1use crate::raw_mutex::RawMutex;
2use core::num::NonZeroUsize;
3use lock_api::{self, GetThreadId};
4
5pub struct RawThreadId;
7
8unsafe impl GetThreadId for RawThreadId {
9 const INIT: RawThreadId = RawThreadId;
10
11 fn nonzero_thread_id(&self) -> NonZeroUsize {
12 thread_local!(static KEY: u8 = const { 0 });
16 KEY.with(|x| {
17 NonZeroUsize::new(core::ptr::from_ref(x).addr())
18 .expect("thread-local variable address is null")
19 })
20 }
21}
22
23pub type ReentrantMutex<T> = lock_api::ReentrantMutex<RawMutex, RawThreadId, T>;
51
52pub type ReentrantMutexGuard<'a, T> = lock_api::ReentrantMutexGuard<'a, RawMutex, RawThreadId, T>;
57
58pub type MappedReentrantMutexGuard<'a, T> =
66 lock_api::MappedReentrantMutexGuard<'a, RawMutex, RawThreadId, T>;
67
68#[cfg(test)]
69mod tests {
70 use crate::ReentrantMutex;
71 use crate::ReentrantMutexGuard;
72 use std::cell::RefCell;
73 use std::sync::Arc;
74 use std::sync::mpsc::channel;
75 use std::thread;
76
77 #[cfg(feature = "serde")]
78 use postcard::{from_bytes, to_stdvec};
79
80 #[test]
81 fn smoke() {
82 let m = ReentrantMutex::new(2);
83 {
84 let a = m.lock();
85 {
86 let b = m.lock();
87 {
88 let c = m.lock();
89 assert_eq!(*c, 2);
90 }
91 assert_eq!(*b, 2);
92 }
93 assert_eq!(*a, 2);
94 }
95 }
96
97 #[test]
98 fn is_mutex() {
99 let m = Arc::new(ReentrantMutex::new(RefCell::new(0)));
100 let m2 = m.clone();
101 let lock = m.lock();
102 let child = thread::spawn(move || {
103 let lock = m2.lock();
104 assert_eq!(*lock.borrow(), 4950);
105 });
106 for i in 0..100 {
107 let lock = m.lock();
108 *lock.borrow_mut() += i;
109 }
110 drop(lock);
111 child.join().unwrap();
112 }
113
114 #[test]
115 fn trylock_works() {
116 let m = Arc::new(ReentrantMutex::new(()));
117 let m2 = m.clone();
118 let _lock = m.try_lock().unwrap();
119 let _lock2 = m.try_lock().unwrap();
120 thread::spawn(move || {
121 let lock = m2.try_lock();
122 assert!(lock.is_none());
123 })
124 .join()
125 .unwrap();
126 let _lock3 = m.try_lock().unwrap();
127 }
128
129 #[test]
130 fn test_reentrant_mutex_debug() {
131 let mutex = ReentrantMutex::new(vec![0u8, 10]);
132
133 assert_eq!(format!("{:?}", mutex), "ReentrantMutex { data: [0, 10] }");
134 }
135
136 #[test]
137 fn test_reentrant_mutex_bump() {
138 let mutex = Arc::new(ReentrantMutex::new(()));
139 let mutex2 = mutex.clone();
140
141 let mut guard = mutex.lock();
142
143 let (tx, rx) = channel();
144
145 thread::spawn(move || {
146 let _guard = mutex2.lock();
147 tx.send(()).unwrap();
148 });
149
150 while rx.try_recv().is_err() {
152 ReentrantMutexGuard::bump(&mut guard);
153 }
154 }
155
156 #[cfg(feature = "serde")]
157 #[test]
158 fn test_serde() {
159 let contents: Vec<u8> = vec![0, 1, 2];
160 let mutex = ReentrantMutex::new(contents.clone());
161
162 let serialized = to_stdvec(&mutex).unwrap();
163 let deserialized: ReentrantMutex<Vec<u8>> = from_bytes(&serialized).unwrap();
164
165 assert_eq!(*(mutex.lock()), *(deserialized.lock()));
166 assert_eq!(contents, *(deserialized.lock()));
167 }
168}