Struct maitake_sync::blocking::DefaultMutex

pub struct DefaultMutex(/* private fields */);

Default, best-effort ScopedRawMutex implementation.

This is the default Lock type parameter for the Mutex type, and for the async synchronization primitives that use the blocking Mutex. This type makes a best-effort attempt to Do The Right Thing based on the currently enabled feature flags. In particular, here’s what we currently give you:

• If cfg(loom) is enabled, then the DefaultMutex is a loom mutex so that maitake-sync primitives work nicely in loom tests

• If the std feature is enabled, then the DefaultMutex is a [std::sync::Mutex], so that std users get an OS mutex rather than a spinlock.

• If the critical-section feature is enabled, then the DefaultMutex is a spinlock that acquires a critical section once locked. This ensures that bare-metal users who have enabled critical-section get a mutex that disables IRQs when locked.

• Otherwise, the DefaultMutex is a Spinlock. This is the default behavior and will at least work on all platforms, but may not be the most efficient, and may not be IRQ-safe.

Notes

• Regardless of feature flags, this type implements the ScopedRawMutex trait, not the RawMutex trait. In order to use methods or types that require a RawMutex, you must provide your own RawMutex type.

• :warning: If the critical-section feature is enabled, you MUST provide a critical-section implementation. See the critical-section documentation for details on how to select an implementation. If you don’t provide an implementation, you’ll get a linker error when compiling your code.

• This type has a const fn new() constructor and implements the ConstInit trait except when cfg(loom) is enabled.

  Loom users are probably already aware that loom’s simulated types cannot be const initialized, as they must bind to the current test iteration when constructed. This is not a non-additive feature flag, because loom support can only be enabled by a RUSTFLAGS cfg set by the top-level build, and not by a dependency.s

Implementations

impl DefaultMutex

pub const fn new() -> Self

Returns a new DefaultMutex.

See the type-level documentation for details on how to use a DefaultMutex.

Trait Implementations

impl ConstInit for DefaultMutex

const INIT: Self = _

Create a new instance.

impl Debug for DefaultMutex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DefaultMutex

fn default() -> Self

Returns the “default value” for a type.

impl ScopedRawMutex for DefaultMutex

fn with_lock<R>(&self, f: impl FnOnce() -> R) -> R

Lock this ScopedRawMutex, calling f() after the lock has been acquired, and releasing the lock after the completion of f().

fn try_with_lock<R>(&self, f: impl FnOnce() -> R) -> Option<R>

Lock this ScopedRawMutex, calling f() after the lock has been acquired, and releasing the lock after the completion of f().

fn is_locked(&self) -> bool

Is this mutex currently locked?