Enum std::sync::atomic::Ordering

pub enum Ordering {
    Relaxed,
    Release,
    Acquire,
    AcqRel,
    SeqCst,
    // some variants omitted
}

Atomic memory orderings

Memory orderings limit the ways that both the compiler and CPU may reorder instructions around atomic operations. At its most restrictive, "sequentially consistent" atomics allow neither reads nor writes to be moved either before or after the atomic operation; on the other end "relaxed" atomics allow all reorderings.

Rust's memory orderings are the same as LLVM's.

For more information see the nomicon.

Variants

Relaxed

No ordering constraints, only atomic operations.

Corresponds to LLVM's Monotonic ordering.

Release

When coupled with a store, all previous writes become visible to the other threads that perform a load with Acquire ordering on the same value.

Acquire

When coupled with a load, all subsequent loads will see data written before a store with Release ordering on the same value in other threads.

AcqRel

Has the effects of both Acquire and Release together.

This ordering is only applicable for operations that combine both loads and stores.

For loads it uses Acquire ordering. For stores it uses the Release ordering.

SeqCst

Like AcqRel with the additional guarantee that all threads see all sequentially consistent operations in the same order.

Trait Implementations

impl Copy for Ordering

impl Debug for Ordering

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl Clone for Ordering

fn clone(&self) -> Ordering

Returns a copy of the value.

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

Performs copy-assignment from source.