Struct miri::concurrency::data_race::MemoryCellClocks

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

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

impl MemoryCellClocks

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

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

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

fn write(&self) -> VClock

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

Load the internal atomic memory cells if they exist.

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

Load the internal atomic memory cells if they exist.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

impl Clone for MemoryCellClocks

fn clone(&self) -> MemoryCellClocks

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryCellClocks

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

Formats the value using the given formatter.

impl PartialEq for MemoryCellClocks

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for MemoryCellClocks

impl StructuralPartialEq for MemoryCellClocks

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