Struct std::sync::mpmc::array::Channel

pub(crate) struct Channel<T> {
    head: CachePadded<AtomicUsize>,
    tail: CachePadded<AtomicUsize>,
    buffer: Box<[Slot<T>]>,
    cap: usize,
    one_lap: usize,
    mark_bit: usize,
    senders: SyncWaker,
    receivers: SyncWaker,
}

Bounded channel based on a preallocated array.

Fields

head: CachePadded<AtomicUsize>

The head of the channel.

This value is a “stamp” consisting of an index into the buffer, a mark bit, and a lap, but packed into a single usize. The lower bits represent the index, while the upper bits represent the lap. The mark bit in the head is always zero.

Messages are popped from the head of the channel.

tail: CachePadded<AtomicUsize>

The tail of the channel.

This value is a “stamp” consisting of an index into the buffer, a mark bit, and a lap, but packed into a single usize. The lower bits represent the index, while the upper bits represent the lap. The mark bit indicates that the channel is disconnected.

Messages are pushed into the tail of the channel.

buffer: Box<[Slot<T>]>

The buffer holding slots.

cap: usize

The channel capacity.

one_lap: usize

A stamp with the value of { lap: 1, mark: 0, index: 0 }.

mark_bit: usize

If this bit is set in the tail, that means the channel is disconnected.

senders: SyncWaker

Senders waiting while the channel is full.

receivers: SyncWaker

Receivers waiting while the channel is empty and not disconnected.

Implementations

impl<T> Channel<T>

pub(crate) fn with_capacity(cap: usize) -> Self

Creates a bounded channel of capacity cap.

fn start_send(&self, token: &mut Token) -> bool

Attempts to reserve a slot for sending a message.

pub(crate) unsafe fn write(&self, token: &mut Token, msg: T) -> Result<(), T>

Writes a message into the channel.

fn start_recv(&self, token: &mut Token) -> bool

Attempts to reserve a slot for receiving a message.

pub(crate) unsafe fn read(&self, token: &mut Token) -> Result<T, ()>

Reads a message from the channel.

pub(crate) fn try_send(&self, msg: T) -> Result<(), TrySendError<T>>

Attempts to send a message into the channel.

pub(crate) fn send( &self, msg: T, deadline: Option<Instant> ) -> Result<(), SendTimeoutError<T>>

Sends a message into the channel.

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

Attempts to receive a message without blocking.

pub(crate) fn recv( &self, deadline: Option<Instant> ) -> Result<T, RecvTimeoutError>

Receives a message from the channel.

pub(crate) fn len(&self) -> usize

Returns the current number of messages inside the channel.

pub(crate) fn capacity(&self) -> Option<usize>

Returns the capacity of the channel.

pub(crate) fn disconnect_senders(&self) -> bool

Disconnects senders and wakes up all blocked receivers.

Returns true if this call disconnected the channel.

pub(crate) unsafe fn disconnect_receivers(&self) -> bool

Disconnects receivers and wakes up all blocked senders.

Returns true if this call disconnected the channel.

Safety

May only be called once upon dropping the last receiver. The destruction of all other receivers must have been observed with acquire ordering or stronger.

unsafe fn discard_all_messages(&self, tail: usize)

Discards all messages.

tail should be the current (and therefore last) value of tail.

Panicking

If a destructor panics, the remaining messages are leaked, matching the behaviour of the unbounded channel.

Safety

This method must only be called when dropping the last receiver. The destruction of all other receivers must have been observed with acquire ordering or stronger.

pub(crate) fn is_disconnected(&self) -> bool

Returns true if the channel is disconnected.

pub(crate) fn is_empty(&self) -> bool

Returns true if the channel is empty.

pub(crate) fn is_full(&self) -> bool

Returns true if the channel is full.