Struct StaticRing 

pub struct StaticRing<T, const N: usize> { /* private fields */ }

No-alloc, const-capacity bounded ring with lock-free MPMC access — the bare-metal tier of Ring. The [Cell<T>; N] buffer lives inline (no heap), so it compiles and runs where alloc is unavailable (DPDK/SPDK/embedded). Same Vyukov algorithm as Ring — both delegate to the shared cells_* fns, so loom’s model-check of that algorithm covers this too.

N MUST be a power of two >= 2 (asserted in StaticRing::new); the protocol needs it for the pos & (N - 1) slot index.

new is const, so the whole no-alloc tier can back a static on bare metal with no heap and no lazy OnceCell/runtime init: static RING: StaticRing<T, N> = StaticRing::new();. StaticBoundedQueue and the pipe-forms StaticSinkFront inherit that through here.

Implementations

impl<T, const N: usize> StaticRing<T, N>

pub const fn new() -> Self

Construct an empty ring, seeding each cell’s sequence to its own index (the Vyukov empty-slot test is seq == pos, slot by slot). const, so a bare-metal caller can put one straight in a static; a non-power-of-two N then fails the BUILD rather than the first call.

loom’s atomics register with the model checker on construction and are therefore not const-constructible, so the --features loom build gets the same body without const (same cfg split as write_cell above).

pub fn push(&self, record: T) -> Result<(), T>

Push one record; Err(record) if full (no blocking). MPMC-safe.

pub fn dequeue(&self) -> Option<T>

Pop one record in FIFO order; None if empty. MPMC-safe.

pub fn len(&self) -> usize

Items currently buffered (snapshot, not linearizable).

pub fn is_empty(&self) -> bool

pub const fn capacity(&self) -> usize

Trait Implementations

impl<T, const N: usize> Default for StaticRing<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const N: usize> Drop for StaticRing<T, N>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T, const N: usize> RingStorage for StaticRing<T, N>

type Item = T

The queued element.

fn push(&self, item: T) -> Result<(), T>

Push one item; on a full ring the item is handed back via Err.

fn dequeue(&self) -> Option<T>

Pop the oldest item, or None when empty.

fn len(&self) -> usize

Snapshot of the number of queued items (not linearizable).

fn capacity(&self) -> usize

The ring’s capacity (a power of two).

fn is_empty(&self) -> bool

True when the ring holds nothing (snapshot).

fn drain_into(&self, out: &mut [Self::Item]) -> usize

Pop up to out.len() items FIFO into out, returning the count filled. Default is a dequeue loop; the heap Ring overrides it with its prefetching batch Drainer.

impl<T: Send, const N: usize> Send for StaticRing<T, N>

impl<T: Send, const N: usize> Sync for StaticRing<T, N>