Struct SpscRingBuffer 

pub struct SpscRingBuffer<T> { /* private fields */ }

Zero-copy SPSC ring buffer with proper memory ordering

Safety

This type is only safe to use when:

• Only one producer thread exists
• Only one consumer thread exists
• Memory is properly aligned for the element type T

Implementations

impl<T> SpscRingBuffer<T>

pub fn new(config: RingConfig) -> Self

Create a new SPSC ring buffer with the given configuration

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

Push an element into the ring buffer

Returns Ok(()) on success, or Err(value) if the ring is full. When full, the producer should wait/backpressure until space is available.

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

Pop an element from the ring buffer

Returns Some(value) on success, or None if the ring is empty.

pub fn len(&self) -> usize

Get the current number of elements in the ring

pub fn is_empty(&self) -> bool

Check if the ring is empty

pub fn capacity(&self) -> usize

Get the configured capacity

pub fn overflow_count(&self) -> usize

Get overflow count for backpressure monitoring

pub fn empty_count(&self) -> usize

Get empty count for backpressure monitoring

pub fn should_backpressure(&self) -> bool

Check if backpressure should be applied (ring >= threshold)

pub fn write_available(&self) -> usize

Number of elements that can currently be pushed without blocking.

pub fn read_available(&self) -> usize

Number of elements currently available to pop (best-effort, not a snapshot).

pub fn wait_for_space(&self)

Wait for space to become available

Uses exponential backoff: spins with PAUSE up to 256 iterations, then transitions to OS yield to avoid starving the consumer.

pub fn wait_for_data(&self)

Wait for an element to become available

Uses exponential backoff: spins with PAUSE up to 256 iterations, then transitions to OS yield to avoid starving the producer.

pub fn push_batch(&self, slice: &[T]) -> usize

where T: Copy,

Push a batch of elements, returning the number successfully pushed.

Stops early if the ring becomes full. This amortizes atomic store overhead across multiple elements: only two atomic stores (tail + cached_head) for up to slice.len() pushes.

Uses prefetching to reduce cache misses on write path.

pub fn pop_batch(&self, out: &mut [MaybeUninit<T>]) -> usize

Pop up to count elements into the provided mutable slice, returning the number of elements actually popped.

Uses MaybeUninit to avoid zero-initialisation overhead. Uses prefetching to reduce cache misses on read path.

Trait Implementations

impl<T: Debug> Debug for SpscRingBuffer<T>

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

Formats the value using the given formatter.

impl<T> Drop for SpscRingBuffer<T>

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: Send> Send for SpscRingBuffer<T>

impl<T: Send> Sync for SpscRingBuffer<T>