Impl LatchProbe and Latch for &L where L: Latch.

Author: ralfbiedert

rayon-core/src/job.rs

@@ -64,24 +64,24 @@ impl JobRef {
 /// executes it need not free any heap data, the cleanup occurs when
 /// the stack frame is later popped.  The function parameter indicates
 /// `true` if the job was stolen -- executed on a different thread.
-pub(super) struct StackJob<'a, L: 'a, F, R>
+pub(super) struct StackJob<L, F, R>
 where
     L: Latch + Sync,
     F: FnOnce(bool) -> R + Send,
     R: Send,
 {
-    pub(super) latch: &'a mut L,
+    pub(super) latch: L,
     func: UnsafeCell<Option<F>>,
     result: UnsafeCell<JobResult<R>>,
 }
 
-impl<'a, L, F, R> StackJob<'a, L, F, R>
+impl<L, F, R> StackJob<L, F, R>
 where
     L: Latch + Sync,
     F: FnOnce(bool) -> R + Send,
     R: Send,
 {
-    pub(super) fn new(func: F, latch: &'a mut L) -> StackJob<'a, L, F, R> {
+    pub(super) fn new(func: F, latch: L) -> StackJob<L, F, R> {
         StackJob {
             latch,
             func: UnsafeCell::new(Some(func)),
@@ -102,7 +102,7 @@ where
     }
 }
 
-impl<'a, L, F, R> Job for StackJob<'a, L, F, R>
+impl<L, F, R> Job for StackJob<L, F, R>
 where
     L: Latch + Sync,
     F: FnOnce(bool) -> R + Send,

rayon-core/src/join/mod.rs

@@ -120,12 +120,12 @@ where
             worker: worker_thread.index()
         });
 
-        let mut latch = SpinLatch::new();
+        let latch = SpinLatch::new();
 
         // 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)), &mut 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);
 

rayon-core/src/latch.rs

@@ -87,7 +87,7 @@ impl LockLatch {
     }
 
     /// Resets this lock latch so it can be reused again.
-    pub(super) fn reset(&mut self) {
+    pub(super) fn reset(&self) {
         *self.m.lock().unwrap() = false;
     }
 
@@ -191,3 +191,15 @@ impl<'a, L: Latch> Latch for TickleLatch<'a, L> {
         self.sleep.tickle(usize::MAX);
     }
 }
+
+impl<'a, L> LatchProbe for &'a L where L: LatchProbe {
+    fn probe(&self) -> bool {
+        unimplemented!()
+    }
+}
+
+impl<'a, L> Latch for &'a L where L: Latch {
+    fn set(&self) {
+        unimplemented!()
+    }
+}

rayon-core/src/registry.rs

@@ -15,7 +15,7 @@ use std::fmt;
 use std::hash::Hasher;
 use std::io;
 use std::mem;
-use std::ops::DerefMut;
+use std::ops::{Deref};
 use std::ptr;
 #[allow(deprecated)]
 use std::sync::atomic::ATOMIC_USIZE_INIT;
@@ -480,7 +480,8 @@ impl Registry {
             }
         }
     }
-
+    
+    
     #[cold]
     unsafe fn in_worker_cold<OP, R>(&self, op: OP) -> R
     where
@@ -490,7 +491,7 @@ impl Registry {
         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 mut latch = l.borrow_mut();
+            let latch = l.borrow();
 
             // This thread isn't a member of *any* thread pool, so just block.
             debug_assert!(WorkerThread::current().is_null());
@@ -500,7 +501,7 @@ impl Registry {
                     assert!(injected && !worker_thread.is_null());
                     op(&*worker_thread, true)
                 },
-                latch.deref_mut(),
+                latch.deref(),
             );
             self.inject(&[job.as_job_ref()]);
             job.latch.wait();
@@ -518,14 +519,14 @@ impl Registry {
         // This thread is a member of a different pool, so let it process
         // other work while waiting for this `op` to complete.
         debug_assert!(current_thread.registry().id() != self.id());
-        let mut latch = TickleLatch::new(SpinLatch::new(), &current_thread.registry().sleep);
+        let latch = TickleLatch::new(SpinLatch::new(), &current_thread.registry().sleep);
         let job = StackJob::new(
             |injected| {
                 let worker_thread = WorkerThread::current();
                 assert!(injected && !worker_thread.is_null());
                 op(&*worker_thread, true)
             },
-            &mut latch,
+            &latch,
         );
         self.inject(&[job.as_job_ref()]);
         current_thread.wait_until(job.latch);