Enum script::dom::bindings::import::module::jsapi::mozilla::MemoryOrdering

#[repr(u32)]
pub enum MemoryOrdering {
    Relaxed = 0,
    ReleaseAcquire = 1,
    SequentiallyConsistent = 2,
}

An enum of memory ordering possibilities for atomics.

Memory ordering is the observable state of distinct values in memory. (It’s a separate concept from atomicity, which concerns whether an operation can ever be observed in an intermediate state. Don’t conflate the two!) Given a sequence of operations in source code on memory, it is not always the case that, at all times and on all cores, those operations will appear to have occurred in that exact sequence. First, the compiler might reorder that sequence, if it thinks another ordering will be more efficient. Second, the CPU may not expose so consistent a view of memory. CPUs will often perform their own instruction reordering, above and beyond that performed by the compiler. And each core has its own memory caches, and accesses (reads and writes both) to “memory” may only resolve to out-of-date cache entries – not to the “most recently” performed operation in some global sense. Any access to a value that may be used by multiple threads, potentially across multiple cores, must therefore have a memory ordering imposed on it, for all code on all threads/cores to have a sufficiently coherent worldview.

http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync and http://en.cppreference.com/w/cpp/atomic/memory_order go into more detail on all this, including examples of how each mode works.

Note that for simplicity and practicality, not all of the modes in C++11 are supported. The missing C++11 modes are either subsumed by the modes we provide below, or not relevant for the CPUs we support in Gecko. These three modes are confusing enough as it is!

Variants

Relaxed = 0

ReleaseAcquire = 1

SequentiallyConsistent = 2

Trait Implementations

impl Clone for MemoryOrdering

fn clone(&self) -> MemoryOrdering

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryOrdering

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

Formats the value using the given formatter.

impl Hash for MemoryOrdering

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

where __H: Hasher,

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 PartialEq for MemoryOrdering

fn eq(&self, other: &MemoryOrdering) -> 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 Copy for MemoryOrdering

impl Eq for MemoryOrdering

impl StructuralPartialEq for MemoryOrdering