Merge rayon-rs#1025

1025: Stop deriving traits on JobRef r=cuviper a=cuviper

I don't see any difference in benchmarks from this, and only a slight reduction in code size. If nothing else I think it's more principled that `JobRef` should not implement `Copy` in particular. `Registry::inject` taking a slice of jobs was an over-abstraction that we never used.

Co-authored-by: Josh Stone <cuviper@gmail.com>

Author: bors[bot]

rayon-core/src/job.rs

@@ -30,7 +30,6 @@ pub(super) trait Job {
 /// Internally, we store the job's data in a `*const ()` pointer.  The
 /// true type is something like `*const StackJob<...>`, but we hide
 /// it. We also carry the "execute fn" from the `Job` trait.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub(super) struct JobRef {
     pointer: *const (),
     execute_fn: unsafe fn(*const ()),
@@ -74,6 +73,17 @@ where
     result: UnsafeCell<JobResult<R>>,
 }
 
+impl<L, F, R> PartialEq<JobRef> for StackJob<L, F, R>
+where
+    L: Latch + Sync,
+    F: FnOnce(bool) -> R + Send,
+    R: Send,
+{
+    fn eq(&self, job: &JobRef) -> bool {
+        job.pointer == <*const Self>::cast(self) && job.execute_fn == Self::execute
+    }
+}
+
 impl<L, F, R> StackJob<L, F, R>
 where
     L: Latch + Sync,

rayon-core/src/join/mod.rs

@@ -134,8 +134,7 @@ where
         // done here so that the stack frame can keep it all live
         // long enough.
         let job_b = StackJob::new(call_b(oper_b), SpinLatch::new(worker_thread));
-        let job_b_ref = job_b.as_job_ref();
-        worker_thread.push(job_b_ref);
+        worker_thread.push(job_b.as_job_ref());
 
         // Execute task a; hopefully b gets stolen in the meantime.
         let status_a = unwind::halt_unwinding(call_a(oper_a, injected));
@@ -151,7 +150,7 @@ where
         // those off to get to it.
         while !job_b.latch.probe() {
             if let Some(job) = worker_thread.take_local_job() {
-                if job == job_b_ref {
+                if job_b == job {
                     // Found it! Let's run it.
                     //
                     // Note that this could panic, but it's ok if we unwind here.

rayon-core/src/registry.rs

@@ -416,18 +416,16 @@ impl Registry {
             if !worker_thread.is_null() && (*worker_thread).registry().id() == self.id() {
                 (*worker_thread).push(job_ref);
             } else {
-                self.inject(&[job_ref]);
+                self.inject(job_ref);
             }
         }
     }
 
     /// Push a job into the "external jobs" queue; it will be taken by
     /// whatever worker has nothing to do. Use this if you know that
     /// you are not on a worker of this registry.
-    pub(super) fn inject(&self, injected_jobs: &[JobRef]) {
-        self.log(|| JobsInjected {
-            count: injected_jobs.len(),
-        });
+    pub(super) fn inject(&self, injected_job: JobRef) {
+        self.log(|| JobsInjected { count: 1 });
 
         // It should not be possible for `state.terminate` to be true
         // here. It is only set to true when the user creates (and
@@ -442,12 +440,8 @@ impl Registry {
 
         let queue_was_empty = self.injected_jobs.is_empty();
 
-        for &job_ref in injected_jobs {
-            self.injected_jobs.push(job_ref);
-        }
-
-        self.sleep
-            .new_injected_jobs(usize::MAX, injected_jobs.len() as u32, queue_was_empty);
+        self.injected_jobs.push(injected_job);
+        self.sleep.new_injected_jobs(usize::MAX, 1, queue_was_empty);
     }
 
     fn has_injected_job(&self) -> bool {
@@ -547,7 +541,7 @@ impl Registry {
                 },
                 LatchRef::new(l),
             );
-            self.inject(&[job.as_job_ref()]);
+            self.inject(job.as_job_ref());
             job.latch.wait_and_reset(); // Make sure we can use the same latch again next time.
 
             // flush accumulated logs as we exit the thread
@@ -575,7 +569,7 @@ impl Registry {
             },
             latch,
         );
-        self.inject(&[job.as_job_ref()]);
+        self.inject(job.as_job_ref());
         current_thread.wait_until(&job.latch);
         job.into_result()
     }

rayon-core/src/scope/mod.rs

@@ -615,7 +615,7 @@ impl<'scope> ScopeFifo<'scope> {
                 // SAFETY: this job will execute before the scope ends.
                 unsafe { worker.push(fifo.push(job_ref)) };
             }
-            None => self.base.registry.inject(&[job_ref]),
+            None => self.base.registry.inject(job_ref),
         }
     }
 

rayon-core/src/spawn/mod.rs

@@ -154,7 +154,7 @@ where
     // in a locally-FIFO order.  Otherwise, just use the pool's global injector.
     match registry.current_thread() {
         Some(worker) => worker.push_fifo(job_ref),
-        None => registry.inject(&[job_ref]),
+        None => registry.inject(job_ref),
     }
     mem::forget(abort_guard);
 }