rsgc 1.1.0

Concurrent GC library for Rust
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
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
110
111
112
113
114
115

use std::{time::Instant, ops::{Deref, DerefMut}};

use super::mutex::{Mutex, Condvar, MutexGuard, WaitTimeoutResult};


/// A monitor is a synchronization primitive that can be used to protect shared data from concurrent access.
/// 
/// It combines a mutex and a condition variable.
pub struct Monitor<T> {
    mutex: Mutex<T>,
    cv: Condvar
}

unsafe impl<T> Send for Monitor<T> {}
unsafe impl<T> Sync for Monitor<T> {}

impl<T> Monitor<T> {
    pub const fn new(val: T) -> Self {
        Self {
            mutex: Mutex::new(val),
            cv: Condvar::new()
        }
    }

    pub fn lock<'a>(&'a self, safepoint: bool) -> MonitorLocker<'a, T> {
        MonitorLocker {
            guard: self.mutex.lock(safepoint),
            cv: &self.cv
        }
    }

    pub fn try_lock<'a>(&'a self, safepoint: bool) -> Option<MonitorLocker<'a, T>> {
        self.mutex.try_lock(safepoint).map(|guard| MonitorLocker {
            guard,
            cv: &self.cv
        })
    }

    pub fn notify_all(&self) -> usize {
        self.cv.notify_all()
    }

    pub fn notify_one(&self) -> bool {
        self.cv.notify_one()
    }

    pub fn get_mut(&mut self) -> &mut T {
        self.mutex.get_mut()
    }

    pub unsafe fn unsafe_get(&self) -> &T {
        self.mutex.unsafe_get()
    }

    pub fn mutex(&self) -> &Mutex<T> {
        &self.mutex
    }

    


}

pub struct MonitorLocker<'a, T> {
    cv: &'a Condvar,
    guard: MutexGuard<'a, T>,
}

impl<'a, T> MonitorLocker<'a, T> {
    pub fn wait(&mut self) {
        self.cv.wait(&mut self.guard);
    }

    pub fn wait_until(&mut self, timeout: Instant) {
        self.cv.wait_until(&mut self.guard, timeout);
    }

    pub fn wait_for(&mut self, timeout: std::time::Duration) -> WaitTimeoutResult {
        self.cv.wait_for(&mut self.guard, timeout)
    }

    pub fn wait_while(&mut self, condition: impl FnMut(&mut T) -> bool) {
        self.cv.wait_while(&mut self.guard, condition)
    }

    pub fn notify(self) -> bool {
        let res = self.cv.notify_one();
        res 
    }

    pub fn notify_all(&self) -> usize {
        let res = self.cv.notify_all();
       
        res 
    }
}

impl<'a, T> Deref for MonitorLocker<'a, T> {
    type Target = MutexGuard<'a, T>;

    fn deref(&self) -> &Self::Target {
        &self.guard
    }
}

impl<'a, T> DerefMut for MonitorLocker<'a, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.guard
    }
}
impl<'a, T> Drop for MonitorLocker<'a, T> {
    fn drop(&mut self) {
        self.cv.notify_all();
    }
}