Enum MemOrder 

pub enum MemOrder {
    NotAtomic,
    Relaxed,
    Acquire,
    Release,
    AcqRel,
    SeqCst,
}

How strongly an atomic operation is ordered against everything around it.

These are C11’s, minus consume, which every compiler in existence widens to acquire because nobody can implement it as specified and the standard committee has said so.

Variants

NotAtomic

Not atomic at all, which is what an ordinary load or store is.

Relaxed

Atomic, with no ordering against anything else.

Acquire

Nothing after this in program order moves before it.

Release

Nothing before this in program order moves after it.

AcqRel

Both, for a read-modify-write.

SeqCst

Both, and a single total order over every sequentially consistent operation.

Implementations

impl MemOrder

pub const fn name(self) -> &'static str

The textual form.

pub fn from_name(name: &str) -> Option<Self>

The ordering with that name, if there is one.

pub fn all() -> impl Iterator<Item = Self>

Every ordering, weakest first.

pub const fn is_valid_for_load(self) -> bool

Whether this ordering can be asked of a load.

A load cannot release, because there is nothing it published.

pub const fn is_valid_for_store(self) -> bool

Whether this ordering can be asked of a store.

A store cannot acquire, because it read nothing to synchronise with.

pub const fn is_valid_for_rmw(self) -> bool

Whether this ordering can be asked of a read-modify-write, which is any of them.

pub const fn is_release(self) -> bool

Whether this ordering publishes everything before it, which is the release half.

Asked by the race detector rather than by the back end. A release is a synchronization edge in the sense of spec/safe-memory/09-type-init-and-races.md section 9.5, so it is where a thread’s clock has to be written down for whoever takes the other end.

pub const fn is_acquire(self) -> bool

Whether this ordering takes everything published before it, which is the acquire half.

The other end of MemOrder::is_release. acq_rel and seq_cst answer yes to both, which is what makes a read-modify-write one edge in and one edge out.

Trait Implementations

impl Clone for MemOrder

fn clone(&self) -> MemOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MemOrder

impl Debug for MemOrder

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

Formats the value using the given formatter.

impl Default for MemOrder

fn default() -> MemOrder

Returns the “default value” for a type.

impl Display for MemOrder

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

Formats the value using the given formatter.

impl Eq for MemOrder

impl Hash for MemOrder

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for MemOrder

fn cmp(&self, other: &MemOrder) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for MemOrder

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for MemOrder

fn partial_cmp(&self, other: &MemOrder) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for MemOrder