Implement our own PRNG for rayon-core

Our need for randomness is very simple, just to spread the work-stealing
somewhat equally across all possible victims.  Rather than worrying
about compatibility and updates to the `rand` crate, we now implement a
simple `xorshift*` generator for this.  We keep `rand` only as a dev-
dependency for testing purposes.

Author: cuviper

.travis.yml

@@ -15,12 +15,6 @@ matrix:
     - rust: 1.13.0
       os: linux
       #if: everything!
-      before_script:
-        # rand 0.4.2 requires rust 1.15, and rand-0.3.22 requires rand-0.4  :/
-        # manually lowering the dependency in rayon-core:
-        - sed -i -e 's/^rand = .*$/rand = "=0.3.20"/' rayon-core/Cargo.toml
-        - cargo generate-lockfile
-        - git checkout rayon-core/Cargo.toml
 
     - rust: stable
       os: linux

Cargo.toml

@@ -27,7 +27,7 @@ default-features = false
 [dev-dependencies]
 docopt = "0.8"
 lazy_static = "1"
-rand = ">= 0.3, < 0.5"
+rand = "0.4"
 serde = "1"
 serde_derive = "1"
 

rayon-core/Cargo.toml

@@ -14,7 +14,6 @@ keywords = ["parallel", "thread", "concurrency", "join", "performance"]
 categories = ["concurrency"]
 
 [dependencies]
-rand = ">= 0.3, < 0.5"
 num_cpus = "1.2"
 libc = "0.2.16"
 lazy_static = "1"
@@ -25,3 +24,4 @@ lazy_static = "1"
 version = "0.2.0"
 
 [dev-dependencies]
+rand = "0.4"

rayon-core/src/lib.rs

@@ -37,6 +37,8 @@ extern crate crossbeam_deque;
 extern crate lazy_static;
 extern crate libc;
 extern crate num_cpus;
+
+#[cfg(test)]
 extern crate rand;
 
 #[macro_use]

rayon-core/src/registry.rs

@@ -7,14 +7,12 @@ use job::Job;
 use internal::task::Task;
 use latch::{LatchProbe, Latch, CountLatch, LockLatch, SpinLatch, TickleLatch};
 use log::Event::*;
-use rand::{self, Rng};
 use sleep::Sleep;
 use std::any::Any;
-use std::cell::{Cell, UnsafeCell};
+use std::cell::Cell;
 use std::sync::{Arc, Mutex, Once, ONCE_INIT};
 use std::thread;
 use std::mem;
-use std::u32;
 use std::usize;
 use unwind;
 use util::leak;
@@ -460,7 +458,7 @@ pub struct WorkerThread {
     breadth_first: bool,
 
     /// A weak random number generator.
-    rng: UnsafeCell<rand::XorShiftRng>,
+    rng: XorShift64Star,
 
     registry: Arc<Registry>,
 }
@@ -602,17 +600,8 @@ impl WorkerThread {
         if num_threads <= 1 {
             return None;
         }
-        assert!(num_threads < (u32::MAX as usize),
-                "we do not support more than u32::MAX worker threads");
-
-        let start = {
-            // OK to use this UnsafeCell because (a) this data is
-            // confined to current thread, as WorkerThread is not Send
-            // nor Sync and (b) rand crate will not call back into
-            // this method.
-            let rng = &mut *self.rng.get();
-            rng.next_u32() % num_threads as u32
-        } as usize;
+
+        let start = self.rng.next() as usize % num_threads;
         (start .. num_threads)
             .chain(0 .. start)
             .filter(|&i| i != self.index)
@@ -646,7 +635,7 @@ unsafe fn main_loop(worker: Deque<JobRef>,
         worker: worker,
         breadth_first: breadth_first,
         index: index,
-        rng: UnsafeCell::new(rand::weak_rng()),
+        rng: XorShift64Star::new(),
         registry: registry.clone(),
     };
     WorkerThread::set_current(&worker_thread);
@@ -716,3 +705,36 @@ pub fn in_worker<OP, R>(op: OP) -> R
         }
     }
 }
+
+/// [xorshift*] is a fast pseudorandom number generator which will
+/// even tolerate weak seeding, as long as it's not zero.
+///
+/// [xorshift*]: https://en.wikipedia.org/wiki/Xorshift#xorshift*
+struct XorShift64Star {
+    state: Cell<u64>,
+}
+
+impl XorShift64Star {
+    fn new() -> Self {
+        // Any non-zero seed will do -- this uses a stack address, which should be unique since
+        // we're only calling this once from each new thread.  The address is also shift-XORed to
+        // give us some high bits even on 32-bit platforms.
+        let base = 0;
+        let addr = &base as *const _ as u64;
+        let seed = addr ^ (addr << 32);
+
+        XorShift64Star {
+            state: Cell::new(seed),
+        }
+    }
+
+    fn next(&self) -> u64 {
+        let mut x = self.state.get();
+        debug_assert_ne!(x, 0);
+        x ^= x >> 12;
+        x ^= x << 25;
+        x ^= x >> 27;
+        self.state.set(x);
+        x.wrapping_mul(0x2545_f491_4f6c_dd1d)
+    }
+}

rayon-demo/Cargo.toml

@@ -12,7 +12,7 @@ fixedbitset = "0.1.5"
 glium = "0.20"
 lazy_static = "1"
 odds = "0.3"
-rand = ">= 0.3, < 0.5"
+rand = "0.4"
 regex = "0.2"
 serde = "1"
 serde_derive = "1"