Add special bounded(1) implementation

Author: Stjepan Glavina

src/lib.rs

@@ -36,9 +36,11 @@ use std::panic::{RefUnwindSafe, UnwindSafe};
 use std::sync::atomic::{self, AtomicUsize, Ordering};
 
 use crate::bounded::Bounded;
+use crate::single::Single;
 use crate::unbounded::Unbounded;
 
 mod bounded;
+mod single;
 mod unbounded;
 
 /// A concurrent queue.
@@ -67,8 +69,9 @@ impl<T> UnwindSafe for ConcurrentQueue<T> {}
 impl<T> RefUnwindSafe for ConcurrentQueue<T> {}
 
 enum Inner<T> {
-    Bounded(Bounded<T>),
-    Unbounded(Unbounded<T>),
+    Single(Single<T>),
+    Bounded(Box<Bounded<T>>),
+    Unbounded(Box<Unbounded<T>>),
 }
 
 impl<T> ConcurrentQueue<T> {
@@ -88,7 +91,11 @@ impl<T> ConcurrentQueue<T> {
     /// let q = ConcurrentQueue::<i32>::bounded(100);
     /// ```
     pub fn bounded(cap: usize) -> ConcurrentQueue<T> {
-        ConcurrentQueue(Inner::Bounded(Bounded::new(cap)))
+        if cap == 1 {
+            ConcurrentQueue(Inner::Single(Single::new()))
+        } else {
+            ConcurrentQueue(Inner::Bounded(Box::new(Bounded::new(cap))))
+        }
     }
 
     /// Creates a new unbounded queue.
@@ -101,7 +108,7 @@ impl<T> ConcurrentQueue<T> {
     /// let q = ConcurrentQueue::<i32>::unbounded();
     /// ```
     pub fn unbounded() -> ConcurrentQueue<T> {
-        ConcurrentQueue(Inner::Unbounded(Unbounded::new()))
+        ConcurrentQueue(Inner::Unbounded(Box::new(Unbounded::new())))
     }
 
     /// Attempts to push an item into the queue.
@@ -135,6 +142,7 @@ impl<T> ConcurrentQueue<T> {
     /// ```
     pub fn push(&self, value: T) -> Result<(), PushError<T>> {
         match &self.0 {
+            Inner::Single(q) => q.push(value),
             Inner::Bounded(q) => q.push(value),
             Inner::Unbounded(q) => q.push(value),
         }
@@ -167,6 +175,7 @@ impl<T> ConcurrentQueue<T> {
     /// ```
     pub fn pop(&self) -> Result<T, PopError> {
         match &self.0 {
+            Inner::Single(q) => q.pop(),
             Inner::Bounded(q) => q.pop(),
             Inner::Unbounded(q) => q.pop(),
         }
@@ -187,6 +196,7 @@ impl<T> ConcurrentQueue<T> {
     /// ```
     pub fn is_empty(&self) -> bool {
         match &self.0 {
+            Inner::Single(q) => q.is_empty(),
             Inner::Bounded(q) => q.is_empty(),
             Inner::Unbounded(q) => q.is_empty(),
         }
@@ -209,6 +219,7 @@ impl<T> ConcurrentQueue<T> {
     /// ```
     pub fn is_full(&self) -> bool {
         match &self.0 {
+            Inner::Single(q) => q.is_full(),
             Inner::Bounded(q) => q.is_full(),
             Inner::Unbounded(q) => q.is_full(),
         }
@@ -232,6 +243,7 @@ impl<T> ConcurrentQueue<T> {
     /// ```
     pub fn len(&self) -> usize {
         match &self.0 {
+            Inner::Single(q) => q.len(),
             Inner::Bounded(q) => q.len(),
             Inner::Unbounded(q) => q.len(),
         }
@@ -254,6 +266,7 @@ impl<T> ConcurrentQueue<T> {
     /// ```
     pub fn capacity(&self) -> Option<usize> {
         match &self.0 {
+            Inner::Single(_) => Some(1),
             Inner::Bounded(q) => Some(q.capacity()),
             Inner::Unbounded(_) => None,
         }
@@ -288,6 +301,7 @@ impl<T> ConcurrentQueue<T> {
     /// ```
     pub fn close(&self) -> bool {
         match &self.0 {
+            Inner::Single(q) => q.close(),
             Inner::Bounded(q) => q.close(),
             Inner::Unbounded(q) => q.close(),
         }
@@ -308,6 +322,7 @@ impl<T> ConcurrentQueue<T> {
     /// ```
     pub fn is_closed(&self) -> bool {
         match &self.0 {
+            Inner::Single(q) => q.is_closed(),
             Inner::Bounded(q) => q.is_closed(),
             Inner::Unbounded(q) => q.is_closed(),
         }

src/single.rs

@@ -0,0 +1,120 @@
+use std::cell::UnsafeCell;
+use std::mem::MaybeUninit;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::thread;
+
+use crate::{PopError, PushError};
+
+const LOCKED: usize = 1 << 0;
+const PUSHED: usize = 1 << 1;
+const CLOSED: usize = 1 << 2;
+
+/// A single-element queue.
+pub struct Single<T> {
+    state: AtomicUsize,
+    slot: UnsafeCell<MaybeUninit<T>>,
+}
+
+impl<T> Single<T> {
+    /// Creates a new single-element queue.
+    pub fn new() -> Single<T> {
+        Single {
+            state: AtomicUsize::new(0),
+            slot: UnsafeCell::new(MaybeUninit::uninit()),
+        }
+    }
+
+    /// Attempts to push an item into the queue.
+    pub fn push(&self, value: T) -> Result<(), PushError<T>> {
+        // Lock and fill the slot.
+        let state = self
+            .state
+            .compare_and_swap(0, LOCKED | PUSHED, Ordering::SeqCst);
+
+        if state == 0 {
+            // Write the value and unlock.
+            unsafe { self.slot.get().write(MaybeUninit::new(value)) }
+            self.state.fetch_and(!LOCKED, Ordering::Release);
+            Ok(())
+        } else if state & CLOSED != 0 {
+            Err(PushError::Closed(value))
+        } else {
+            Err(PushError::Full(value))
+        }
+    }
+
+    /// Attempts to pop an item from the queue.
+    pub fn pop(&self) -> Result<T, PopError> {
+        let mut state = PUSHED;
+        loop {
+            // Lock and empty the slot.
+            let prev =
+                self.state
+                    .compare_and_swap(state, (state | LOCKED) & !PUSHED, Ordering::SeqCst);
+
+            if prev == state {
+                // Read the value and unlock.
+                let value = unsafe { self.slot.get().read().assume_init() };
+                self.state.fetch_and(!LOCKED, Ordering::Release);
+                return Ok(value);
+            }
+
+            if prev & PUSHED == 0 {
+                if prev & CLOSED == 0 {
+                    return Err(PopError::Empty);
+                } else {
+                    return Err(PopError::Closed);
+                }
+            }
+
+            if prev & LOCKED == 0 {
+                state = prev;
+            } else {
+                thread::yield_now();
+                state = prev & !LOCKED;
+            }
+        }
+    }
+
+    /// Returns the number of items in the queue.
+    pub fn len(&self) -> usize {
+        if self.state.load(Ordering::SeqCst) & PUSHED == 0 {
+            0
+        } else {
+            1
+        }
+    }
+
+    /// Returns `true` if the queue is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns `true` if the queue is full.
+    pub fn is_full(&self) -> bool {
+        self.len() == 1
+    }
+
+    /// Closes the queue.
+    ///
+    /// Returns `true` if this call closed the queue.
+    pub fn close(&self) -> bool {
+        let state = self.state.fetch_or(CLOSED, Ordering::SeqCst);
+        state & CLOSED == 0
+    }
+
+    /// Returns `true` if the queue is closed.
+    pub fn is_closed(&self) -> bool {
+        self.state.load(Ordering::SeqCst) & CLOSED != 0
+    }
+}
+
+impl<T> Drop for Single<T> {
+    fn drop(&mut self) {
+        // Drop the value in the slot.
+        if *self.state.get_mut() & PUSHED != 0 {
+            let value = unsafe { self.slot.get().read().assume_init() };
+            drop(value);
+        }
+    }
+}

tests/bounded.rs

@@ -5,7 +5,7 @@ use easy_parallel::Parallel;
 
 #[test]
 fn smoke() {
-    let q = ConcurrentQueue::bounded(1);
+    let q = ConcurrentQueue::bounded(2);
 
     q.push(7).unwrap();
     assert_eq!(q.pop(), Ok(7));
@@ -114,7 +114,7 @@ fn len() {
 
 #[test]
 fn close() {
-    let q = ConcurrentQueue::bounded(1);
+    let q = ConcurrentQueue::bounded(2);
     assert_eq!(q.push(10), Ok(()));
 
     assert!(!q.is_closed());