sketch out DefaultMutex

maitake-sync/Cargo.toml

@@ -23,13 +23,15 @@ rust-version = "1.61.0"
 [features]
 default = ["alloc"]
 alloc = ["cordyceps/alloc"]
+std = ["alloc"]
 no-cache-pad = ["cordyceps/no-cache-pad"]
 core-error = []
 
 [dependencies]
 mycelium-bitfield = { version = "0.1.3", path = "../bitfield" }
 mutex-traits = "0.999.0"
 cordyceps = { version = "0.3.0", path = "../cordyceps" }
+critical-section = { version = "1.1", optional = true }
 pin-project = "1"
 portable-atomic = "1.2"
 tracing = { version = "0.1", default_features = false, optional = true }

maitake-sync/src/blocking.rs

@@ -150,8 +150,10 @@
 //! [`lock_api`]: https://crates.io/crates/lock_api
 //! [`critical-section`]: https://crates.io/crates/critical-section
 //! [`std::sync::Mutex`]: https://doc.rust-lang.org/stable/std/sync/struct.Mutex.html
+mod default_mutex;
 pub(crate) mod mutex;
 pub(crate) mod rwlock;
 
 pub use self::{mutex::*, rwlock::*};
+pub use default_mutex::DefaultMutex;
 pub use mutex_traits::ConstInit;

maitake-sync/src/blocking/default_mutex.rs

@@ -0,0 +1,154 @@
+#[cfg(loom)]
+pub use loom_impl::DefaultMutex;
+
+#[cfg(all(not(loom), feature = "std"))]
+pub use std_impl::DefaultMutex;
+
+#[cfg(all(not(loom), not(feature = "std"), feature = "critical-section"))]
+pub use cs_impl::DefaultMutex;
+
+#[cfg(all(not(loom), not(feature = "std"), not(feature = "critical-section")))]
+pub use spin_impl::DefaultMutex;
+
+#[cfg(loom)]
+mod loom_impl {
+    #[cfg(feature = "tracing")]
+    use core::panic::Location;
+    use mutex_traits::ScopedRawMutex;
+
+    pub struct DefaultMutex(loom::sync::Mutex<()>);
+
+    unsafe impl ScopedRawMutex for DefaultMutex {
+        #[track_caller]
+        fn with_lock<R>(&self, f: impl FnOnce() -> R) -> R {
+            #[cfg(feature = "tracing")]
+            let location = Location::caller();
+            #[cfg(feature = "tracing")]
+            tracing::debug!(%location, "DefaultMutex::with_lock()");
+
+            let guard = self.0.lock();
+            tracing::debug!(%location, "DefaultMutex::with_lock() -> locked");
+
+            let result = f();
+            drop(guard);
+
+            #[cfg(feature = "tracing")]
+            tracing::debug!(%location, "DefaultMutex::with_lock() -> unlocked");
+
+            result
+        }
+
+        #[track_caller]
+        fn try_with_lock<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
+            #[cfg(feature = "tracing")]
+            let location = Location::caller();
+            #[cfg(feature = "tracing")]
+            tracing::debug!(%location, "DefaultMutex::try_with_lock()");
+
+            match self.0.try_lock() {
+                Ok(guard) => {
+                    #[cfg(feature = "tracing")]
+                    tracing::debug!(%location, "DefaultMutex::try_with_lock() -> locked");
+
+                    let result = f();
+                    drop(guard);
+
+                    #[cfg(feature = "tracing")]
+                    tracing::debug!(%location, "DefaultMutex::try_with_lock() -> unlocked");
+
+                    Some(result)
+                }
+                None => {
+                    #[cfg(feature = "tracing")]
+                    tracing::debug!(%location, "DefaultMutex::try_with_lock() -> already locked");
+
+                    None
+                }
+            }
+        }
+
+        fn is_locked(&self) -> bool {
+            self.0.try_lock().is_none()
+        }
+    }
+}
+
+#[cfg(all(not(loom), feature = "std"))]
+mod std_impl {
+    use mutex_traits::ScopedRawMutex;
+
+    pub struct DefaultMutex(std::sync::Mutex<()>);
+
+    unsafe impl ScopedRawMutex for DefaultMutex {
+        #[track_caller]
+        #[inline]
+        fn with_lock<R>(&self, f: impl FnOnce() -> R) -> R {
+            let _guard = self.0.lock().unwrap();
+            f()
+        }
+
+        #[track_caller]
+        fn try_with_lock<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
+            let _guard = self.0.try_lock().ok()?;
+            Some(f())
+        }
+
+        fn is_locked(&self) -> bool {
+            self.0.try_lock().is_none()
+        }
+    }
+}
+
+#[cfg(all(not(loom), not(feature = "std"), feature = "critical-section"))]
+mod cs_impl {
+    use crate::spin::Spinlock;
+    use mutex_traits::ScopedRawMutex;
+
+    pub struct DefaultMutex(Spinlock);
+
+    unsafe impl ScopedRawMutex for DefaultMutex {
+        #[track_caller]
+        #[inline]
+        fn with_lock<R>(&self, f: impl FnOnce() -> R) -> R {
+            self.0.with_lock(|| critical_section::with(|| f()))
+        }
+
+        #[track_caller]
+        #[inline]
+        fn try_with_lock<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
+            self.0.try_with_lock(|| critical_section::with(|| f()))
+        }
+
+        #[inline]
+        fn is_locked(&self) -> bool {
+            self.0.is_locked()
+        }
+    }
+}
+
+#[cfg(all(not(loom), not(feature = "std"), not(feature = "critical-section")))]
+mod spin_impl {
+    use crate::spin::Spinlock;
+    use mutex_traits::ScopedRawMutex;
+
+    pub struct DefaultMutex(Spinlock);
+
+    unsafe impl ScopedRawMutex for DefaultMutex {
+        #[track_caller]
+        #[inline]
+        fn with_lock<R>(&self, f: impl FnOnce() -> R) -> R {
+            self.0.with_lock(|| critical_section::with(|| f()))
+        }
+
+        #[track_caller]
+        #[inline]
+        fn try_with_lock<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
+            self.0.try_with_lock(|| critical_section::with(|| f()))
+        }
+
+        #[inline]
+        fn is_locked(&self) -> bool {
+            self.0.is_locked()
+        }
+    }
+}

maitake-sync/src/lib.rs

@@ -1,7 +1,7 @@
 #![doc = include_str!("../README.md")]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg, doc_cfg_hide))]
 #![cfg_attr(docsrs, doc(cfg_hide(docsrs, loom)))]
-#![cfg_attr(not(test), no_std)]
+#![cfg_attr(not(any(test, feature = "std")), no_std)]
 #![cfg_attr(feature = "core-error", feature(error_in_core))]
 #![warn(missing_docs, missing_debug_implementations)]