Struct miri::concurrency::data_race::MemoryCellClocks

source ·
struct MemoryCellClocks {
    write: (VectorIdx, VTimestamp),
    write_type: NaWriteType,
    read: VClock,
    atomic_ops: Option<Box<AtomicMemoryCellClocks>>,
}
Expand description

Memory Cell vector clock metadata for data-race detection.

Fields§

§write: (VectorIdx, VTimestamp)

The vector-clock timestamp and the thread that did the last non-atomic write. We don’t need a full VClock here, it’s always a single thread and nothing synchronizes, so the effective clock is all-0 except for the thread that did the write.

§write_type: NaWriteType

The type of operation that the write index represents, either newly allocated memory, a non-atomic write or a deallocation of memory.

§read: VClock

The vector-clock of all non-atomic reads that happened since the last non-atomic write (i.e., we join together the “singleton” clocks corresponding to each read). It is reset to zero on each write operation.

§atomic_ops: Option<Box<AtomicMemoryCellClocks>>

Atomic access, acquire, release sequence tracking clocks. For non-atomic memory in the common case this value is set to None.

Implementations§

source§

impl MemoryCellClocks

source

fn new(alloc: VTimestamp, alloc_index: VectorIdx) -> Self

Create a new set of clocks representing memory allocated at a given vector timestamp and index.

source

fn write_was_before(&self, other: &VClock) -> bool

source

fn write(&self) -> VClock

source

fn atomic(&self) -> Option<&AtomicMemoryCellClocks>

Load the internal atomic memory cells if they exist.

source

fn atomic_mut_unwrap(&mut self) -> &mut AtomicMemoryCellClocks

Load the internal atomic memory cells if they exist.

source

fn atomic_access( &mut self, thread_clocks: &ThreadClockSet, size: Size, ) -> Result<&mut AtomicMemoryCellClocks, DataRace>

Load or create the internal atomic memory metadata if it does not exist. Also ensures we do not do mixed-size atomic accesses, and updates the recorded atomic access size.

source

fn load_acquire( &mut self, thread_clocks: &mut ThreadClockSet, index: VectorIdx, access_size: Size, ) -> Result<(), DataRace>

Update memory cell data-race tracking for atomic load acquire semantics, is a no-op if this memory was not used previously as atomic memory.

source

fn load_relaxed( &mut self, thread_clocks: &mut ThreadClockSet, index: VectorIdx, access_size: Size, ) -> Result<(), DataRace>

Update memory cell data-race tracking for atomic load relaxed semantics, is a no-op if this memory was not used previously as atomic memory.

source

fn store_release( &mut self, thread_clocks: &ThreadClockSet, index: VectorIdx, access_size: Size, ) -> Result<(), DataRace>

Update the memory cell data-race tracking for atomic store release semantics.

source

fn store_relaxed( &mut self, thread_clocks: &ThreadClockSet, index: VectorIdx, access_size: Size, ) -> Result<(), DataRace>

Update the memory cell data-race tracking for atomic store relaxed semantics.

source

fn rmw_release( &mut self, thread_clocks: &ThreadClockSet, index: VectorIdx, access_size: Size, ) -> Result<(), DataRace>

Update the memory cell data-race tracking for atomic store release semantics for RMW operations.

source

fn rmw_relaxed( &mut self, thread_clocks: &ThreadClockSet, index: VectorIdx, access_size: Size, ) -> Result<(), DataRace>

Update the memory cell data-race tracking for atomic store relaxed semantics for RMW operations.

source

fn atomic_read_detect( &mut self, thread_clocks: &ThreadClockSet, index: VectorIdx, access_size: Size, ) -> Result<(), DataRace>

Detect data-races with an atomic read, caused by a non-atomic access that does not happen-before the atomic-read.

source

fn atomic_write_detect( &mut self, thread_clocks: &ThreadClockSet, index: VectorIdx, access_size: Size, ) -> Result<(), DataRace>

Detect data-races with an atomic write, either with a non-atomic read or with a non-atomic write.

source

fn read_race_detect( &mut self, thread_clocks: &mut ThreadClockSet, index: VectorIdx, read_type: NaReadType, current_span: Span, ) -> Result<(), DataRace>

Detect races for non-atomic read operations at the current memory cell returns true if a data-race is detected.

source

fn write_race_detect( &mut self, thread_clocks: &mut ThreadClockSet, index: VectorIdx, write_type: NaWriteType, current_span: Span, ) -> Result<(), DataRace>

Detect races for non-atomic write operations at the current memory cell returns true if a data-race is detected.

Trait Implementations§

source§

impl Clone for MemoryCellClocks

source§

fn clone(&self) -> MemoryCellClocks

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for MemoryCellClocks

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl PartialEq for MemoryCellClocks

source§

fn eq(&self, other: &MemoryCellClocks) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl Eq for MemoryCellClocks

source§

impl StructuralPartialEq for MemoryCellClocks

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 96 bytes