Struct mpmcpq::PriorityQueue

pub struct PriorityQueue<M, P>where
    M: Send,
    P: PartialOrd + Ord,{ /* private fields */ }

A queue which orders messages by priority

Implementations

impl<M, P> PriorityQueue<M, P>where
    M: Send,
    P: PartialOrd + Ord,

pub fn new() -> PriorityQueue<M, P>

Create a new PriorityQueue

Examples found in repository

src/mpmcpq.rs (line 27)

    fn default() -> Self {
        Self::new()
    }

pub fn sync(&self, stash: &mut Stash<'_, M, P>)

Inserts all elements from the stash to the PriorityQueue, empties stash. This function waits until the on the queue is locked.

Examples found in repository

src/stash.rs (line 62)

    fn drop(&mut self) {
        if let Some(pq) = self.pq {
            pq.sync(self);
        }
    }

pub fn send(&self, message: M, prio: P, stash: &mut Stash<'_, M, P>)

Pushes an message with prio onto the queue, uses a Stash as temporary storage when the queue is contended. Drains the stash in the uncontended case. This function does not wait for the lock on the queue.

Examples found in repository

src/mpmcpq.rs (line 144)

    pub fn send_batched(&self, message: M, prio: P, batch_size: usize, stash: &mut Stash<M, P>) {
        if stash.len() <= batch_size {
            // append to the stash
            self.send_stashed(message, prio, stash);
        } else {
            // try to send
            self.send(message, prio, stash);
        }
    }

pub fn send_sync(&self, message: M, prio: P, stash: &mut Stash<'_, M, P>)

Pushes a message with prio onto the queue, drains the Stash first. This function waits until the on the queue is locked.

pub fn send_stashed(&self, message: M, prio: P, stash: &mut Stash<'_, M, P>)

Pushes an message to the Stash. will not try to send data to the queue. Use this to combine some messages together before calling sync() to send them. This function does not wait for the lock on the queue.

Examples found in repository

src/mpmcpq.rs (line 141)

    pub fn send_batched(&self, message: M, prio: P, batch_size: usize, stash: &mut Stash<M, P>) {
        if stash.len() <= batch_size {
            // append to the stash
            self.send_stashed(message, prio, stash);
        } else {
            // try to send
            self.send(message, prio, stash);
        }
    }

pub fn send_batched(
    &self,
    message: M,
    prio: P,
    batch_size: usize,
    stash: &mut Stash<'_, M, P>
)

Combines the above to collect at least ‘batch_size’ messages in the stash before trying to send them out. Use this to batch some messages together before calling sync() to send them. This function does not wait for the lock on the queue.

pub fn send_nostash(&self, message: M, prio: P)

Pushes a message with prio onto the queue without using a stash. This function waits until the on the queue is locked. No stash involved, this should be not used with threads that have a stash since it won’t get drained first. Can be used to send synchronous out-of-band message bypassing the stash.

pub fn recv_guard(&self) -> ReceiveGuard<'_, M, P>

Returns the smallest message from a queue. This message is wraped in a ReceiveGuard/Message

pub fn try_recv_guard(&self) -> Option<ReceiveGuard<'_, M, P>>

Try to get the smallest message from a queue. Will return Some when a message is available. This will not wait on the queue lock.

pub fn maybe_recv_guard(&self) -> Option<ReceiveGuard<'_, M, P>>

Try to get the smallest message from a queue. Will return Some when a message is available. This will wait on the queue lock but return None when the queue is empty.

pub fn recv(&self) -> Message<M, P>

Returns the smallest message from a queue.

pub fn try_recv(&self) -> Option<Message<M, P>>

Try to get the smallest message from a queue. Will return Some when a message is available. This will not wait on the queue lock.

pub fn maybe_recv(&self) -> Option<Message<M, P>>

Try to get the smallest message from a queue. Will return Some when a message is available. This will wait on the queue lock but return None when the queue is empty.

pub fn in_progress(&self) -> usize

Returns the number of messages in flight. This is the .len() plus any receiver that still holds a guard. Note: Informal only, this method will be racy when other threads modify the PriorityQueue.

pub fn is_empty(&self) -> bool

Returns true when the Stash contains no messages. Note: Informal only, this method will be racy when other threads modify the PriorityQueue.

pub fn len(&self) -> usize

Returns the number of messages in the stash. Note: Informal only, this method will be racy when other threads modify the PriorityQueue.

pub fn reserve(&self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the PriorityQueue.

Trait Implementations

impl<M, P> Debug for PriorityQueue<M, P>where
    M: Send + Debug,
    P: PartialOrd + Ord + Debug,

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

Formats the value using the given formatter.

impl<M, P> Default for PriorityQueue<M, P>where
    M: Send,
    P: PartialOrd + Ord,

fn default() -> Self

Returns the “default value” for a type.