Basic implementation using parking_lot::RawMutex

source/mutex/Cargo.toml

@@ -28,9 +28,14 @@ optional = true
 [dependencies.lock_api-0_4]
 package = "lock_api"
 version = "0.4"
-default_features = false
+default-features = false
 optional = true
 
+[dependencies.parking_lot]
+version = "0.12.3"
+optional = true
+default-features = false
+
 [features]
 default = [
     "impl-critical-section",
@@ -42,4 +47,6 @@ impl-lock_api-0_4 = ["dep:lock_api-0_4"]
 #
 # These can be disabled when minimizing binary size is important.
 fmt = []
-std = []
+std = [
+    "dep:parking_lot",
+]

source/mutex/src/raw_impls.rs

@@ -139,7 +139,7 @@
 
 // ================
 
 #[cfg(all(feature = "impl-unsafe-cortex-m-single-core", cortex_m))]
 pub mod single_core_thread_mode {
     //! A single-core safe implementation that does not require a critical section
 
@@ -269,3 +269,55 @@
         }
     }
 }
+
+#[cfg(feature = "std")]
+pub mod std {
+    //! Std implementation of the [RawMutex] trait
+    //!
+    //! Currently based on [`parking_lot::RawMutex], but subject to change
+
+    use mutex_traits::{ConstInit, RawMutex};
+    use parking_lot::{lock_api::RawMutex as _, RawMutex as PLRawMutex};
+
+    /// Std implementation of the [RawMutex] trait
+    ///
+    /// Currently based on [`parking_lot::RawMutex], but subject to change
+    #[cfg_attr(feature = "fmt", derive(Debug))]
+    pub struct StdRawMutex {
+        inner: PLRawMutex,
+    }
+
+    impl ConstInit for StdRawMutex {
+        const INIT: Self = StdRawMutex {
+            inner: PLRawMutex::INIT,
+        };
+    }
+
+    unsafe impl RawMutex for StdRawMutex {
+        type GuardMarker = <parking_lot::RawMutex as parking_lot::lock_api::RawMutex>::GuardMarker;
+
+        #[inline]
+        #[track_caller]
+        fn lock(&self) {
+            self.inner.lock();
+        }
+
+        #[inline]
+        #[track_caller]
+        fn try_lock(&self) -> bool {
+            self.inner.try_lock()
+        }
+
+        #[inline]
+        #[track_caller]
+        unsafe fn unlock(&self) {
+            self.inner.unlock()
+        }
+
+        #[inline]
+        #[track_caller]
+        fn is_locked(&self) -> bool {
+            self.inner.is_locked()
+        }
+    }
+}