Crate hermit_sync
source ·Expand description
Overview
hermit-sync provides synchronization primitives targeted at operating system kernels.
Interrupts
without_interrupts
runs a closure with disabled interrupts.
Mutexes
This crate provides three kinds of mutexes based on lock_api::RawMutex
:
RawSpinMutex
is a simple test and test-and-set spinlock with exponential backoff.RawTicketMutex
is a fair ticket lock with exponential backoff.RawInterruptMutex
wraps another mutex and disables interrupts while locked.
For API documentation see lock_api::Mutex
.
Examples
use hermit_sync::InterruptSpinMutex;
static NUMBER: InterruptSpinMutex<usize> = InterruptSpinMutex::new(0);
// Modify the data
*NUMBER.lock() = 2;
// Read the data
let answer = *NUMBER.lock();
assert_eq!(2, answer);
Initializing Static Data
There are two primitives for safely initializing static data based on generic_once_cell
and RawSpinMutex
:
OnceCell
can be written to only once and can then be accessed without locking.Lazy
wraps aOnceCell
and is initialized on the first access from a closure.
For API documentation see generic_once_cell::OnceCell
and generic_once_cell::Lazy
.
Examples
use std::collections::HashMap;
use hermit_sync::InterruptLazy;
static MAP: InterruptLazy<HashMap<usize, String>> = InterruptLazy::new(|| {
// This is run on the first access of MAP.
let mut map = HashMap::new();
map.insert(42, "Ferris".to_string());
map.insert(3, "やれやれだぜ".to_string());
map
});
assert_eq!("Ferris", MAP.get(&42).unwrap());
Accessing Static Data Mutably
There is ExclusiveCell
for safely accessing static data mutable once.
Type Definitions
This crate provides a lot of type definitions for ease of use:
Structs
- A synchronization primitive that can only be called once sucessfully.
- The
CallOnceError
error indicates thatCallOnce::call_once
has been called more than once. - A synchronization primitive which can be accessed only once.
- An interrupt-safe mutex.
- A simple spinning, read-preferring readers-writer lock with exponential backoff.
Functions
- Run a closure with disabled interrupts.
Type Aliases
- A
generic_once_cell::Lazy
, initialized usingRawInterruptSpinMutex
. - A
lock_api::Mutex
based onRawInterruptMutex
. - A
lock_api::MutexGuard
based onRawInterruptMutex
. - A
generic_once_cell::OnceCell
, initialized usingRawInterruptSpinMutex
. - A
lock_api::Mutex
based onRawInterruptSpinMutex
. - A
lock_api::MutexGuard
based onRawInterruptSpinMutex
. - A
lock_api::Mutex
based onRawInterruptTicketMutex
. - A
lock_api::MutexGuard
based onRawInterruptTicketMutex
. - A
generic_once_cell::Lazy
, initialized usingRawSpinMutex
. - A
generic_once_cell::OnceCell
, initialized usingRawSpinMutex
. - An interrupt-safe
RawSpinMutex
. - An interrupt-safe
RawTicketMutex
. - A
lock_api::RwLock
based onRawRwSpinLock
. - A
lock_api::RwLockReadGuard
based onRawRwSpinLock
. - A
lock_api::RwLockUpgradableReadGuard
based onRawRwSpinLock
. - A
lock_api::RwLockWriteGuard
based onRawRwSpinLock
. - A
lock_api::Mutex
based onRawSpinMutex
. - A
lock_api::MutexGuard
based onRawSpinMutex
. - A
lock_api::Mutex
based onRawTicketMutex
. - A
lock_api::MutexGuard
based onRawTicketMutex
.