Remove the crossbeam-utils dependency

Everything from that crate can either be inlined or ignored.

I also fix a bug with the list implementation as well.

Cargo.toml

@@ -19,7 +19,6 @@ default = ["std"]
 std = ["parking"]
 
 [dependencies]
-crossbeam-utils = { version = "0.8.12", default-features = false }
 parking = { version = "2.0.0", optional = true }
 
 [dev-dependencies]

src/lib.rs

@@ -347,7 +347,7 @@ impl Event {
  // Notify if there is at least one unnotified listener and the number of notified
  // listeners is less than `n`.
  if inner.notified.load(Ordering::Acquire) < n {
- inner.notify(n, false); 
+ inner.notify(n, false);
  }
  }
  }
@@ -435,7 +435,7 @@ impl Event {
  if let Some(inner) = self.try_inner() {
  // Notify if there is at least one unnotified listener.
  if inner.notified.load(Ordering::Acquire) < usize::MAX {
- inner.notify(n, true); 
+ inner.notify(n, true);
  }
  }
  }

src/list.rs

@@ -482,7 +482,7 @@ impl ListenerSlab {
  _ => return None,
  };
 
- let entry = self.listeners.remove(key.get());
+ let entry = &self.listeners[key.get()];
  let prev = entry.prev().get();
  let next = entry.next().get();
 

src/list/node.rs

@@ -1,12 +1,14 @@
 //! The node that makes up queues.
 
 use crate::list::{Listener, ListenerSlab};
-use crate::sync::atomic::{AtomicUsize, Ordering};
+use crate::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
 use crate::sync::Arc;
 use crate::{State, Task};
 
+use alloc::boxed::Box;
+
 use core::num::NonZeroUsize;
-use crossbeam_utils::atomic::AtomicCell;
+use core::ptr;
 
 /// A node in the backup queue.
 pub(crate) enum Node {
@@ -42,7 +44,7 @@ pub(crate) enum Node {
 
 pub(crate) struct TaskWaiting {
  /// The task that is being waited on.
- task: AtomicCell<Option<Task>>,
+ task: AtomicCell<Task>,
 
  /// The ID of the new entry.
  ///
@@ -54,7 +56,7 @@ impl Node {
  pub(crate) fn listener() -> (Self, Arc<TaskWaiting>) {
  // Create a new `TaskWaiting` structure.
  let task_waiting = Arc::new(TaskWaiting {
- task: AtomicCell::new(None),
+ task: AtomicCell::new(),
  entry_id: AtomicUsize::new(0),
  });
 
@@ -75,7 +77,7 @@ impl Node {
 
  // Send the new key to the listener and wake it if necessary.
  task_waiting.entry_id.store(key.get(), Ordering::Release);
- return task_waiting.task.take();
+ return task_waiting.task.take().map(|t| *t);
  }
  Node::Notify { count, additional } => {
  // Notify the listener.
@@ -108,7 +110,7 @@ impl TaskWaiting {
  /// Register a listener.
  pub(crate) fn register(&self, task: Task) {
  // Set the task.
- if let Some(task) = self.task.swap(Some(task)) {
+ if let Some(task) = self.task.replace(Some(Box::new(task))) {
  task.wake();
  }
 
@@ -119,3 +121,39 @@ impl TaskWaiting {
  }
  }
 }
+
+/// A shared pointer to a value.
+///
+/// The inner value is a `Box<T>`.
+#[derive(Debug)]
+struct AtomicCell<T>(AtomicPtr<T>);
+
+impl<T> AtomicCell<T> {
+ /// Create a new `AtomicCell`.
+ fn new() -> Self {
+ Self(AtomicPtr::new(ptr::null_mut()))
+ }
+
+ /// Swap the value out.
+ fn replace(&self, value: Option<Box<T>>) -> Option<Box<T>> {
+ let value = value.map_or(ptr::null_mut(), |value| Box::into_raw(value));
+ let old_value = self.0.swap(value, Ordering::SeqCst);
+
+ if old_value.is_null() {
+ None
+ } else {
+ Some(unsafe { Box::from_raw(old_value) })
+ }
+ }
+
+ /// Take the value out.
+ fn take(&self) -> Option<Box<T>> {
+ self.replace(None)
+ }
+}
+
+impl<T> Drop for AtomicCell<T> {
+ fn drop(&mut self) {
+ self.take();
+ }
+}

src/list/queue.rs

@@ -3,18 +3,16 @@
 use super::node::Node;
 use crate::sync::atomic::{AtomicPtr, Ordering};
 
-use crossbeam_utils::CachePadded;
-
 use alloc::boxed::Box;
 use core::ptr;
 
 /// A queue of nodes.
 pub(crate) struct Queue {
  /// The head of the queue.
- head: CachePadded<AtomicPtr<QueueNode>>,
+ head: AtomicPtr<QueueNode>,
 
  /// The tail of the queue.
- tail: CachePadded<AtomicPtr<QueueNode>>,
+ tail: AtomicPtr<QueueNode>,
 }
 
 /// A single node in the `Queue`.
@@ -30,8 +28,8 @@ impl Queue {
  /// Create a new queue.
  pub(crate) fn new() -> Self {
  Self {
- head: CachePadded::new(AtomicPtr::new(ptr::null_mut())),
- tail: CachePadded::new(AtomicPtr::new(ptr::null_mut())),
+ head: AtomicPtr::new(ptr::null_mut()),
+ tail: AtomicPtr::new(ptr::null_mut()),
  }
  }