orx-concurrent-queue 1.2.0

use crate::{
    atomic_utils::{comp_exch, comp_exch_weak},
    common_traits::iter::{QueueIterOfMut, QueueIterOfRef, QueueIterOwned},
    write_permit::WritePermit,
};
use core::{
    marker::PhantomData,
    ops::Range,
    sync::atomic::{AtomicUsize, Ordering},
};
use orx_fixed_vec::{ConcurrentFixedVec, FixedVec};
use orx_pinned_vec::{ConcurrentPinnedVec, IntoConcurrentPinnedVec};
use orx_split_vec::{ConcurrentSplitVec, Doubling, Linear, SplitVec, prelude::PseudoDefault};

type DefaultPinnedVec<T> = SplitVec<T, Doubling>;

/// Default concurrent pinned vector used as the underlying storage of the concurrent queue.
pub type DefaultConPinnedVec<T> = <DefaultPinnedVec<T> as IntoConcurrentPinnedVec<T>>::ConPinnedVec;

impl<T> Default for ConcurrentQueue<T, DefaultConPinnedVec<T>>
where
    T: Send,
{
    fn default() -> Self {
        Self::new()
    }
}

impl<T> ConcurrentQueue<T, DefaultConPinnedVec<T>>
where
    T: Send,
{
    /// Creates a new empty concurrent queue.
    ///
    /// This queue is backed with default concurrent pinned vec, which is the concurrent version of [`SplitVec`] with [`Doubling`] growth
    /// (shorthand for [`with_doubling_growth`]).
    ///
    /// In order to create a concurrent queue backed with a particular [`PinnedVec`], you may use the `From` trait.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    /// use orx_split_vec::{SplitVec, Doubling, Linear};
    /// use orx_fixed_vec::FixedVec;
    ///
    /// let bag: ConcurrentQueue<usize> = ConcurrentQueue::new();
    /// // equivalent to:
    /// let bag: ConcurrentQueue<usize> = ConcurrentQueue::with_doubling_growth();
    ///
    /// // in order to create a queue from a different pinned vec, use into, rather than new:
    /// let bag: ConcurrentQueue<usize, _> = SplitVec::with_linear_growth_and_fragments_capacity(10, 64).into();
    /// let bag: ConcurrentQueue<usize, _> = FixedVec::new(1000).into();
    /// ```
    ///
    /// [`SplitVec`]: orx_split_vec::SplitVec
    /// [`Doubling`]: orx_split_vec::Doubling
    /// [`PinnedVec`]: orx_pinned_vec::PinnedVec
    /// [`with_doubling_growth`]: ConcurrentQueue::with_doubling_growth
    pub fn new() -> Self {
        SplitVec::with_doubling_growth_and_max_concurrent_capacity().into()
    }

    /// Creates a new empty concurrent queue.
    ///
    /// This queue is backed with default concurrent pinned vec, which is the concurrent version of [`SplitVec`] with [`Doubling`] growth.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    /// use orx_split_vec::{SplitVec, ConcurrentSplitVec, Doubling, Linear};
    /// use orx_fixed_vec::{FixedVec, ConcurrentFixedVec};
    ///
    /// let bag: ConcurrentQueue<usize> = ConcurrentQueue::new();
    /// // equivalent to:
    /// let bag: ConcurrentQueue<usize> = ConcurrentQueue::with_doubling_growth();
    /// ```
    ///
    /// [`SplitVec`]: orx_split_vec::SplitVec
    /// [`Doubling`]: orx_split_vec::Doubling
    /// [`PinnedVec`]: orx_pinned_vec::PinnedVec
    /// [`with_doubling_growth`]: ConcurrentQueue::with_doubling_growth
    pub fn with_doubling_growth() -> Self {
        SplitVec::with_doubling_growth_and_max_concurrent_capacity().into()
    }
}

