Use a git version for RawReentrantMutex + RawMutexStatus

coolreader18 · coolreader18 · commit 0a9d8ecd80bb · 2020-05-18T11:27:40.000-05:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/vm/Cargo.toml b/vm/Cargo.toml
@@ -71,7 +71,7 @@ smallbox = "0.8"
 bstr = "0.2.12"
 crossbeam-utils = "0.7"
 generational-arena = "0.2"
-parking_lot = "0.10"
+parking_lot = { git = "https://github.com/coolreader18/parking_lot", branch = "pub-raw-reentrant" }
 
 ## unicode stuff
 unicode_names2 = "0.4"
diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs
@@ -5,12 +5,10 @@ use crate::pyobject::{PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 use parking_lot::{
-    lock_api::{GetThreadId, RawMutex as RawMutexT, RawMutexTimed},
+    lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex},
     RawMutex, RawThreadId,
 };
-use std::cell::Cell;
 use std::fmt;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
 
 #[cfg(not(target_os = "windows"))]
@@ -93,89 +91,13 @@ impl LockProtocol for PyLock {
 
 #[pyimpl(with(LockProtocol))]
 impl PyLock {
-    // TODO: locked(), might require something to change in parking_lot
-}
-
-// Copied from lock_api
-// TODO: open a PR to make this public in lock_api
-struct RawReentrantMutex<R, G> {
-    owner: AtomicUsize,
-    lock_count: Cell<usize>,
-    mutex: R,
-    get_thread_id: G,
-}
-
-impl<R: RawMutexT, G: GetThreadId> RawReentrantMutex<R, G> {
-    #[inline]
-    fn lock_internal<F: FnOnce() -> bool>(&self, try_lock: F) -> bool {
-        let id = self.get_thread_id.nonzero_thread_id().get();
-        if self.owner.load(Ordering::Relaxed) == id {
-            self.lock_count.set(
-                self.lock_count
-                    .get()
-                    .checked_add(1)
-                    .expect("ReentrantMutex lock count overflow"),
-            );
-        } else {
-            if !try_lock() {
-                return false;
-            }
-            self.owner.store(id, Ordering::Relaxed);
-            debug_assert_eq!(self.lock_count.get(), 0);
-            self.lock_count.set(1);
-        }
-        true
-    }
-}
-
-unsafe impl<R: RawMutexT + Send, G: GetThreadId + Send> Send for RawReentrantMutex<R, G> {}
-unsafe impl<R: RawMutexT + Sync, G: GetThreadId + Sync> Sync for RawReentrantMutex<R, G> {}
-
-unsafe impl<R: RawMutexT, G: GetThreadId> RawMutexT for RawReentrantMutex<R, G> {
-    const INIT: Self = RawReentrantMutex {
-        owner: AtomicUsize::new(0),
-        lock_count: Cell::new(0),
-        mutex: R::INIT,
-        get_thread_id: G::INIT,
-    };
-
-    type GuardMarker = R::GuardMarker;
-
-    #[inline]
-    fn lock(&self) {
-        self.lock_internal(|| {
-            self.mutex.lock();
-            true
-        });
-    }
-
-    #[inline]
-    fn try_lock(&self) -> bool {
-        self.lock_internal(|| self.mutex.try_lock())
-    }
-
-    #[inline]
-    fn unlock(&self) {
-        let lock_count = self.lock_count.get() - 1;
-        self.lock_count.set(lock_count);
-        if lock_count == 0 {
-            self.owner.store(0, Ordering::Relaxed);
-            self.mutex.unlock();
+    #[pymethod]
+    fn locked(&self) -> bool {
+        let acquired_lock = self.mu.try_lock();
+        if acquired_lock {
+            self.mu.unlock();
         }
-    }
-}
-
-unsafe impl<R: RawMutexTimed, G: GetThreadId> RawMutexTimed for RawReentrantMutex<R, G> {
-    type Instant = R::Instant;
-    type Duration = R::Duration;
-    #[inline]
-    fn try_lock_until(&self, timeout: R::Instant) -> bool {
-        self.lock_internal(|| self.mutex.try_lock_until(timeout))
-    }
-
-    #[inline]
-    fn try_lock_for(&self, timeout: R::Duration) -> bool {
-        self.lock_internal(|| self.mutex.try_lock_for(timeout))
+        !acquired_lock
     }
 }
 
