blob: f91e8f9f59a140dbe58ff8f14581aff6112e04a7 (
plain)
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
|
//! System Mutexes
//!
//! The Windows implementation of mutexes is a little odd and it might not be
//! immediately obvious what's going on. The primary oddness is that SRWLock is
//! used instead of CriticalSection, and this is done because:
//!
//! 1. SRWLock is several times faster than CriticalSection according to
//! benchmarks performed on both Windows 8 and Windows 7.
//!
//! 2. CriticalSection allows recursive locking while SRWLock deadlocks. The
//! Unix implementation deadlocks so consistency is preferred. See #19962 for
//! more details.
//!
//! 3. While CriticalSection is fair and SRWLock is not, the current Rust policy
//! is that there are no guarantees of fairness.
use crate::cell::UnsafeCell;
use crate::sys::c;
pub struct Mutex {
srwlock: UnsafeCell<c::SRWLOCK>,
}
// Windows SRW Locks are movable (while not borrowed).
pub type MovableMutex = Mutex;
unsafe impl Send for Mutex {}
unsafe impl Sync for Mutex {}
#[inline]
pub unsafe fn raw(m: &Mutex) -> c::PSRWLOCK {
m.srwlock.get()
}
impl Mutex {
#[inline]
pub const fn new() -> Mutex {
Mutex { srwlock: UnsafeCell::new(c::SRWLOCK_INIT) }
}
#[inline]
pub unsafe fn init(&mut self) {}
#[inline]
pub unsafe fn lock(&self) {
c::AcquireSRWLockExclusive(raw(self));
}
#[inline]
pub unsafe fn try_lock(&self) -> bool {
c::TryAcquireSRWLockExclusive(raw(self)) != 0
}
#[inline]
pub unsafe fn unlock(&self) {
c::ReleaseSRWLockExclusive(raw(self));
}
}
|
