Enum MemoryOrdering 

#[non_exhaustive]
pub enum MemoryOrdering {
    Relaxed,
    Acquire,
    Release,
    AcqRel,
    SeqCst,
    GridSync,
}

Memory ordering attached to atomic and barrier operations.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Relaxed

No synchronization beyond atomicity of the operation.

Acquire

Subsequent reads observe writes released by another participant.

Release

Prior writes become visible to acquiring participants.

AcqRel

Acquire and release semantics in one operation.

SeqCst

Single total order across sequentially consistent operations within the issuing thread’s workgroup.

GridSync

Cross-grid synchronization. Every thread in the dispatch waits here, and every prior write is globally visible after the barrier returns. This is strictly stronger than SeqCst, which only synchronizes within a workgroup. GridSync is required when a fused kernel has an arm with divergent stores (e.g. if invocation_id == K { store ... }) followed by an arm that reads what was stored — without grid-level sync, threads in non-K blocks observe stale state. Backends that lack a native grid barrier (workgroup-only fences, no cooperative launch) must lower this to a kernel-split: emit two separate dispatches that share the underlying buffers.

Implementations

impl MemoryOrdering

pub const fn wire_tag(self) -> u8

Stable wire tag for this ordering.

pub fn from_wire_tag(tag: u8) -> Result<Self, String>

Decode a stable wire tag.

Errors

Returns an actionable error when tag is not assigned to a memory ordering in this schema.

pub const fn is_valid_for_atomic_rmw(self) -> bool

Whether this ordering is valid for an atomic RMW operation. GridSync is barrier-only and not a valid atomic ordering.

pub const fn is_valid_for_barrier(self) -> bool

Whether this ordering is valid for a barrier.

pub const fn requires_grid_sync(self) -> bool

Whether this ordering requires cross-grid synchronization. Backends with a native grid barrier emit one instruction; backends without must split the kernel.

Trait Implementations

impl Clone for MemoryOrdering

fn clone(&self) -> MemoryOrdering

Returns a duplicate 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

Formats the value using the given formatter.

impl Default for MemoryOrdering

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MemoryOrdering

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for MemoryOrdering

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for MemoryOrdering

impl Eq for MemoryOrdering

impl StructuralPartialEq for MemoryOrdering