feat(maitake): add WaitQueue (#191)

this branch adds a `WaitQueue` type in `maitake::wait`. this allows multiple tasks to wait for an event, and be woken either one at a time (in FIFO fashion), or all at once. there are additional APIs we could add here, but this is a good starting place. there probably should be docs examples but i'm lazy. Signed-off-by: Eliza Weisman <[email protected]>
hawkw · Jun 5, 2022 · 85d5b00 · 85d5b00
1 parent 233d2c8
commit 85d5b00
Show file tree

Hide file tree

Showing 12 changed files with 1,364 additions and 18 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -220,7 +220,9 @@ jobs:
       run: rustup show
     - uses: actions/checkout@v2
     - name: run tests
-      run: cargo test -p maitake --no-default-features
+      # don't run doctests with `no-default-features`, as some of them
+      # require liballoc.
+      run: cargo test -p maitake --no-default-features --tests --lib 
 
   # run loom tests
   maitake_loom:

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/bin/loom b/bin/loom
@@ -3,7 +3,7 @@
 set -x
 
 RUSTFLAGS="--cfg loom ${RUSTFLAGS}" \
-LOOM_LOG="${LOOM_LOG:-info}" \
+LOOM_LOG="${LOOM_LOG:-debug}" \
 LOOM_LOCATION=true \
 cargo test \
     --profile loom \

diff --git a/bitfield/src/bitfield.rs b/bitfield/src/bitfield.rs
@@ -234,11 +234,11 @@ macro_rules! bitfield {
         #[automatically_derived]
         impl core::fmt::Debug for $Name {
             fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-                if f.alternate() {
-                    f.debug_tuple(stringify!($Name)).field(&format_args!("{}", self)).finish()
-                } else {
-                    f.debug_tuple(stringify!($Name)).field(&format_args!("{:#b}", self.0)).finish()
-                }
+                let mut dbg = f.debug_struct(stringify!($Name));
+                $(
+                    dbg.field(stringify!($Field), &self.get(Self::$Field));
+                )+
+                dbg.finish()
 
             }
         }

diff --git a/maitake/Cargo.toml b/maitake/Cargo.toml
@@ -48,8 +48,11 @@ git = "https://github.com/tokio-rs/tracing"
 [dev-dependencies]
 futures-util = "0.3"
 
+[target.'cfg(not(loom))'.dev-dependencies]
+tracing-subscriber = { git = "https://github.com/tokio-rs/tracing", features = ["ansi", "fmt"] }
+
 [target.'cfg(loom)'.dev-dependencies]
-loom = { version = "0.5.5", features = ["futures"] }
+loom = { version = "0.5.5", features = ["futures", "checkpoint"] }
 tracing_01 = { package = "tracing", version = "0.1", default_features = false }
 tracing_subscriber_03 = { package = "tracing-subscriber", version = "0.3.11", features = ["fmt"] }
 

diff --git a/maitake/src/lib.rs b/maitake/src/lib.rs
@@ -1,6 +1,6 @@
 #![cfg_attr(docsrs, doc = include_str!("../README.md"))]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg, doc_cfg_hide))]
-#![cfg_attr(docsrs, doc(cfg_hide(docsrs)))]
+#![cfg_attr(docsrs, doc(cfg_hide(docsrs, loom)))]
 #![cfg_attr(not(test), no_std)]
 #[cfg(feature = "alloc")]
 extern crate alloc;

diff --git a/maitake/src/loom.rs b/maitake/src/loom.rs
@@ -3,9 +3,42 @@ pub(crate) use self::inner::*;
 
 #[cfg(loom)]
 mod inner {
+    #![allow(dead_code)]
+
     #[cfg(feature = "alloc")]
-    pub use loom::alloc;
-    pub use loom::{cell, future, hint, model, sync, thread};
+    pub(crate) use loom::alloc;
+    pub(crate) use loom::{cell, future, hint, model, thread};
+
+    pub(crate) mod sync {
+        pub(crate) use loom::sync::*;
+
+        pub(crate) mod spin {
+            pub(crate) use loom::sync::MutexGuard;
+
+            /// Mock version of mycelium's spinlock, but using
+            /// `loom::sync::Mutex`. The API is slightly different, since the
+            /// mycelium mutex does not support poisoning.
+            #[derive(Debug)]
+            pub(crate) struct Mutex<T>(loom::sync::Mutex<T>);
+
+            impl<T> Mutex<T> {
+                #[track_caller]
+                pub(crate) fn new(t: T) -> Self {
+                    Self(loom::sync::Mutex::new(t))
+                }
+
+                #[track_caller]
+                pub fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
+                    self.0.try_lock().ok()
+                }
+
+                #[track_caller]
+                pub fn lock(&self) -> MutexGuard<'_, T> {
+                    self.0.lock().expect("loom mutex will never poison")
+                }
+            }
+        }
+    }
 }
 
 #[cfg(not(loom))]
@@ -15,6 +48,8 @@ mod inner {
         #[cfg(feature = "alloc")]
         pub use alloc::sync::*;
         pub use core::sync::*;
+
+        pub use mycelium_util::sync::spin;
     }
 
     pub(crate) use core::sync::atomic;

