Removed RefCell, refs, moved thread_local, applied cargo fmt.

Author: ralfbiedert

rayon-core/src/join/mod.rs

@@ -125,7 +125,7 @@ where
         // Create virtual wrapper for task b; this all has to be
         // done here so that the stack frame can keep it all live
         // long enough.
-        let job_b = StackJob::new(|migrated| oper_b(FnContext::new(migrated)), &latch);
+        let job_b = StackJob::new(|migrated| oper_b(FnContext::new(migrated)), latch);
         let job_b_ref = job_b.as_job_ref();
         worker_thread.push(job_b_ref);
 
@@ -164,7 +164,7 @@ where
                 log!(LostJob {
                     worker: worker_thread.index()
                 });
-                worker_thread.wait_until(job_b.latch);
+                worker_thread.wait_until(&job_b.latch);
                 debug_assert!(job_b.latch.probe());
                 break;
             }

rayon-core/src/latch.rs

@@ -86,9 +86,13 @@ impl LockLatch {
         }
     }
 
-    /// Resets this lock latch so it can be reused again.
-    pub(super) fn reset(&self) {
-        *self.m.lock().unwrap() = false;
+    /// Block until latch is set, then resets this lock latch so it can be reused again.
+    pub(super) fn wait_and_reset(&self) {
+        let mut guard = self.m.lock().unwrap();
+        while !*guard {
+            guard = self.v.wait(guard).unwrap();
+        }
+        *guard = false;
     }
 
     /// Block until latch is set.
@@ -192,13 +196,19 @@ impl<'a, L: Latch> Latch for TickleLatch<'a, L> {
     }
 }
 
-impl<'a, L> LatchProbe for &'a L where L: LatchProbe {
+impl<'a, L> LatchProbe for &'a L
+where
+    L: LatchProbe,
+{
     fn probe(&self) -> bool {
         L::probe(self)
     }
 }
 
-impl<'a, L> Latch for &'a L where L: Latch {
+impl<'a, L> Latch for &'a L
+where
+    L: Latch,
+{
     fn set(&self) {
         L::set(self);
     }

rayon-core/src/registry.rs

@@ -9,13 +9,12 @@ use latch::{CountLatch, Latch, LatchProbe, LockLatch, SpinLatch, TickleLatch};
 use log::Event::*;
 use sleep::Sleep;
 use std::any::Any;
-use std::cell::{Cell, RefCell};
+use std::cell::Cell;
 use std::collections::hash_map::DefaultHasher;
 use std::fmt;
 use std::hash::Hasher;
 use std::io;
 use std::mem;
-use std::ops::{Deref};
 use std::ptr;
 #[allow(deprecated)]
 use std::sync::atomic::ATOMIC_USIZE_INIT;
@@ -480,19 +479,16 @@ impl Registry {
             }
         }
     }
-    
-    
+
     #[cold]
     unsafe fn in_worker_cold<OP, R>(&self, op: OP) -> R
     where
         OP: FnOnce(&WorkerThread, bool) -> R + Send,
         R: Send,
     {
-        LOCK_LATCH.with(|l| {
-            // This should not panic since the latch is thread local and we are in the `cold` path.
-            // If `op` were to call another `ThreadPool::install` it would not end up here.
-            let latch = l.borrow();
+        thread_local!(static LOCK_LATCH: LockLatch = LockLatch::new());
 
+        LOCK_LATCH.with(|l| {
             // This thread isn't a member of *any* thread pool, so just block.
             debug_assert!(WorkerThread::current().is_null());
             let job = StackJob::new(
@@ -501,11 +497,10 @@ impl Registry {
                     assert!(injected && !worker_thread.is_null());
                     op(&*worker_thread, true)
                 },
-                latch.deref(),
+                l,
             );
             self.inject(&[job.as_job_ref()]);
-            job.latch.wait();
-            job.latch.reset(); // Makes sure we can use the same latch again next time.
+            job.latch.wait_and_reset(); // Make sure we can use the same latch again next time.
             job.into_result()
         })
     }
@@ -620,8 +615,6 @@ pub(super) struct WorkerThread {
 // for a RefCell<T> etc.
 thread_local! {
     static WORKER_THREAD_STATE: Cell<*const WorkerThread> = Cell::new(ptr::null());
-
-    static LOCK_LATCH: RefCell<LockLatch> = RefCell::new(LockLatch::new());
 }
 
 impl Drop for WorkerThread {