aboutsummaryrefslogtreecommitdiff
path: root/src/loom
diff options
context:
space:
mode:
Diffstat (limited to 'src/loom')
-rw-r--r--src/loom/mocked.rs27
-rw-r--r--src/loom/mod.rs2
-rw-r--r--src/loom/std/atomic_ptr.rs8
-rw-r--r--src/loom/std/atomic_u16.rs2
-rw-r--r--src/loom/std/atomic_u32.rs2
-rw-r--r--src/loom/std/atomic_u8.rs2
-rw-r--r--src/loom/std/atomic_usize.rs2
-rw-r--r--src/loom/std/mod.rs19
-rw-r--r--src/loom/std/mutex.rs31
-rw-r--r--src/loom/std/parking_lot.rs20
-rw-r--r--src/loom/std/unsafe_cell.rs2
11 files changed, 97 insertions, 20 deletions
diff --git a/src/loom/mocked.rs b/src/loom/mocked.rs
index 7891395..367d59b 100644
--- a/src/loom/mocked.rs
+++ b/src/loom/mocked.rs
@@ -1,5 +1,32 @@
pub(crate) use loom::*;
+pub(crate) mod sync {
+
+ pub(crate) use loom::sync::MutexGuard;
+
+ #[derive(Debug)]
+ pub(crate) struct Mutex<T>(loom::sync::Mutex<T>);
+
+ #[allow(dead_code)]
+ impl<T> Mutex<T> {
+ #[inline]
+ pub(crate) fn new(t: T) -> Mutex<T> {
+ Mutex(loom::sync::Mutex::new(t))
+ }
+
+ #[inline]
+ pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
+ self.0.lock().unwrap()
+ }
+
+ #[inline]
+ pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
+ self.0.try_lock().ok()
+ }
+ }
+ pub(crate) use loom::sync::*;
+}
+
pub(crate) mod rand {
pub(crate) fn seed() -> u64 {
1
diff --git a/src/loom/mod.rs b/src/loom/mod.rs
index 56a41f2..5957b53 100644
--- a/src/loom/mod.rs
+++ b/src/loom/mod.rs
@@ -1,6 +1,8 @@
//! This module abstracts over `loom` and `std::sync` depending on whether we
//! are running tests or not.
+#![allow(unused)]
+
#[cfg(not(all(test, loom)))]
mod std;
#[cfg(not(all(test, loom)))]
diff --git a/src/loom/std/atomic_ptr.rs b/src/loom/std/atomic_ptr.rs
index f7fd56c..236645f 100644
--- a/src/loom/std/atomic_ptr.rs
+++ b/src/loom/std/atomic_ptr.rs
@@ -1,5 +1,5 @@
use std::fmt;
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
/// `AtomicPtr` providing an additional `load_unsync` function.
pub(crate) struct AtomicPtr<T> {
@@ -21,6 +21,12 @@ impl<T> Deref for AtomicPtr<T> {
}
}
+impl<T> DerefMut for AtomicPtr<T> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.inner
+ }
+}
+
impl<T> fmt::Debug for AtomicPtr<T> {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
self.deref().fmt(fmt)
diff --git a/src/loom/std/atomic_u16.rs b/src/loom/std/atomic_u16.rs
index 7039097..c1c5312 100644
--- a/src/loom/std/atomic_u16.rs
+++ b/src/loom/std/atomic_u16.rs
@@ -11,7 +11,7 @@ unsafe impl Send for AtomicU16 {}
unsafe impl Sync for AtomicU16 {}
impl AtomicU16 {
- pub(crate) fn new(val: u16) -> AtomicU16 {
+ pub(crate) const fn new(val: u16) -> AtomicU16 {
let inner = UnsafeCell::new(std::sync::atomic::AtomicU16::new(val));
AtomicU16 { inner }
}
diff --git a/src/loom/std/atomic_u32.rs b/src/loom/std/atomic_u32.rs
index 6f786c5..61f95fb 100644
--- a/src/loom/std/atomic_u32.rs
+++ b/src/loom/std/atomic_u32.rs
@@ -11,7 +11,7 @@ unsafe impl Send for AtomicU32 {}
unsafe impl Sync for AtomicU32 {}
impl AtomicU32 {
- pub(crate) fn new(val: u32) -> AtomicU32 {
+ pub(crate) const fn new(val: u32) -> AtomicU32 {
let inner = UnsafeCell::new(std::sync::atomic::AtomicU32::new(val));
AtomicU32 { inner }
}
diff --git a/src/loom/std/atomic_u8.rs b/src/loom/std/atomic_u8.rs
index 4fcd0df..408aea3 100644
--- a/src/loom/std/atomic_u8.rs
+++ b/src/loom/std/atomic_u8.rs
@@ -11,7 +11,7 @@ unsafe impl Send for AtomicU8 {}
unsafe impl Sync for AtomicU8 {}
impl AtomicU8 {
- pub(crate) fn new(val: u8) -> AtomicU8 {
+ pub(crate) const fn new(val: u8) -> AtomicU8 {
let inner = UnsafeCell::new(std::sync::atomic::AtomicU8::new(val));
AtomicU8 { inner }
}
diff --git a/src/loom/std/atomic_usize.rs b/src/loom/std/atomic_usize.rs
index 0fe998f..0d5f36e 100644
--- a/src/loom/std/atomic_usize.rs
+++ b/src/loom/std/atomic_usize.rs
@@ -11,7 +11,7 @@ unsafe impl Send for AtomicUsize {}
unsafe impl Sync for AtomicUsize {}
impl AtomicUsize {
- pub(crate) fn new(val: usize) -> AtomicUsize {
+ pub(crate) const fn new(val: usize) -> AtomicUsize {
let inner = UnsafeCell::new(std::sync::atomic::AtomicUsize::new(val));
AtomicUsize { inner }
}
diff --git a/src/loom/std/mod.rs b/src/loom/std/mod.rs
index 60ee56a..9525286 100644
--- a/src/loom/std/mod.rs
+++ b/src/loom/std/mod.rs
@@ -6,6 +6,7 @@ mod atomic_u32;
mod atomic_u64;
mod atomic_u8;
mod atomic_usize;
+mod mutex;
#[cfg(feature = "parking_lot")]
mod parking_lot;
mod unsafe_cell;
@@ -14,7 +15,12 @@ pub(crate) mod cell {
pub(crate) use super::unsafe_cell::UnsafeCell;
}
-#[cfg(any(feature = "sync", feature = "io-driver"))]
+#[cfg(any(
+ feature = "net",
+ feature = "process",
+ feature = "signal",
+ feature = "sync",
+))]
pub(crate) mod future {
pub(crate) use crate::sync::AtomicWaker;
}
@@ -55,9 +61,10 @@ pub(crate) mod sync {
#[cfg(not(feature = "parking_lot"))]
#[allow(unused_imports)]
- pub(crate) use std::sync::{
- Condvar, Mutex, MutexGuard, RwLock, RwLockReadGuard, WaitTimeoutResult,
- };
+ pub(crate) use std::sync::{Condvar, MutexGuard, RwLock, RwLockReadGuard, WaitTimeoutResult};
+
+ #[cfg(not(feature = "parking_lot"))]
+ pub(crate) use crate::loom::std::mutex::Mutex;
pub(crate) mod atomic {
pub(crate) use crate::loom::std::atomic_ptr::AtomicPtr;
@@ -72,12 +79,12 @@ pub(crate) mod sync {
}
pub(crate) mod sys {
- #[cfg(feature = "rt-threaded")]
+ #[cfg(feature = "rt-multi-thread")]
pub(crate) fn num_cpus() -> usize {
usize::max(1, num_cpus::get())
}
- #[cfg(not(feature = "rt-threaded"))]
+ #[cfg(not(feature = "rt-multi-thread"))]
pub(crate) fn num_cpus() -> usize {
1
}
diff --git a/src/loom/std/mutex.rs b/src/loom/std/mutex.rs
new file mode 100644
index 0000000..bf14d62
--- /dev/null
+++ b/src/loom/std/mutex.rs
@@ -0,0 +1,31 @@
+use std::sync::{self, MutexGuard, TryLockError};
+
+/// Adapter for `std::Mutex` that removes the poisoning aspects
+// from its api
+#[derive(Debug)]
+pub(crate) struct Mutex<T: ?Sized>(sync::Mutex<T>);
+
+#[allow(dead_code)]
+impl<T> Mutex<T> {
+ #[inline]
+ pub(crate) fn new(t: T) -> Mutex<T> {
+ Mutex(sync::Mutex::new(t))
+ }
+
+ #[inline]
+ pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
+ match self.0.lock() {
+ Ok(guard) => guard,
+ Err(p_err) => p_err.into_inner(),
+ }
+ }
+
+ #[inline]
+ pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
+ match self.0.try_lock() {
+ Ok(guard) => Some(guard),
+ Err(TryLockError::Poisoned(p_err)) => Some(p_err.into_inner()),
+ Err(TryLockError::WouldBlock) => None,
+ }
+ }
+}
diff --git a/src/loom/std/parking_lot.rs b/src/loom/std/parking_lot.rs
index 25d94af..c03190f 100644
--- a/src/loom/std/parking_lot.rs
+++ b/src/loom/std/parking_lot.rs
@@ -3,7 +3,7 @@
//!
//! This can be extended to additional types/methods as required.
-use std::sync::{LockResult, TryLockError, TryLockResult};
+use std::sync::LockResult;
use std::time::Duration;
// Types that do not need wrapping
@@ -27,16 +27,20 @@ impl<T> Mutex<T> {
}
#[inline]
- pub(crate) fn lock(&self) -> LockResult<MutexGuard<'_, T>> {
- Ok(self.0.lock())
+ #[cfg(all(feature = "parking_lot", not(all(loom, test)),))]
+ #[cfg_attr(docsrs, doc(cfg(all(feature = "parking_lot",))))]
+ pub(crate) const fn const_new(t: T) -> Mutex<T> {
+ Mutex(parking_lot::const_mutex(t))
}
#[inline]
- pub(crate) fn try_lock(&self) -> TryLockResult<MutexGuard<'_, T>> {
- match self.0.try_lock() {
- Some(guard) => Ok(guard),
- None => Err(TryLockError::WouldBlock),
- }
+ pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
+ self.0.lock()
+ }
+
+ #[inline]
+ pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
+ self.0.try_lock()
}
// Note: Additional methods `is_poisoned` and `into_inner`, can be
diff --git a/src/loom/std/unsafe_cell.rs b/src/loom/std/unsafe_cell.rs
index f2b03d8..66c1d79 100644
--- a/src/loom/std/unsafe_cell.rs
+++ b/src/loom/std/unsafe_cell.rs
@@ -2,7 +2,7 @@
pub(crate) struct UnsafeCell<T>(std::cell::UnsafeCell<T>);
impl<T> UnsafeCell<T> {
- pub(crate) fn new(data: T) -> UnsafeCell<T> {
+ pub(crate) const fn new(data: T) -> UnsafeCell<T> {
UnsafeCell(std::cell::UnsafeCell::new(data))
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-16 01:37:43 +0000