impl<T> ConcurrentQueue<T, ConcurrentFixedVec<T>>
where
    T: Send,
{
    /// Creates a new empty concurrent queue.
    ///
    /// This queue is backed with concurrent concurrent version of [`FixedVec`].
    ///
    /// # Panics
    ///
    /// This method does not panic; however, the queue created with a fixed capacity vector
    /// might panic during growth.
    /// If the total number of elements pushed to this queue exceeds the parameter `fixed_capacity`,
    /// the vector cannot grow concurrently and panics.
    /// Please use the other variants to work with a thread safe dynamic capacity.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    /// use orx_fixed_vec::{FixedVec};
    ///
    /// let bag: ConcurrentQueue<usize, _> = ConcurrentQueue::with_fixed_capacity(1024);
    /// // equivalent to:
    /// let bag: ConcurrentQueue<usize, _> = FixedVec::new(1024).into();
    /// ```
    ///
    /// [`FixedVec`]: orx_fixed_vec::FixedVec
    pub fn with_fixed_capacity(fixed_capacity: usize) -> Self {
        FixedVec::new(fixed_capacity).into()
    }
}

impl<T> ConcurrentQueue<T, ConcurrentSplitVec<T, Linear>>
where
    T: Send,
{
    /// Creates a new empty concurrent queue.
    ///
    /// This queue is backed with concurrent concurrent version of [`SplitVec`] with [`Linear`] growth.
    ///
    /// # Panics
    ///
    /// This method does not panic; however, the queue created with a linear growth vector
    /// might panic during growth.
    /// Unlike `FixedVec` backed queue created by [`with_fixed_capacity`], this queue does not pre-allocate;
    /// however, it has an upper bound on how much it can grow.
    /// This upper bound is determined as follows:
    ///
    /// * Each fragment of the split vector will have a capacity of  `2 ^ constant_fragment_capacity_exponent`.
    /// * And the concurrent split vector can have at most `fragments_capacity` capacity.
    ///
    /// Therefore, this queue cannot grow beyond `fragments_capacity * 2 ^ constant_fragment_capacity_exponent` elements.
    ///
    /// For instance, if the queue is created with
    /// * `with_linear_growth(10, 64)`, its maximum capacity will be 64x1024 = 65,536,
    /// * `with_linear_growth(10, 1024)`, its maximum capacity will be 64x1024 = 1,048,576.
    ///
    /// If the total number of elements pushed to this queue exceeds this upper bound,
    /// the vector cannot grow concurrently and panics.
    ///
    /// [`with_fixed_capacity`]: ConcurrentQueue::with_fixed_capacity
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    /// use orx_split_vec::{SplitVec};
    ///
    /// let bag: ConcurrentQueue<usize, _> = ConcurrentQueue::with_linear_growth(10, 64);
    /// // equivalent to:
    /// let bag: ConcurrentQueue<usize, _> = SplitVec::with_linear_growth_and_fragments_capacity(10, 64).into();
    /// ```
    pub fn with_linear_growth(
        constant_fragment_capacity_exponent: usize,
        fragments_capacity: usize,
    ) -> Self {
        SplitVec::with_linear_growth_and_fragments_capacity(
            constant_fragment_capacity_exponent,
            fragments_capacity,
        )
        .into()
    }
}

