Merge branch 'master' into stable-tests

Forked the octillion test with `Range<u128>` vs. `flat_map` iterators.
The `cfg(nightly)` is no longer needed with stable Rust 1.26, as we only
used `i128` and `impl Trait` that are now stable.

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 hacking the lockfile due to the limitations of cargo#2773
-        - cargo generate-lockfile
-        - sed -i -e 's/"rand 0.[34].[0-9]\+/"rand 0.3.20/' Cargo.lock
-        - sed -i -e '/^name = "rand"/,/^$/s/version = "0.3.[0-9]\+"/version = "0.3.20"/' Cargo.lock
       script: cargo build
 
     - rust: stable

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "rayon"
 # Reminder to update html_rool_url in lib.rs when updating version
-version = "1.0.0"
+version = "1.0.1"
 authors = ["Niko Matsakis <[email protected]>",
            "Josh Stone <[email protected]>"]
 description = "Simple work-stealing parallelism for Rust"
@@ -28,6 +28,6 @@ default-features = false
 [dev-dependencies]
 docopt = "0.8"
 lazy_static = "1"
-rand = ">= 0.3, < 0.5"
+rand = "0.4"
 serde = "1"
 serde_derive = "1"

FAQ.md

@@ -196,7 +196,7 @@ these are preferable to random failures in my experience.
 ## But wait, isn't Rust supposed to free me from this kind of thinking?
 
 You might think that Rust is supposed to mean that you don't have to
-think about atomicity at all. In fact, if you avoid inherent
+think about atomicity at all. In fact, if you avoid interior
 mutability (`Cell` and `RefCell` in a sequential setting, or
 `AtomicUsize`, `RwLock`, `Mutex`, et al. in parallel code), then this
 is true: the type system will basically guarantee that you don't have

RELEASES.md

@@ -1,3 +1,18 @@
+# Release rayon 1.0.1
+
+- Added more documentation for `rayon::iter::split()`.
+- Corrected links and typos in documentation.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @HadrienG2
+- @matthiasbeyer
+- @nikomatsakis
+
+
 # Release rayon 1.0.0 / rayon-core 1.4.0
 
 - `ParallelIterator` added the `update` method which applies a function to

build.rs

@@ -1,16 +1,33 @@
 use std::env;
-use std::process::Command;
-use std::str;
+use std::io::Write;
+use std::process::{Command, Stdio};
 
 fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-env-changed=RUSTC");
-
-    let rustc = env::var_os("RUSTC").unwrap();
-    let version = Command::new(rustc).arg("-V").output().unwrap().stdout;
-    let version = str::from_utf8(&version).unwrap();
-    if version.contains("nightly") || version.contains("dev") {
-        // a few tests want to use nightly features
-        println!("cargo:rustc-cfg=nightly");
+    if probe("fn main() { 0i128; }") {
+        println!("cargo:rustc-cfg=has_i128");
     }
 }
+
+/// Test if a code snippet can be compiled
+fn probe(code: &str) -> bool {
+    let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
+    let out_dir = env::var_os("OUT_DIR").expect("environment variable OUT_DIR");
+
+    let mut child = Command::new(rustc)
+        .arg("--out-dir")
+        .arg(out_dir)
+        .arg("--emit=obj")
+        .arg("-")
+        .stdin(Stdio::piped())
+        .spawn()
+        .expect("rustc probe");
+
+    child
+        .stdin
+        .as_mut()
+        .expect("rustc stdin")
+        .write_all(code.as_bytes())
+        .expect("write rustc stdin");
+
+    child.wait().expect("rustc probe").success()
+}

rayon-core/Cargo.toml

@@ -14,13 +14,17 @@ keywords = ["parallel", "thread", "concurrency", "join", "performance"]
 categories = ["concurrency"]
 
 [dependencies]
-rand = ">= 0.3, < 0.5"
 num_cpus = "1.2"
-crossbeam-deque = "0.2.0"
 libc = "0.2.16"
 lazy_static = "1"
 
+# This is deliberately not the latest version, because we want
+# to support older rustc than crossbeam-deque 0.3+ does.
+[dependencies.crossbeam-deque]
+version = "0.2.0"
+
 [dev-dependencies]
+rand = "0.4"
 
 [[test]]
 name = "stack_overflow_crash"

rayon-core/src/join/mod.rs

@@ -39,7 +39,7 @@ mod test;
 /// sort for real, you should prefer [the `par_sort` method] offered
 /// by Rayon).
 ///
-/// [the `par_sort` method]: ../slice/trait.ParallelSliceMut.html#method.par_sort
+/// [the `par_sort` method]: ../rayon/slice/trait.ParallelSliceMut.html#method.par_sort
 ///
 /// ```rust
 /// # use rayon_core as rayon;

rayon-core/src/lib.rs

@@ -36,6 +36,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,15 @@ 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::collections::hash_map::DefaultHasher;
+use std::hash::Hasher;
 use std::sync::{Arc, Mutex, Once, ONCE_INIT};
+use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 use std::thread;
 use std::mem;
-use std::u32;
 use std::usize;
 use unwind;
 use util::leak;
@@ -460,7 +461,7 @@ pub struct WorkerThread {
     breadth_first: bool,
 
     /// A weak random number generator.
-    rng: UnsafeCell<rand::XorShiftRng>,
+    rng: XorShift64Star,
 
     registry: Arc<Registry>,
 }
@@ -602,17 +603,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_usize(num_threads);
         (start .. num_threads)
             .chain(0 .. start)
             .filter(|&i| i != self.index)
@@ -646,7 +638,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 +708,43 @@ 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 the hash of a global counter.
+        let mut seed = 0;
+        while seed == 0 {
+            let mut hasher = DefaultHasher::new();
+            static COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
+            hasher.write_usize(COUNTER.fetch_add(1, Ordering::Relaxed));
+            seed = hasher.finish();
+        }
+
+        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)
+    }
+
+    /// Return a value from `0..n`.
+    fn next_usize(&self, n: usize) -> usize {
+        (self.next() % n as u64) as usize
+    }
+}

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"