Struct miri::concurrency::data_race::MemoryCellClocks

struct MemoryCellClocks {
    write: VTimestamp,
    write_index: VectorIdx,
    write_type: WriteType,
    read: VClock,
    atomic_ops: Option<Box<AtomicMemoryCellClocks>>,
}

Memory Cell vector clock metadata for data-race detection.

Fields

write: VTimestamp

The vector-clock timestamp of the last write corresponding to the writing threads timestamp.

write_index: VectorIdx

The identifier of the vector index, corresponding to a thread that performed the last write operation.

write_type: WriteType

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 the timestamp of the last read operation performed by a thread since the last write operation occurred. It is reset to zero on each write operation.

atomic_ops: Option<Box<AtomicMemoryCellClocks>>

Atomic 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 atomic(&self) -> Option<&AtomicMemoryCellClocks>

Load the internal atomic memory cells if they exist.

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

Load or create the internal atomic memory metadata if it does not exist.

fn load_acquire( &mut self, thread_clocks: &mut ThreadClockSet, index: VectorIdx ) -> 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 race_free_with_atomic(&self, thread_clocks: &ThreadClockSet) -> bool

Checks if the memory cell access is ordered with all prior atomic reads and writes

fn load_relaxed( &mut self, thread_clocks: &mut ThreadClockSet, index: VectorIdx ) -> 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 ) -> Result<(), DataRace>

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

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

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

fn rmw_release( &mut self, thread_clocks: &ThreadClockSet, index: VectorIdx ) -> 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 ) -> 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 ) -> Result<(), DataRace>

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

fn atomic_write_detect( &mut self, thread_clocks: &ThreadClockSet, index: VectorIdx ) -> 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, 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: WriteType, 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<MemoryCellClocks> for MemoryCellClocks

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

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

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.

impl Eq for MemoryCellClocks

impl StructuralEq 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