Remove unused experimental deadlock feature

Author: faern

src/libstd/sys_common/parking_lot/condvar.rs

@@ -7,7 +7,6 @@
 
 use sys_common::parking_lot_core::{
     self,
-    deadlock,
     ParkResult,
     RequeueOp,
     UnparkResult,
@@ -306,9 +305,7 @@ impl Condvar {
             }
 
             // ... and re-lock it once we are done sleeping
-            if result == ParkResult::Unparked(TOKEN_HANDOFF) {
-                deadlock::acquire_resource(mutex as *const _ as usize);
-            } else {
+            if result != ParkResult::Unparked(TOKEN_HANDOFF) {
                 mutex.lock();
             }
 

src/libstd/sys_common/parking_lot/raw_mutex.rs

@@ -9,7 +9,6 @@ use sync::atomic::{Ordering, AtomicU8, ATOMIC_U8_INIT};
 use time::Instant;
 use super::super::parking_lot_core::{
     self,
-    deadlock,
     ParkResult,
     SpinWait,
     UnparkResult,
@@ -49,7 +48,6 @@ impl RawMutex {
         {
             self.lock_slow(None);
         }
-        unsafe { deadlock::acquire_resource(self as *const _ as usize) };
     }
 
     /// Attempts to acquire this mutex without blocking.
@@ -67,7 +65,6 @@ impl RawMutex {
                 Ordering::Relaxed,
             ) {
                 Ok(_) => {
-                    unsafe { deadlock::acquire_resource(self as *const _ as usize) };
                     return true;
                 }
                 Err(x) => state = x,
@@ -78,7 +75,6 @@ impl RawMutex {
     /// Unlocks this mutex.
     #[inline]
     pub fn unlock(&self) {
-        unsafe { deadlock::release_resource(self as *const _ as usize) };
         if self
             .state
             .compare_exchange_weak(LOCKED_BIT, 0, Ordering::Release, Ordering::Relaxed)

src/libstd/sys_common/parking_lot/raw_rwlock.rs

@@ -8,7 +8,6 @@
 use super::elision::{have_elision, AtomicElisionExt};
 use super::super::parking_lot_core::{
     self,
-    deadlock,
     FilterOp,
     ParkResult,
     ParkToken,
@@ -59,7 +58,6 @@ impl RawRwLock {
             let result = self.lock_exclusive_slow(None);
             debug_assert!(result);
         }
-        unsafe { deadlock::acquire_resource(self as *const _ as usize) };
     }
 
     /// Attempts to acquire an exclusive lock without blocking.
@@ -70,7 +68,6 @@ impl RawRwLock {
             .compare_exchange(0, EXCLUSIVE_GUARD, Ordering::Acquire, Ordering::Relaxed)
             .is_ok()
         {
-            unsafe { deadlock::acquire_resource(self as *const _ as usize) };
             true
         } else {
             false
@@ -80,7 +77,6 @@ impl RawRwLock {
     /// Releases an exclusive lock.
     #[inline]
     pub fn unlock_exclusive(&self) {
-        unsafe { deadlock::release_resource(self as *const _ as usize) };
         if self
             .state
             .compare_exchange_weak(EXCLUSIVE_GUARD, 0, Ordering::Release, Ordering::Relaxed)
@@ -98,7 +94,6 @@ impl RawRwLock {
             let result = self.lock_shared_slow(false, None);
             debug_assert!(result);
         }
-        unsafe { deadlock::acquire_resource(self as *const _ as usize) };
     }
 
     /// Attempts to acquire a shared lock without blocking.
@@ -109,16 +104,12 @@ impl RawRwLock {
         } else {
             self.try_lock_shared_slow(false)
         };
-        if result {
-            unsafe { deadlock::acquire_resource(self as *const _ as usize) };
-        }
         result
     }
 
     /// Releases a shared lock.
     #[inline]
     pub fn unlock_shared(&self) {
-        unsafe { deadlock::release_resource(self as *const _ as usize) };
         let state = self.state.load(Ordering::Relaxed);
         if state & PARKED_BIT == 0
             || (state & UPGRADING_BIT == 0 && state & GUARD_COUNT_MASK != SHARED_GUARD)

src/libstd/sys_common/parking_lot_core/mod.rs

@@ -43,7 +43,6 @@ mod spinwait;
 mod util;
 mod word_lock;
 
-pub use self::parking_lot::deadlock;
 pub use self::parking_lot::{park, unpark_filter, unpark_one, unpark_requeue};
 pub use self::parking_lot::{FilterOp, ParkResult, ParkToken, RequeueOp, UnparkResult, UnparkToken};
 pub use self::parking_lot::{DEFAULT_PARK_TOKEN, DEFAULT_UNPARK_TOKEN};

src/libstd/sys_common/parking_lot_core/parking_lot.rs

@@ -125,11 +125,6 @@ struct ThreadData {
 
     // Is the thread parked with a timeout?
     parked_with_timeout: Cell<bool>,
-
-    // Extra data for deadlock detection
-    // FIXME: once supported in stable replace with #[cfg...] & remove dummy struct/impl
-    #[allow(dead_code)]
-    deadlock_data: deadlock::DeadlockData,
 }
 
 impl ThreadData {
@@ -148,7 +143,6 @@ impl ThreadData {
             unpark_token: Cell::new(DEFAULT_UNPARK_TOKEN),
             park_token: Cell::new(DEFAULT_PARK_TOKEN),
             parked_with_timeout: Cell::new(false),
-            deadlock_data: deadlock::DeadlockData::new(),
         }
     }
 }
@@ -601,8 +595,6 @@ unsafe fn park_internal(
         Some(timeout) => thread_data.parker.park_until(timeout),
         None => {
             thread_data.parker.park();
-            // call deadlock detection on_unpark hook
-            deadlock::on_unpark(thread_data);
             true
         }
     };
@@ -1020,31 +1012,3 @@ unsafe fn unpark_filter_internal(
 
     result
 }
-
-/// Just not supported when in libstd.
-pub mod deadlock {
-    pub(super) struct DeadlockData {}
-
-    impl DeadlockData {
-        pub(super) fn new() -> Self {
-            DeadlockData {}
-        }
-    }
-
-    /// Acquire a resource identified by key in the deadlock detector
-    /// Noop if deadlock_detection feature isn't enabled.
-    /// Note: Call after the resource is acquired
-    #[inline]
-    pub unsafe fn acquire_resource(_key: usize) {}
-
-    /// Release a resource identified by key in the deadlock detector.
-    /// Noop if deadlock_detection feature isn't enabled.
-    /// Note: Call before the resource is released
-    /// # Panics
-    /// Panics if the resource was already released or wasn't acquired in this thread.
-    #[inline]
-    pub unsafe fn release_resource(_key: usize) {}
-
-    #[inline]
-    pub(super) unsafe fn on_unpark(_td: &super::ThreadData) {}
-}