hermit-sync 0.1.6

Synchronization primitives for kernels.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#[cfg(not(feature = "all-one-shot"))]
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>;
}
#[cfg(feature = "all-one-shot")]
pub(crate) mod spin {
    pub use one_shot_mutex::{
        OneShotMutex as SpinMutex, OneShotMutexGuard as SpinMutexGuard,
        RawOneShotMutex as RawSpinMutex,
    };
}
#[cfg(not(feature = "all-one-shot"))]
pub(crate) mod ticket;
#[cfg(feature = "all-one-shot")]
pub(crate) mod ticket {
    pub use one_shot_mutex::{
        OneShotMutex as TicketMutex, OneShotMutexGuard as TicketMutexGuard,
        RawOneShotMutex as RawTicketMutex,
    };
}

use interrupt_mutex::RawInterruptMutex;
use one_shot_mutex::RawOneShotMutex;
use spin::RawSpinMutex;
use ticket::RawTicketMutex;

/// An interrupt-safe [`RawOneShotMutex`].
pub type RawInterruptOneShotMutex = RawInterruptMutex<RawOneShotMutex>;

/// A [`lock_api::Mutex`] based on [`RawInterruptOneShotMutex`].
pub type InterruptOneShotMutex<T> = lock_api::Mutex<RawInterruptOneShotMutex, T>;

/// A [`lock_api::MutexGuard`] based on [`RawInterruptOneShotMutex`].
pub type InterruptOneShotMutexGuard<'a, T> = lock_api::MutexGuard<'a, RawInterruptOneShotMutex, T>;

/// An interrupt-safe [`RawSpinMutex`].
pub type RawInterruptSpinMutex = RawInterruptMutex<RawSpinMutex>;

/// A [`lock_api::Mutex`] based on [`RawInterruptSpinMutex`].
pub type InterruptSpinMutex<T> = lock_api::Mutex<RawInterruptSpinMutex, T>;

/// A [`lock_api::MutexGuard`] based on [`RawInterruptSpinMutex`].
pub type InterruptSpinMutexGuard<'a, T> = lock_api::MutexGuard<'a, RawInterruptSpinMutex, T>;

/// An interrupt-safe [`RawTicketMutex`].
pub type RawInterruptTicketMutex = RawInterruptMutex<RawTicketMutex>;

/// A [`lock_api::Mutex`] based on [`RawInterruptTicketMutex`].
pub type InterruptTicketMutex<T> = lock_api::Mutex<RawInterruptTicketMutex, T>;

/// A [`lock_api::MutexGuard`] based on [`RawInterruptTicketMutex`].
pub type InterruptTicketMutexGuard<'a, T> = lock_api::MutexGuard<'a, RawInterruptTicketMutex, T>;