Struct AsyncSpscProducer 

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

Asynchronous producer façade for [SegSpsc].

Implementations

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

pub fn capacity(&self) -> usize

Capacity of the underlying queue.

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

Fast-path send without suspension.

Attempts to send an item immediately without blocking. Always notifies waiting consumers on success to prevent missed wakeups.

Performance

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

pub async fn send(&mut self, value: T) -> Result<(), PushError<T>>

Asynchronously sends a single item.

Tries to send immediately; if the queue is full, suspends until space becomes available. The item is held in the Future’s stack frame while waiting, avoiding the need for a pending field in the struct.

Correctness

The item is never dropped or lost:

• On success: item is in the queue
• On Full: item is stored in pending (Future stack frame)
• On Closed: item is returned in the error

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

Safety

The wait_for_space call is safe because:

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

pub async fn send_batch( &mut self, values: &mut Vec<T>, ) -> Result<(), PushError<()>>

Sends an entire Vec, awaiting at most once if the queue fills.

Makes progress whenever space is available, writing as many items as possible in each attempt. Items are moved out of the Vec using move semantics. Notifies consumers after each batch write (not just at the end), allowing the consumer to start processing while the producer is still sending.

On return, the Vec will be empty if all items were sent, or contain only the items that were not sent (if the channel closed).

Efficiency

• Amortizes notification overhead across batch (single notify per write batch)
• Allows progressive consumption (consumer doesn’t wait for entire batch)
• Move semantics (no Clone/Copy required)

pub async fn send_iter<I>(&mut self, iter: I) -> Result<(), PushError<T>>

where I: IntoIterator<Item = T>,

Sends every item from the iterator, awaiting as required.

pub fn close(&mut self)

Closes the queue and wakes any waiters.

Trait Implementations

impl<T, const P: usize, const NUM_SEGS_P2: usize> Sink<T> for AsyncSpscProducer<T, P, NUM_SEGS_P2>

type Error = PushError<T>

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), PushError<T>>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), PushError<T>>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<(), PushError<T>>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<(), PushError<T>>>

Flush any remaining output and close this sink, if necessary.