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 a OnceCell 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:

`RawMutex`	Base	With `RawInterruptMutex`
`R`	`Mutex`	`InterruptMutex`
`RawSpinMutex`		`RawInterruptSpinMutex`
	`SpinMutex`	`InterruptSpinMutex`
	`SpinMutexGuard`	`InterruptSpinMutexGuard`
	`OnceCell`	`InterruptOnceCell`
	`Lazy`	`InterruptLazy`
`RawTicketMutex`		`RawInterruptTicketMutex`
	`TicketMutex`	`InterruptTicketMutex`
	`TicketMutexGuard`	`InterruptTicketMutexGuard`