diff --git a/maitake/src/scheduler/tests.rs b/maitake/src/scheduler/tests.rs
@@ -49,6 +49,8 @@ mod alloc {
         static SCHEDULER: Lazy<StaticScheduler> = Lazy::new(StaticScheduler::new);
         static IT_WORKED: AtomicBool = AtomicBool::new(false);
 
+        crate::util::trace_init();
+
         SCHEDULER.spawn(async {
             Yield::once().await;
             IT_WORKED.store(true, Ordering::Release);
@@ -69,6 +71,7 @@ mod alloc {
 
         const TASKS: usize = 10;
 
+        crate::util::trace_init();
         for _ in 0..TASKS {
             SCHEDULER.spawn(async {
                 Yield::once().await;
@@ -89,6 +92,7 @@ mod alloc {
         static SCHEDULER: Lazy<StaticScheduler> = Lazy::new(StaticScheduler::new);
         static COMPLETED: AtomicUsize = AtomicUsize::new(0);
 
+        crate::util::trace_init();
         let chan = Chan::new(1);
 
         SCHEDULER.spawn({
@@ -114,6 +118,7 @@ mod alloc {
         static SCHEDULER: Lazy<StaticScheduler> = Lazy::new(StaticScheduler::new);
         static COMPLETED: AtomicUsize = AtomicUsize::new(0);
 
+        crate::util::trace_init();
         let chan = Chan::new(1);
 
         SCHEDULER.spawn({
@@ -142,6 +147,8 @@ mod alloc {
 
         const TASKS: usize = 10;
 
+        crate::util::trace_init();
+
         for i in 0..TASKS {
             SCHEDULER.spawn(async {
                 Yield::new(i).await;
@@ -196,6 +203,8 @@ mod custom_storage {
         static SCHEDULER: StaticScheduler = unsafe { StaticScheduler::new_with_static_stub(&STUB) };
         static IT_WORKED: AtomicBool = AtomicBool::new(false);
 
+        crate::util::trace_init();
+
         MyBoxTask::spawn(&SCHEDULER, async {
             Yield::once().await;
             IT_WORKED.store(true, Ordering::Release);
@@ -217,6 +226,8 @@ mod custom_storage {
 
         const TASKS: usize = 10;
 
+        crate::util::trace_init();
+
         for _ in 0..TASKS {
             MyBoxTask::spawn(&SCHEDULER, async {
                 Yield::once().await;
@@ -238,6 +249,7 @@ mod custom_storage {
         static SCHEDULER: StaticScheduler = unsafe { StaticScheduler::new_with_static_stub(&STUB) };
         static COMPLETED: AtomicUsize = AtomicUsize::new(0);
 
+        crate::util::trace_init();
         let chan = Chan::new(1);
 
         MyBoxTask::spawn(&SCHEDULER, {
@@ -264,6 +276,7 @@ mod custom_storage {
         static SCHEDULER: StaticScheduler = unsafe { StaticScheduler::new_with_static_stub(&STUB) };
         static COMPLETED: AtomicUsize = AtomicUsize::new(0);
 
+        crate::util::trace_init();
         let chan = Chan::new(1);
 
         MyBoxTask::spawn(&SCHEDULER, {
@@ -291,6 +304,7 @@ mod custom_storage {
         static SCHEDULER: StaticScheduler = unsafe { StaticScheduler::new_with_static_stub(&STUB) };
         static COMPLETED: AtomicUsize = AtomicUsize::new(0);
 
+        crate::util::trace_init();
         const TASKS: usize = 10;
 
         for i in 0..TASKS {

diff --git a/maitake/src/util.rs b/maitake/src/util.rs
@@ -18,7 +18,12 @@ macro_rules! test_dbg {
     ($e:expr) => {
         match $e {
             e => {
-                crate::util::tracing::debug!("{} = {:?}", stringify!($e), &e);
+                crate::util::tracing::debug!(
+                    location = %core::panic::Location::caller(),
+                    "{} = {:?}",
+                    stringify!($e),
+                    &e
+                );
                 e
             }
         }
@@ -33,7 +38,10 @@ macro_rules! test_trace {
 #[cfg(test)]
 macro_rules! test_trace {
     ($($args:tt)+) => {
-        crate::util::tracing::debug!($($args)+);
+        crate::util::tracing::debug!(
+            location = %core::panic::Location::caller(),
+            $($args)+
+        );
     };
 }
 
@@ -87,3 +95,12 @@ pub(crate) unsafe fn non_null<T>(ptr: *mut T) -> NonNull<T> {
 unsafe fn non_null<T>(ptr: *mut T) -> NonNull<T> {
     NonNull::new_unchecked(ptr)
 }
+
+#[cfg(all(test, not(loom)))]
+pub(crate) fn trace_init() {
+    use tracing_subscriber::filter::LevelFilter;
+    let _ = tracing_subscriber::fmt()
+        .with_max_level(LevelFilter::TRACE)
+        .with_test_writer()
+        .try_init();
+}
diff --git a/maitake/src/wait.rs b/maitake/src/wait.rs
@@ -1,16 +1,20 @@
 //! Waiter cells and queues to allow tasks to wait for notifications.
 //!
 //! This module implements two types of structure for waiting: a [`WaitCell`],
-//! which stores a *single* waiting task, and a wait *queue*, which
+//! which stores a *single* waiting task, and a [`WaitQueue`], which
 //! stores a queue of waiting tasks.
 pub(crate) mod cell;
-pub use cell::WaitCell;
+pub mod queue;
+
+pub use self::cell::WaitCell;
+#[doc(inline)]
+pub use self::queue::WaitQueue;
 
 use core::task::Poll;
 
-/// An error indicating that a [`WaitCell`] or queue was closed while attempting
-/// register a waiter.
-#[derive(Clone, Debug, PartialEq, Eq)]
+/// An error indicating that a [`WaitCell`] or [`WaitQueue`] was closed while
+/// attempting register a waiter.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub struct Closed(());
 
 pub type WaitResult = Result<(), Closed>;