Debian Codegraph @

third_party/rust/wgpu-core/src/lock/vanilla.rs

raw
1 //! Plain, uninstrumented wrappers around [`parking_lot`] lock types.
2 //!
3 //! These definitions are used when no particular lock instrumentation
4 //! Cargo feature is selected.
5
6 use core::{fmt, ops};
7
8 /// A plain wrapper around [`parking_lot::Mutex`].
9 ///
10 /// This is just like [`parking_lot::Mutex`], except that our [`new`]
11 /// method takes a rank, indicating where the new mutex should sit in
12 /// `wgpu-core`'s lock ordering. The rank is ignored.
13 ///
14 /// See the [`lock`] module documentation for other wrappers.
15 ///
16 /// [`new`]: Mutex::new
17 /// [`lock`]: crate::lock
18 pub struct Mutex<T>(parking_lot::Mutex<T>);
19
20 /// A guard produced by locking [`Mutex`].
21 ///
22 /// This is just a wrapper around a [`parking_lot::MutexGuard`].
23 pub struct MutexGuard<'a, T>(parking_lot::MutexGuard<'a, T>);
24
25 impl<T> Mutex<T> {
26 pub fn new(_rank: super::rank::LockRank, value: T) -> Mutex<T> {
27 Mutex(parking_lot::Mutex::new(value))
28 }
29
30 pub fn lock(&self) -> MutexGuard<T> {
31 MutexGuard(self.0.lock())
32 }
33
34 pub fn into_inner(self) -> T {
35 self.0.into_inner()
36 }
37 }
38
39 impl<'a, T> ops::Deref for MutexGuard<'a, T> {
40 type Target = T;
41
42 fn deref(&self) -> &Self::Target {
43 self.0.deref()
44 }
45 }
46
47 impl<'a, T> ops::DerefMut for MutexGuard<'a, T> {
48 fn deref_mut(&mut self) -> &mut Self::Target {
49 self.0.deref_mut()
50 }
51 }
52
53 impl<T: fmt::Debug> fmt::Debug for Mutex<T> {
54 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
55 self.0.fmt(f)
56 }
57 }
58
59 /// A plain wrapper around [`parking_lot::RwLock`].
60 ///
61 /// This is just like [`parking_lot::RwLock`], except that our [`new`]
62 /// method takes a rank, indicating where the new mutex should sit in
63 /// `wgpu-core`'s lock ordering. The rank is ignored.
64 ///
65 /// See the [`lock`] module documentation for other wrappers.
66 ///
67 /// [`new`]: RwLock::new
68 /// [`lock`]: crate::lock
69 pub struct RwLock<T>(parking_lot::RwLock<T>);
70
71 /// A read guard produced by locking [`RwLock`] as a reader.
72 ///
73 /// This is just a wrapper around a [`parking_lot::RwLockReadGuard`].
74 pub struct RwLockReadGuard<'a, T>(parking_lot::RwLockReadGuard<'a, T>);
75
76 /// A write guard produced by locking [`RwLock`] as a writer.
77 ///
78 /// This is just a wrapper around a [`parking_lot::RwLockWriteGuard`].
79 pub struct RwLockWriteGuard<'a, T>(parking_lot::RwLockWriteGuard<'a, T>);
80
81 impl<T> RwLock<T> {
82 pub fn new(_rank: super::rank::LockRank, value: T) -> RwLock<T> {
83 RwLock(parking_lot::RwLock::new(value))
84 }
85
86 pub fn read(&self) -> RwLockReadGuard<T> {
87 RwLockReadGuard(self.0.read())
88 }
89
90 pub fn write(&self) -> RwLockWriteGuard<T> {
91 RwLockWriteGuard(self.0.write())
92 }
93 }
94
95 impl<'a, T> RwLockWriteGuard<'a, T> {
96 pub fn downgrade(this: Self) -> RwLockReadGuard<'a, T> {
97 RwLockReadGuard(parking_lot::RwLockWriteGuard::downgrade(this.0))
98 }
99 }
100
101 impl<T: fmt::Debug> fmt::Debug for RwLock<T> {
102 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
103 self.0.fmt(f)
104 }
105 }
106
107 impl<'a, T> ops::Deref for RwLockReadGuard<'a, T> {
108 type Target = T;
109
110 fn deref(&self) -> &Self::Target {
111 self.0.deref()
112 }
113 }
114
115 impl<'a, T> ops::Deref for RwLockWriteGuard<'a, T> {
116 type Target = T;
117
118 fn deref(&self) -> &Self::Target {
119 self.0.deref()
120 }
121 }
122
123 impl<'a, T> ops::DerefMut for RwLockWriteGuard<'a, T> {
124 fn deref_mut(&mut self) -> &mut Self::Target {
125 self.0.deref_mut()
126 }
127 }