feat: migrate to upstream spinning-top

Signed-off-by: Martin Kröning <[email protected]>

Cargo.toml

@@ -15,6 +15,7 @@ generic_once_cell = "0.1"
 interrupts = "0.1"
 interrupt-mutex = "0.1"
 lock_api = "0.4"
+spinning_top = "0.3.0"
 
 [dev-dependencies]
 rand = "0.8"

src/lib.rs

@@ -88,9 +88,24 @@
 #![cfg_attr(not(test), no_std)]
 #![warn(unsafe_op_in_unsafe_fn)]
 
-mod backoff;
 pub(crate) mod mutex;
-pub(crate) mod rwlock;
+pub(crate) mod rwlock {
+    /// A simple spinning, read-preferring readers-writer lock with exponential backoff.
+    pub type RawRwSpinLock = spinning_top::RawRwSpinlock<spinning_top::relax::Backoff>;
+
+    /// A [`lock_api::RwLock`] based on [`RawRwSpinLock`].
+    pub type RwSpinLock<T> = lock_api::RwLock<RawRwSpinLock, T>;
+
+    /// A [`lock_api::RwLockReadGuard`] based on [`RawRwSpinLock`].
+    pub type RwSpinLockReadGuard<'a, T> = lock_api::RwLockReadGuard<'a, RawRwSpinLock, T>;
+
+    /// A [`lock_api::RwLockUpgradableReadGuard`] based on [`RawRwSpinLock`].
+    pub type RwSpinLockUpgradableReadGuard<'a, T> =
+        lock_api::RwLockUpgradableReadGuard<'a, RawRwSpinLock, T>;
+
+    /// A [`lock_api::RwLockWriteGuard`] based on [`RawRwSpinLock`].
+    pub type RwSpinLockWriteGuard<'a, T> = lock_api::RwLockWriteGuard<'a, RawRwSpinLock, T>;
+}
 
 pub use exclusive_cell::{CallOnce, CallOnceError, ExclusiveCell};
 pub use interrupt_mutex::{InterruptMutex, InterruptMutexGuard, RawInterruptMutex};

src/mutex/mod.rs

@@ -1,4 +1,13 @@
-pub(crate) mod spin;
+pub(crate) mod spin {
+    /// A simple spinlock with exponential backoff.
+    pub type RawSpinMutex = spinning_top::RawSpinlock<spinning_top::relax::Backoff>;
+
+    /// A [`lock_api::Mutex`] based on [`RawSpinMutex`].
+    pub type SpinMutex<T> = lock_api::Mutex<RawSpinMutex, T>;
+
+    /// A [`lock_api::MutexGuard`] based on [`RawSpinMutex`].
+    pub type SpinMutexGuard<'a, T> = lock_api::MutexGuard<'a, RawSpinMutex, T>;
+}
 pub(crate) mod ticket;
 
 use interrupt_mutex::RawInterruptMutex;

src/mutex/ticket.rs

@@ -2,7 +2,7 @@ use core::sync::atomic::{AtomicUsize, Ordering};
 
 use lock_api::{GuardSend, RawMutex, RawMutexFair};
 
-use crate::backoff::Backoff;
+use spinning_top::relax::{Backoff, Relax};
 
 /// A [fair] [ticket lock] with [exponential backoff].
 ///
@@ -28,9 +28,9 @@ unsafe impl RawMutex for RawTicketMutex {
     fn lock(&self) {
         let ticket = self.next_ticket.fetch_add(1, Ordering::Relaxed);
 
-        let mut backoff = Backoff::new();
+        let mut backoff = Backoff::default();
         while self.next_serving.load(Ordering::Acquire) != ticket {
-            backoff.snooze();
+            backoff.relax();
         }
     }