Struct AsyncSpscConsumer 

pub struct AsyncSpscConsumer<T, const P: usize, const NUM_SEGS_P2: usize> { /* private fields */ }

Asynchronous consumer façade for [SegSpsc].

Implementations

impl<T, const P: usize, const NUM_SEGS_P2: usize> AsyncSpscConsumer<T, P, NUM_SEGS_P2>

pub fn capacity(&self) -> usize

Capacity of the underlying queue.

pub fn try_recv(&self) -> Result<T, PopError>

Attempts to receive without awaiting.

Always notifies waiting producers on success to prevent missed wakeups.

Performance

• Success path: ~5-15ns (queue read + notify check)
• Notify overhead: ~1-2ns when no producer waiting

pub async fn recv(&mut self) -> Result<T, PopError>

Asynchronously receives a single item.

Tries to receive immediately; if the queue is empty, suspends until an item becomes available or the channel is closed.

Correctness

The predicate is called on each wakeup to retry receiving. The wait_for_items future uses the double-check pattern internally to prevent missed wakeups.

Safety

The wait_for_items call is safe because:

• AsyncSpscConsumer is !Clone and !Sync (single-threaded access)
• SPSC guarantees only one consumer thread
• Therefore, no concurrent calls to register or wait_until on item_waiter

pub async fn recv_batch(&mut self, dst: &mut [T]) -> Result<usize, PopError>

Receives up to dst.len() items.

Makes progress whenever items are available, reading as many as possible in each attempt. Returns when the buffer is full or the channel is closed. Notifies producers after each batch read to free up space progressively.

Returns

• Ok(count): Number of items read (may be less than dst.len())
• Err(PopError::Closed): Channel closed and no items available

Efficiency

• Amortizes notification overhead across batch (single notify per read batch)
• Allows progressive production (producer can send more while consumer processes)

Trait Implementations

impl<T, const P: usize, const NUM_SEGS_P2: usize> Stream for AsyncSpscConsumer<T, P, NUM_SEGS_P2>

type Item = T

Values yielded by the stream.

fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<T>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.