/// A high performance and convenient thread safe queue that can concurrently
/// grow and shrink with [`push`], [`extend`], [`pop`] and [`pull`] capabilities.
///
/// [`push`]: crate::ConcurrentQueue::push
/// [`extend`]: crate::ConcurrentQueue::extend
/// [`pop`]: crate::ConcurrentQueue::pop
/// [`pull`]: crate::ConcurrentQueue::pull
///
/// # Examples
///
/// The following example demonstrates a basic usage of the queue within a synchronous program.
/// Note that push, extend, pop and pull methods can be called with a shared reference `&self`.
/// This allows to use the queue conveniently in a concurrent program.
///
/// ```
/// use orx_concurrent_queue::ConcurrentQueue;
///
/// let queue = ConcurrentQueue::new();
///
/// queue.push(0); // [0]
/// queue.push(1); // [0, 1]
///
/// let x = queue.pop(); // [1]
/// assert_eq!(x, Some(0));
///
/// queue.extend(2..7); // [1, 2, 3, 4, 5, 6]
///
/// let x: Vec<_> = queue.pull(4).unwrap().collect(); // [5, 6]
/// assert_eq!(x, vec![1, 2, 3, 4]);
///
/// assert_eq!(queue.len(), 2);
///
/// let vec = queue.into_inner();
/// assert_eq!(vec, vec![5, 6]);
/// ```
/// The following example demonstrates the main purpose of the concurrent queue:
/// to simultaneously push to and pop from the queue.
/// This enables a parallel program where tasks can be handled by multiple threads,
/// while at the same time, new tasks can be created and dynamically added to the queue.
///
/// In the following example, the queue is created with three pre-populated tasks.
/// Every task might potentially lead to new tasks.
/// These new tasks are also added to the back of the queue,
/// to be popped later and potentially add new tasks to the queue.
///
/// ```
/// use orx_concurrent_queue::ConcurrentQueue;
/// use std::sync::atomic::{AtomicUsize, Ordering};
///
/// struct Task {
///     micros: usize,
/// }
///
/// impl Task {
///     fn perform(&self) {
///         use std::{thread::sleep, time::Duration};
///         sleep(Duration::from_micros(self.micros as u64));
///     }
///
///     fn child_tasks(&self) -> impl ExactSizeIterator<Item = Task> {
///         let range = match self.micros < 5 {
///             true => 0..0,
///             false => 0..self.micros,
///         };
///
///         range.rev().take(5).map(|micros| Self { micros })
///     }
/// }
///
/// let queue = ConcurrentQueue::new();
/// for micros in [10, 15, 10] {
///     queue.push(Task { micros });
/// }
///
/// let num_performed_tasks = AtomicUsize::new(queue.len());
///
/// let num_threads = 8;
/// std::thread::scope(|s| {
///     for _ in 0..num_threads {
///         s.spawn(|| {
///             // keep popping a task from front of the queue
///             // as long as the queue is not empty
///             while let Some(task) = queue.pop() {
///                 // create children tasks, add to back
///                 queue.extend(task.child_tasks());
///
///                 // perform the popped task
///                 task.perform();
///
///                 _ = num_performed_tasks.fetch_add(1, Ordering::Relaxed);
///             }
///         });
///     }
/// });
///
/// assert_eq!(num_performed_tasks.load(Ordering::Relaxed), 5046);
/// ```
pub struct ConcurrentQueue<T, P = DefaultConPinnedVec<T>>
where
    T: Send,
    P: ConcurrentPinnedVec<T>,
{
    vec: P,
    phantom: PhantomData<T>,
    written: AtomicUsize,
    write_reserved: AtomicUsize,
    popped: AtomicUsize,
}

unsafe impl<T, P> Sync for ConcurrentQueue<T, P>
where
    T: Send,
    P: ConcurrentPinnedVec<T>,
{
}

impl<T, P> Drop for ConcurrentQueue<T, P>
where
    T: Send,
    P: ConcurrentPinnedVec<T>,
{
    fn drop(&mut self) {
        if core::mem::needs_drop::<T>() {
            let popped = self.popped.load(Ordering::Relaxed);
            let written = self.written.load(Ordering::Relaxed);
            for i in popped..written {
                let ptr = unsafe { self.ptr(i) };
                unsafe { ptr.drop_in_place() };
            }
        }
        unsafe { self.vec.set_pinned_vec_len(0) };
    }
}

impl<T, P> From<P> for ConcurrentQueue<T, P::ConPinnedVec>
where
    T: Send,
    P: IntoConcurrentPinnedVec<T>,
{
    fn from(vec: P) -> Self {
        Self {
            phantom: PhantomData,
            written: vec.len().into(),
            write_reserved: vec.len().into(),
            popped: 0.into(),
            vec: vec.into_concurrent(),
        }
    }
}

