Struct BoundedQueue

pub struct BoundedQueue<T, I, RING, const SEAL: usize>
where
    I: Sealed,
{ /* private fields */ }

The bounded queue type from the ACM paper. This uses two SCQ rings internally, one that keeps track of free indices and the other that keeps track of the allocated indices.

Implementations

impl<T, const N: usize> BoundedQueue<T, [UnsafeCell<Option<T>>; N], [CachePadded<AtomicUsize>; N], 0>

pub fn new_const() -> Self

A helper function for creating constant bounded queues, will automatically try to calculate the correct order.

Panics

This function will panic if the value is not a power of two and also if the value is zero as we cannot initialize zero sized constant bounded queues.

Example

use lfqueue::{ConstBoundedQueue, ScqError};

let queue = ConstBoundedQueue::<usize, 4>::new_const();
assert!(queue.enqueue(2).is_ok());
assert!(queue.enqueue(3).is_ok());
assert_eq!(queue.enqueue(4), Err(ScqError::QueueFull));

impl<T, I, P, const S: usize> BoundedQueue<T, I, P, S>

where I: AsRef<[UnsafeCell<Option<T>>]> + Sealed, P: AsRef<[CachePadded<AtomicUsize>]> + Sealed,

pub const MAX_ORDER: usize = 63usize

pub const MIN_ORDER: usize = 0usize

pub fn capacity(&self) -> usize

Returns the capacity of the bounded ring. This is 2 ^ order.

Example

use lfqueue::ConstBoundedQueue;
 
let value = ConstBoundedQueue::<usize, 4>::new_const();
assert_eq!(value.capacity(), 2);

pub fn enqueue(&self, item: T) -> Result<(), ScqError>

Enqueues an element to the bounded queue.

Example

use lfqueue::AllocBoundedQueue;

let queue = AllocBoundedQueue::<usize>::new(2);
assert_eq!(queue.enqueue(4), Ok(()));
assert_eq!(queue.dequeue(), Some(4));

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

Dequeues an element from the bounded queue.

Example

use lfqueue::AllocBoundedQueue;

let queue = AllocBoundedQueue::<usize>::new(2);
assert_eq!(queue.enqueue(4), Ok(()));
assert_eq!(queue.dequeue(), Some(4));

impl<T, const MODE: usize> BoundedQueue<T, Box<[UnsafeCell<Option<T>>]>, Box<[CachePadded<AtomicUsize>]>, MODE>

pub fn new(size: usize) -> Self

Allocates a bounded queue, this method backs most of he

Trait Implementations

impl<T: Debug, I, RING: Debug, const SEAL: usize> Debug for BoundedQueue<T, I, RING, SEAL>

where I: Sealed + Debug,

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

Formats the value using the given formatter.

impl<T: Send + Sync, I: Sealed, R, const SEAL: usize> Send for BoundedQueue<T, I, R, SEAL>

impl<T: Send + Sync, I: Sealed, R, const SEAL: usize> Sync for BoundedQueue<T, I, R, SEAL>