crossync 0.2.0

A fast concurrent programming suite 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

use crate::core::serial::SerialMutex;
use crate::sync::RawMutex;

#[derive(Clone, Copy, Debug)]
enum Kind {
    Shared,
    Exclusive,
    SerialRead,
    SerialWrite,
}

// Pack the reader token into the discriminant's padding on 64-bit targets.
#[derive(Clone, Copy, Debug)]
pub(super) struct GuardLock {
    lock: *const (),
    owner: u32,
    kind: Kind,
}

impl GuardLock {
    #[inline]
    pub(super) fn shared(lock: *const RawMutex) -> Self {
        Self {
            lock: lock.cast(),
            owner: 0,
            kind: Kind::Shared,
        }
    }
    #[inline]
    pub(super) fn exclusive(lock: *const RawMutex) -> Self {
        Self {
            lock: lock.cast(),
            owner: 0,
            kind: Kind::Exclusive,
        }
    }
    #[inline]
    pub(super) fn serial_read(lock: *const SerialMutex, owner: u32) -> Self {
        Self {
            lock: lock.cast(),
            owner,
            kind: Kind::SerialRead,
        }
    }
    #[inline]
    pub(super) fn serial_write(lock: *const SerialMutex) -> Self {
        Self {
            lock: lock.cast(),
            owner: 0,
            kind: Kind::SerialWrite,
        }
    }
    #[inline]
    pub(super) unsafe fn is_locked(self) -> bool {
        unsafe {
            match self.kind {
                Kind::Shared => (*self.lock.cast::<RawMutex>()).is_locked_shared(),
                Kind::Exclusive => (*self.lock.cast::<RawMutex>()).is_locked_exclusive(),
                Kind::SerialRead => (*self.lock.cast::<SerialMutex>()).is_read_locked(),
                Kind::SerialWrite => (*self.lock.cast::<SerialMutex>()).is_write_locked(),
            }
        }
    }
    #[inline]
    pub(super) unsafe fn unlock(self) {
        unsafe {
            match self.kind {
                Kind::Shared => (*self.lock.cast::<RawMutex>()).unlock_shared(),
                Kind::Exclusive => (*self.lock.cast::<RawMutex>()).unlock_exclusive(),
                Kind::SerialRead => (*self.lock.cast::<SerialMutex>()).unlock_read(self.owner),
                Kind::SerialWrite => (*self.lock.cast::<SerialMutex>()).unlock_write(),
            }
        }
    }
}