impl<T, P> ConcurrentQueue<T, P>
where
    T: Send,
    P: ConcurrentPinnedVec<T>,
{
    /// Converts the bag into the underlying pinned vector.
    ///
    /// Whenever the second generic parameter is omitted, the underlying pinned vector is [`SplitVec`] with [`Doubling`] growth.
    ///
    /// [`SplitVec`]: orx_split_vec::SplitVec
    /// [`Doubling`]: orx_split_vec::Doubling
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    /// use orx_split_vec::SplitVec;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.push(0); // [0]
    /// queue.push(1); // [0, 1]
    /// _ = queue.pop(); // [1]
    /// queue.extend(2..7); // [1, 2, 3, 4, 5, 6]
    /// _ = queue.pull(4).unwrap(); // [5, 6]
    ///
    /// let vec: SplitVec<i32> = queue.into_inner();
    /// assert_eq!(vec, vec![5, 6]);
    ///
    /// let vec: Vec<i32> = vec.to_vec();
    /// assert_eq!(vec, vec![5, 6]);
    /// ```
    pub fn into_inner(mut self) -> <P as ConcurrentPinnedVec<T>>::P
    where
        <P as ConcurrentPinnedVec<T>>::P:
            PseudoDefault + IntoConcurrentPinnedVec<T, ConPinnedVec = P>,
    {
        let vec: <P as ConcurrentPinnedVec<T>>::P = PseudoDefault::pseudo_default();
        let mut vec = vec.into_concurrent();
        core::mem::swap(&mut self.vec, &mut vec);

        let a = self.popped.load(Ordering::Relaxed);
        let b = self.written.load(Ordering::Relaxed);
        let len = b.saturating_sub(a);
        if a > 0 {
            let src = unsafe { vec.ptr_iter_unchecked(a..b) };
            let dst = unsafe { vec.ptr_iter_unchecked(0..len) };
            for (s, d) in src.zip(dst) {
                unsafe { d.write(s.read()) };
            }
        }

        for x in [&self.written, &self.write_reserved, &self.popped] {
            x.store(0, Ordering::Relaxed);
        }

        unsafe { vec.into_inner(len) }
    }

    // shrink

    /// Pops and returns the element in the front of the queue; returns None if the queue is empty.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::*;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.extend(1..4);
    /// assert_eq!(queue.pop(), Some(1));
    /// assert_eq!(queue.pop(), Some(2));
    /// assert_eq!(queue.pop(), Some(3));
    /// assert_eq!(queue.pop(), None);
    /// ```
    pub fn pop(&self) -> Option<T> {
        let idx = self.popped.fetch_add(1, Ordering::Relaxed);

        loop {
            let written = self.written.load(Ordering::Acquire);
            match idx < written {
                true => return Some(unsafe { self.ptr(idx).read() }),
                false => {
                    if comp_exch(&self.popped, idx + 1, idx).is_ok() {
                        return None;
                    }
                }
            }
        }
    }

    /// Pulls `chunk_size` elements from the front of the queue:
    ///
    /// * returns None if `chunk_size` is zero,
    /// * returns Some of an ExactSizeIterator with `len = chunk_size` if the queue has at least `chunk_size` items,
    /// * returns Some of a non-empty ExactSizeIterator with `len` such that `0 < len < chunk_size` if the queue
    ///   has `len` elements,
    /// * returns None if the queue is empty.
    ///
    /// Therefore, if the method returns a Some variant, the exact size iterator is not empty.
    ///
    /// Pulled elements are guaranteed to be consecutive elements in the queue.
    ///
    /// In order to reduce the number of concurrent state updates, `pull` with a large enough chunk size might be preferred over `pop` whenever possible.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::*;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.extend(1..6);
    /// assert_eq!(
    ///     queue.pull(2).map(|x| x.collect::<Vec<_>>()),
    ///     Some(vec![1, 2])
    /// );
    /// assert_eq!(
    ///     queue.pull(7).map(|x| x.collect::<Vec<_>>()),
    ///     Some(vec![3, 4, 5])
    /// );
    /// assert_eq!(queue.pull(1).map(|x| x.collect::<Vec<_>>()), None);
    /// ```
    pub fn pull(&self, chunk_size: usize) -> Option<QueueIterOwned<'_, T, P>> {
        match chunk_size > 0 {
            true => {
                let begin_idx = self.popped.fetch_add(chunk_size, Ordering::Relaxed);
                let end_idx = begin_idx + chunk_size;

                loop {
                    let written = self.written.load(Ordering::Acquire);

                    let has_none = begin_idx >= written;
                    let has_some = !has_none;
                    let has_all = end_idx <= written;

                    let range = match (has_some, has_all) {
                        (false, _) => match comp_exch(&self.popped, end_idx, begin_idx).is_ok() {
                            true => return None,
                            false => None,
                        },
                        (true, true) => Some(begin_idx..end_idx),
                        (true, false) => Some(begin_idx..written),
                    };

                    if let Some(range) = range {
                        let ok = match has_all {
                            true => true,
                            false => comp_exch(&self.popped, end_idx, range.end).is_ok(),
                        };

                        if ok {
                            let iter = unsafe { self.vec.ptr_iter_unchecked(range) };
                            return Some(QueueIterOwned::new(iter));
                        }
                    }
                }
            }
            false => None,
        }
    }

    // shrink with idx

    /// Pops and returns the element in the front of the queue together with its index;
    /// returns None if the queue is empty.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::*;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.extend(1..4);
    /// assert_eq!(queue.pop_with_idx(), Some((0, 1)));
    /// assert_eq!(queue.pop_with_idx(), Some((1, 2)));
    /// assert_eq!(queue.pop_with_idx(), Some((2, 3)));
    /// assert_eq!(queue.pop_with_idx(), None);
    /// ```
    pub fn pop_with_idx(&self) -> Option<(usize, T)> {
        let idx = self.popped.fetch_add(1, Ordering::Relaxed);

        loop {
            let written = self.written.load(Ordering::Acquire);
            match idx < written {
                true => return Some((idx, unsafe { self.ptr(idx).read() })),
                false => {
                    if comp_exch(&self.popped, idx + 1, idx).is_ok() {
                        return None;
                    }
                }
            }
        }
    }

    /// Pulls `chunk_size` elements from the front of the queue together with the index of the first pulled element:
    ///
    /// * returns None if `chunk_size` is zero,
    /// * returns Some of an ExactSizeIterator with `len = chunk_size` if the queue has at least `chunk_size` items,
    /// * returns Some of a non-empty ExactSizeIterator with `len` such that `0 < len < chunk_size` if the queue
    ///   has `len` elements,
    /// * returns None if the queue is empty.
    ///
    /// Therefore, if the method returns a Some variant, the exact size iterator is not empty.
    ///
    /// Pulled elements are guaranteed to be consecutive elements in the queue. Therefore, knowing the index of the first pulled element,
    /// indices of all pulled elements can be known.
    ///
    /// In order to reduce the number of concurrent state updates, `pull` with a large enough chunk size might be preferred over `pop` whenever possible.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::*;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.extend(1..6);
    /// assert_eq!(
    ///     queue.pull_with_idx(2).map(|(i, x)| x.enumerate().map(|(j, x)| (i + j, x)).collect::<Vec<_>>()),
    ///     Some(vec![(0, 1), (1, 2)])
    /// );
    /// assert_eq!(
    ///     queue.pull_with_idx(7).map(|(i, x)| x.enumerate().map(|(j, x)| (i + j, x)).collect::<Vec<_>>()),
    ///     Some(vec![(2, 3), (3, 4), (4, 5)])
    /// );
    /// assert_eq!(queue.pull_with_idx(1).map(|(i, x)| x.enumerate().map(|(j, x)| (i + j, x)).collect::<Vec<_>>()), None);
    /// ```
    pub fn pull_with_idx(&self, chunk_size: usize) -> Option<(usize, QueueIterOwned<'_, T, P>)> {
        match chunk_size > 0 {
            true => {
                let begin_idx = self.popped.fetch_add(chunk_size, Ordering::Relaxed);
                let end_idx = begin_idx + chunk_size;

                loop {
                    let written = self.written.load(Ordering::Acquire);

                    let has_none = begin_idx >= written;
                    let has_some = !has_none;
                    let has_all = end_idx <= written;

                    let range = match (has_some, has_all) {
                        (false, _) => match comp_exch(&self.popped, end_idx, begin_idx).is_ok() {
                            true => return None,
                            false => None,
                        },
                        (true, true) => Some(begin_idx..end_idx),
                        (true, false) => Some(begin_idx..written),
                    };

                    if let Some(range) = range {
                        let ok = match has_all {
                            true => true,
                            false => comp_exch(&self.popped, end_idx, range.end).is_ok(),
                        };

                        if ok {
                            let iter = unsafe { self.vec.ptr_iter_unchecked(range) };
                            return Some((begin_idx, QueueIterOwned::new(iter)));
                        }
                    }
                }
            }
            false => None,
        }
    }

    // grow

    /// Pushes the `value` to the back of the queue.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::*;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.push(1);
    /// queue.push(2);
    /// queue.push(3);
    /// assert_eq!(queue.into_inner(), vec![1, 2, 3]);
    /// ```
    pub fn push(&self, value: T) {
        let idx = self.write_reserved.fetch_add(1, Ordering::Relaxed);
        self.assert_has_capacity_for(idx);

        loop {
            match WritePermit::for_one(self.vec.capacity(), idx) {
                WritePermit::JustWrite => {
                    unsafe { self.ptr(idx).write(value) };
                    break;
                }
                WritePermit::GrowThenWrite => {
                    self.grow_to(idx + 1);
                    unsafe { self.ptr(idx).write(value) };
                    break;
                }
                WritePermit::Spin => {}
            }
        }

        let num_written = idx + 1;
        while comp_exch_weak(&self.written, idx, num_written).is_err() {}
    }

    /// Extends the queue by pushing `values` elements to the back of the queue.
    ///
    /// In order to reduce the number of concurrent state updates, `extend` might be preferred over `push` whenever possible.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.extend(1..3);
    /// queue.extend(vec![3, 4, 5, 6]);
    ///
    /// assert_eq!(queue.into_inner(), vec![1, 2, 3, 4, 5, 6]);
    /// ```
    pub fn extend<I, Iter>(&self, values: I)
    where
        I: IntoIterator<Item = T, IntoIter = Iter>,
        Iter: ExactSizeIterator<Item = T>,
    {
        let values = values.into_iter();
        let num_items = values.len();

        if num_items > 0 {
            let begin_idx = self.write_reserved.fetch_add(num_items, Ordering::Relaxed);
            let end_idx = begin_idx + num_items;
            let last_idx = begin_idx + num_items - 1;
            self.assert_has_capacity_for(last_idx);

            loop {
                match WritePermit::for_many(self.vec.capacity(), begin_idx, last_idx) {
                    WritePermit::JustWrite => {
                        let iter = unsafe { self.vec.ptr_iter_unchecked(begin_idx..end_idx) };
                        for (p, value) in iter.zip(values) {
                            unsafe { p.write(value) };
                        }
                        break;
                    }
                    WritePermit::GrowThenWrite => {
                        self.grow_to(end_idx);
                        let iter = unsafe { self.vec.ptr_iter_unchecked(begin_idx..end_idx) };
                        for (p, value) in iter.zip(values) {
                            unsafe { p.write(value) };
                        }
                        break;
                    }
                    WritePermit::Spin => {}
                }
            }

            while comp_exch_weak(&self.written, begin_idx, end_idx).is_err() {}
        }
    }

    // get

    /// Returns the number of elements in the queue.
    ///
    /// Importantly note that `len` is a shorthand for:
    ///
    /// ```ignore
    /// let written = self.num_written(Ordering::Relaxed);
    /// let popped = self.num_popped(Ordering::Relaxed);
    /// written - popped
    /// ```
    ///
    /// When a different ordering is required, you may write your own `len` method
    /// using [`num_written`] and [`num_popped`] methods.
    ///
    /// [`num_written`]: ConcurrentQueue::num_written
    /// [`num_popped`]: ConcurrentQueue::num_popped
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.push(1);
    /// queue.push(2);
    /// assert_eq!(queue.len(), 2);
    ///
    /// queue.extend(vec![3, 4, 5, 6]);
    /// assert_eq!(queue.len(), 6);
    ///
    /// _ = queue.pop();
    /// assert_eq!(queue.len(), 5);
    ///
    /// _ = queue.pull(4);
    /// assert_eq!(queue.len(), 1);
    /// ```
    #[inline(always)]
    pub fn len(&self) -> usize {
        self.written
            .load(Ordering::Relaxed)
            .saturating_sub(self.popped.load(Ordering::Relaxed))
    }

    /// Returns the total number of positions written; i.e., total of
    /// number of times we pushed and sum of lengths of iterators that
    /// we extended the queue with.
    ///
    /// See [`num_write_reserved`] to get the number of positions which are
    /// reserved to be written.
    ///
    /// Note that in a synchronous program, number of reserved positions
    /// will be equal to the number of written positions.
    ///
    /// In a concurrent program; however, it is possible to observe that
    /// `num_write_reserved >= num_written` since we might observe the
    /// counts while writing of some elements are in progress.
    ///
    /// However, we can never observe `num_write_reserved < num_written`.
    ///
    /// [`num_written`]: ConcurrentQueue::num_written
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::*;
    /// use std::sync::atomic::Ordering;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// assert_eq!(queue.num_written(Ordering::Relaxed), 0);
    ///
    /// queue.push(1);
    /// assert_eq!(queue.num_written(Ordering::Relaxed), 1);
    ///
    /// queue.extend([2, 3, 4]);
    /// assert_eq!(queue.num_written(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pop();
    /// assert_eq!(queue.num_written(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pull(2);
    /// assert_eq!(queue.num_written(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pull(10); // only 1 is pulled
    /// assert_eq!(queue.num_written(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pop(); // None
    /// assert_eq!(queue.num_written(Ordering::Relaxed), 4);
    /// ```
    #[inline(always)]
    pub fn num_written(&self, order: Ordering) -> usize {
        self.written.load(order)
    }

    /// Returns the total number of positions reserved to be written.
    ///
    /// See [`num_written`] to get the number of elements which are
    /// completely written.
    ///
    /// Note that in a synchronous program, number of reserved positions
    /// will be equal to the number of written positions.
    ///
    /// In a concurrent program; however, it is possible to observe that
    /// `num_write_reserved >= num_written` since we might observe the
    /// counts while writing of some elements are in progress.
    ///
    /// However, we can never observe `num_write_reserved < num_written`.
    ///
    /// [`num_written`]: ConcurrentQueue::num_written
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::*;
    /// use std::sync::atomic::Ordering;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// assert_eq!(queue.num_write_reserved(Ordering::Relaxed), 0);
    ///
    /// queue.push(1);
    /// assert_eq!(queue.num_write_reserved(Ordering::Relaxed), 1);
    ///
    /// queue.extend([2, 3, 4]);
    /// assert_eq!(queue.num_write_reserved(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pop();
    /// assert_eq!(queue.num_write_reserved(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pull(2);
    /// assert_eq!(queue.num_write_reserved(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pull(10); // only 1 is pulled
    /// assert_eq!(queue.num_write_reserved(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pop(); // None
    /// assert_eq!(queue.num_write_reserved(Ordering::Relaxed), 4);
    /// ```
    #[inline(always)]
    pub fn num_write_reserved(&self, order: Ordering) -> usize {
        self.write_reserved.load(order)
    }

    /// Returns the number of popped elements so far.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::*;
    /// use std::sync::atomic::Ordering;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// assert_eq!(queue.num_popped(Ordering::Relaxed), 0);
    ///
    /// queue.push(1);
    /// queue.extend([2, 3, 4]);
    /// assert_eq!(queue.num_popped(Ordering::Relaxed), 0);
    ///
    /// _ = queue.pop();
    /// assert_eq!(queue.num_popped(Ordering::Relaxed), 1);
    ///
    /// _ = queue.pull(2);
    /// assert_eq!(queue.num_popped(Ordering::Relaxed), 3);
    ///
    /// _ = queue.pull(10); // only 1 is pulled
    /// assert_eq!(queue.num_popped(Ordering::Relaxed), 4);
    ///
    /// _ = queue.pop(); // None
    /// assert_eq!(queue.num_popped(Ordering::Relaxed), 4);
    /// ```
    #[inline(always)]
    pub fn num_popped(&self, order: Ordering) -> usize {
        self.popped.load(order)
    }

    /// Returns true if the queue is empty, false otherwise.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// assert!(queue.is_empty());
    ///
    /// queue.push(1);
    /// queue.push(2);
    /// assert!(!queue.is_empty());
    ///
    /// _ = queue.pull(4);
    /// assert!(queue.is_empty());
    /// ```
    pub fn is_empty(&self) -> bool {
        self.written.load(Ordering::Relaxed) == self.popped.load(Ordering::Relaxed)
    }

    /// Returns an iterator of references to items in the queue.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    ///
    /// let mut queue = ConcurrentQueue::new();
    ///
    /// queue.push(1);
    /// queue.push(2);
    /// queue.push(3);
    ///
    /// let sum: i32 = queue.iter().sum();
    /// assert_eq!(sum, 6);
    /// ```
    ///
    /// # Safety
    ///
    /// Notice that this call requires a mutually exclusive `&mut self` reference.
    /// This is due to the fact that iterators are lazy and they are not necessarily consumed immediately.
    /// On the other hand, concurrent queue allows for popping elements from the queue with a shared reference.
    /// This could've led to the following undefined behavior.
    ///
    /// To prevent this, `iter` requires a mutually exclusive reference, and hence, the following code does not compile.
    ///
    /// ```compile_fail
    /// use orx_concurrent_queue::ConcurrentQueue;
    ///
    /// let queue = ConcurrentQueue::new();
    ///
    /// queue.push(1);
    /// queue.push(2);
    /// queue.push(3);
    ///
    /// let iter = queue.iter(); // iterator over elements 1, 2 and 3
    ///
    /// _ = queue.pop(); // 1 is removed
    ///
    /// let sum = iter.sum(); // UB
    /// ```
    pub fn iter(&mut self) -> impl ExactSizeIterator<Item = &T> {
        QueueIterOfRef::<T, P>::new(self.ptr_iter())
    }

    /// Returns an iterator of mutable references to items in the queue.
    ///
    /// # Examples
    ///
    /// ```
    /// use orx_concurrent_queue::ConcurrentQueue;
    ///
    /// let mut queue = ConcurrentQueue::new();
    ///
    /// queue.push(1);
    /// queue.push(2);
    /// queue.push(3);
    ///
    /// for x in queue.iter_mut() {
    ///     *x += 10;
    /// }
    ///
    /// assert_eq!(queue.into_inner(), vec![11, 12, 13]);
    /// ```
    pub fn iter_mut(&mut self) -> impl ExactSizeIterator<Item = &mut T> {
        QueueIterOfMut::<T, P>::new(self.ptr_iter())
    }

    // helpers

    #[inline(always)]
    unsafe fn ptr(&self, idx: usize) -> *mut T {
        unsafe { self.vec.get_ptr_mut(idx) }
    }

    #[inline(always)]
    fn assert_has_capacity_for(&self, idx: usize) {
        assert!(
            idx < self.vec.max_capacity(),
            "Out of capacity. Underlying pinned vector cannot grow any further while being concurrently safe."
        );
    }

    fn grow_to(&self, new_capacity: usize) {
        _ = self
            .vec
            .grow_to(new_capacity)
            .expect("The underlying pinned vector reached its capacity and failed to grow");
    }

    pub(super) fn valid_range(&mut self) -> Range<usize> {
        self.popped.load(Ordering::Relaxed)..self.written.load(Ordering::Relaxed)
    }

    pub(super) fn ptr_iter(&mut self) -> P::PtrIter<'_> {
        let range = self.valid_range();
        // SAFETY: with a mut ref, we ensure that the range contains all and only valid values
        unsafe { self.vec.ptr_iter_unchecked(range) }
    }

    /// Destructs the concurrent queue into its inner pieces:
    /// * underlying concurrent pinned vector,
    /// * number of written elements, and
    /// * number of popped elements.
    ///
    /// # Safety
    ///
    /// Note that the destruction operation of the queue is safe.
    /// However, it disconnects the concurrent pinned vector from the information
    /// of which elements are taken out and which are still to be dropped.
    /// Therefore, the caller is responsible to drop all elements within the range
    /// `popped..written`.
    pub unsafe fn destruct(mut self) -> (P, usize, usize)
    where
        <P as ConcurrentPinnedVec<T>>::P: IntoConcurrentPinnedVec<T, ConPinnedVec = P>,
    {
        let popped = self.popped.load(Ordering::Relaxed);
        let write_reserved = self.write_reserved.load(Ordering::Relaxed);
        let written = self.written.load(Ordering::Relaxed);
        debug_assert_eq!(written, write_reserved);
        debug_assert!(written >= popped);

        let vec: <P as ConcurrentPinnedVec<T>>::P = PseudoDefault::pseudo_default();
        let mut vec = vec.into_concurrent();
        core::mem::swap(&mut self.vec, &mut vec);

        self.popped.store(0, Ordering::Relaxed);
        self.write_reserved.store(0, Ordering::Relaxed);
        self.written.store(0, Ordering::Relaxed);

        (vec, written, popped)
    }
}