awkernel_sync 0.1.0

no_std synchronization primitives (mutex, rwlock, spinlock, MCS lock) with interrupt guards for the Awkernel operating system.
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! # Mutex and LockGuard Types
//!
//! The `Mutex` and `LockGuard` types in this module provide a way to manage concurrent access to shared resources.
//! These types have different implementations depending on whether the `std` feature is enabled or not.
//! When the `std` feature is enabled, it uses `parking_lot::Mutex` for efficient locking.
//! When the `std` feature is disabled, it falls back to using `super::mcs::MCSLock`.

#[cfg(all(not(feature = "std"), not(feature = "spinlock")))]
type Lock<T> = super::mcs::MCSLock<T>;

#[cfg(all(not(feature = "std"), feature = "spinlock"))]
type Lock<T> = super::spinlock::SpinLock<T>;

#[cfg(all(not(feature = "std"), not(feature = "spinlock")))]
pub type LockGuard<'a, T> = super::mcs::MCSLockGuard<'a, T>;

#[cfg(all(not(feature = "std"), feature = "spinlock"))]
pub type LockGuard<'a, T> = super::spinlock::SpinLockGuard<'a, T>;

#[cfg(feature = "std")]
type Lock<T> = parking_lot::Mutex<T>;

#[cfg(feature = "std")]
pub type LockGuard<'a, T> = parking_lot::MutexGuard<'a, T>;

/// A mutual exclusion primitive that provides safe concurrent access to the inner data.
///
/// The `Mutex` type can be used to ensure that only one thread can access the data at a time.
///
/// It has different implementations depending on whether the `std` feature is enabled or not.
/// When the `std` feature is enabled, it uses `parking_lot::Mutex` for efficient locking.
/// When the `std` feature is disabled, it falls back to using `super::mcs::MCSLock`.
///
/// # Example
///
/// ```
/// use awkernel_lib::sync::mutex::{MCSNode, Mutex};
/// use std::{thread, sync::Arc};
///
/// let data = Arc::new(Mutex::new(0));
///
/// let handles: Vec<_> = (0..10).map(|_| {
///     let data = data.clone();
///     thread::spawn(move || {
///         // Lock the data to access the shared resource.
///         let mut node = MCSNode::new();
///         let mut guard = data.lock(&mut node);
///         *guard += 1;
///     })
/// }).collect();
///
/// for handle in handles {
///     handle.join().unwrap();
/// }
///
/// // Since only one thread can access the data at a time, the final value will be 10.
/// let mut node = MCSNode::new();
/// assert_eq!(*data.lock(&mut node), 10);
/// ```
pub struct Mutex<T: Send> {
    #[cfg(not(std))]
    mutex: Lock<T>,
}

impl<T: Send> Mutex<T> {
    pub const fn new(v: T) -> Self {
        Self {
            mutex: Lock::new(v),
        }
    }

    #[cfg(all(not(feature = "std"), not(feature = "spinlock")))]
    #[inline(always)]
    pub fn lock<'a>(&'a self, node: &'a mut MCSNode<T>) -> LockGuard<'a, T> {
        self.mutex.lock(node)
    }

    #[cfg(all(not(feature = "std"), feature = "spinlock"))]
    #[inline(always)]
    pub fn lock<'a>(&'a self, _node: &'a mut MCSNode<T>) -> LockGuard<'a, T> {
        self.mutex.lock()
    }

    #[cfg(feature = "std")]
    #[inline(always)]
    pub fn lock<'a>(&'a self, _node: &mut MCSNode<T>) -> LockGuard<'a, T> {
        self.mutex.lock()
    }

    #[cfg(all(not(feature = "std"), not(feature = "spinlock")))]
    #[inline(always)]
    pub fn try_lock<'a>(&'a self, node: &'a mut MCSNode<T>) -> Option<LockGuard<'a, T>> {
        self.mutex.try_lock(node)
    }

    #[cfg(all(not(feature = "std"), feature = "spinlock"))]
    #[inline(always)]
    pub fn try_lock<'a>(&'a self, _node: &'a mut MCSNode<T>) -> Option<LockGuard<'a, T>> {
        self.mutex.try_lock()
    }

    #[cfg(feature = "std")]
    #[inline(always)]
    pub fn try_lock<'a>(&'a self, _node: &mut MCSNode<T>) -> Option<LockGuard<'a, T>> {
        self.mutex.try_lock()
    }
}

pub use super::mcs::MCSNode;