Merge #24

24: Merge upstream changes, and some local cleanups r=cuviper a=cuviper



Co-authored-by: Ralf Jung <[email protected]>
Co-authored-by: Alexis Beingessner <[email protected]>
Co-authored-by: Guillaume Gomez <[email protected]>
Co-authored-by: Jonathan Behrens <[email protected]>
Co-authored-by: Val <[email protected]>
Co-authored-by: bors <[email protected]>
Co-authored-by: teresy <[email protected]>
Co-authored-by: kennytm <[email protected]>
Co-authored-by: Josh Stone <[email protected]>

Author: 10 people

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 authors = ["Josh Stone <[email protected]>"]
 name = "rayon-hash"
-version = "0.4.0"
+version = "0.4.1"
 repository = "https://github.com/rayon-rs/rayon-hash"
 documentation = "https://docs.rs/rayon-hash/"
 keywords = ["parallel", "iterator", "hash", "map", "set"]
@@ -14,4 +14,5 @@ readme = "README.md"
 rayon = "1.0"
 
 [dev-dependencies]
-rand = "0.5"
+rand = "0.6"
+rand_xorshift = "0.1"

README.md

@@ -13,10 +13,10 @@ split into parallel jobs.  With the custom types in `rayon-hash`, we can
 instead read the raw hash table directly, for much better performance.
 
 ```text
-test rayon_set_sum_parallel ... bench:   1,077,602 ns/iter (+/- 50,610)
-test rayon_set_sum_serial   ... bench:   6,363,125 ns/iter (+/- 101,513)
-test std_set_sum_parallel   ... bench:   8,519,683 ns/iter (+/- 219,785)
-test std_set_sum_serial     ... bench:   6,295,263 ns/iter (+/- 98,600)
+test rayon_set_sum_parallel ... bench:   1,035,111 ns/iter (+/- 57,327)
+test rayon_set_sum_serial   ... bench:   7,500,179 ns/iter (+/- 96,918)
+test std_set_sum_parallel   ... bench:   6,799,231 ns/iter (+/- 94,154)
+test std_set_sum_serial     ... bench:   7,634,174 ns/iter (+/- 84,806)
 ```
 
 This crate currently requires `rustc 1.28.0` or greater.
@@ -45,7 +45,7 @@ RUSTFLAGS='--cfg rayon_hash_unstable' cargo build
 Note that this must not only be done for your crate, but for any crate that
 depends on your crate.  This infectious nature is intentional, as it serves as
 a reminder that you are outside of the normal semver guarantees.  These
-features also require a nightly Rust compiler.
+features may also require a nightly Rust compiler.
 
 When such features are stabilized in the standard library, we will remove the
 `rayon_hash_unstable` guard here too.

benches/set_sum.rs

@@ -1,23 +1,27 @@
 #![feature(test)]
 
-extern crate test;
 extern crate rand;
+extern crate rand_xorshift;
 extern crate rayon;
 extern crate rayon_hash;
+extern crate test;
 
-use rand::{Rng, SeedableRng, XorShiftRng};
 use rand::distributions::Standard;
-use std::collections::HashSet as StdHashSet;
+use rand::{Rng, SeedableRng};
+use rand_xorshift::XorShiftRng;
+use rayon::prelude::*;
 use rayon_hash::HashSet as RayonHashSet;
+use std::collections::HashSet as StdHashSet;
 use std::iter::FromIterator;
-use rayon::prelude::*;
 use test::Bencher;
 
-
 fn default_set<C: FromIterator<u32>>(n: usize) -> C {
     let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
     (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
-    XorShiftRng::from_seed(seed).sample_iter(&Standard).take(n).collect()
+    XorShiftRng::from_seed(seed)
+        .sample_iter(&Standard)
+        .take(n)
+        .collect()
 }
 
 macro_rules! bench_set_sum {
@@ -32,7 +36,7 @@ macro_rules! bench_set_sum {
                 assert_eq!(s, sum);
             })
         }
-    }
+    };
 }
 
 bench_set_sum!{std_set_sum_serial, StdHashSet<_>, iter}

src/alloc.rs

@@ -37,6 +37,7 @@ fn layout_err() -> LayoutErr {
 /// use specific allocators with looser requirements.)
 // #[stable(feature = "alloc_layout", since = "1.28.0")]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+// #[lang = "alloc_layout"]
 pub(crate) struct Layout {
     inner: alloc::Layout,
 }
@@ -46,6 +47,8 @@ impl Layout {
     /// or returns `LayoutErr` if either of the following conditions
     /// are not met:
     ///
+    /// * `align` must not be zero,
+    ///
     /// * `align` must be a power of two,
     ///
     /// * `size`, when rounded up to the nearest multiple of `align`,
@@ -102,7 +105,7 @@ impl Layout {
     /// to be less than or equal to the alignment of the starting
     /// address for the whole allocated block of memory. One way to
     /// satisfy this constraint is to ensure `align <= self.align()`.
-    // #[unstable(feature = "allocator_api", issue = "32838")]
+    // #[unstable(feature = "alloc_layout_extra", issue = "55724")]
     #[inline]
     pub(crate) fn padding_needed_for(&self, align: usize) -> usize {
         let len = self.size();
@@ -128,7 +131,7 @@ impl Layout {
 
         let len_rounded_up = len.wrapping_add(align).wrapping_sub(1)
             & !align.wrapping_sub(1);
-        return len_rounded_up.wrapping_sub(len);
+        len_rounded_up.wrapping_sub(len)
     }
 
     /// Creates a layout describing the record for `n` instances of
@@ -139,7 +142,7 @@ impl Layout {
     /// of each element in the array.
     ///
     /// On arithmetic overflow, returns `LayoutErr`.
-    // #[unstable(feature = "allocator_api", issue = "32838")]
+    // #[unstable(feature = "alloc_layout_extra", issue = "55724")]
     #[inline]
     pub(crate) fn repeat(&self, n: usize) -> Result<(Self, usize), LayoutErr> {
         let padded_size = self.size().checked_add(self.padding_needed_for(self.align()))
@@ -159,13 +162,16 @@ impl Layout {
     /// will be properly aligned. Note that the result layout will
     /// satisfy the alignment properties of both `self` and `next`.
     ///
+    /// The resulting layout will be the same as that of a C struct containing
+    /// two fields with the layouts of `self` and `next`, in that order.
+    ///
     /// Returns `Some((k, offset))`, where `k` is layout of the concatenated
     /// record and `offset` is the relative location, in bytes, of the
     /// start of the `next` embedded within the concatenated record
     /// (assuming that the record itself starts at offset 0).
     ///
     /// On arithmetic overflow, returns `LayoutErr`.
-    // #[unstable(feature = "allocator_api", issue = "32838")]
+    // #[unstable(feature = "alloc_layout_extra", issue = "55724")]
     #[inline]
     pub(crate) fn extend(&self, next: Self) -> Result<(Self, usize), LayoutErr> {
         let new_align = cmp::max(self.align(), next.align());
@@ -183,7 +189,7 @@ impl Layout {
     /// Creates a layout describing the record for a `[T; n]`.
     ///
     /// On arithmetic overflow, returns `LayoutErr`.
-    // #[unstable(feature = "allocator_api", issue = "32838")]
+    // #[unstable(feature = "alloc_layout_extra", issue = "55724")]
     #[inline]
     pub(crate) fn array<T>(n: usize) -> Result<Self, LayoutErr> {
         Layout::new::<T>()
@@ -210,7 +216,6 @@ impl From<Layout> for alloc::Layout {
 }
 
 /// Augments `AllocErr` with a CapacityOverflow variant.
-// FIXME: should this be in libcore or liballoc?
 #[derive(Clone, PartialEq, Eq, Debug)]
 // #[unstable(feature = "try_reserve", reason = "new API", issue="48043")]
 pub enum CollectionAllocErr {

src/par/map.rs

@@ -1,15 +1,13 @@
 /// Rayon extensions to `HashMap`
-
-use rayon::iter::{ParallelIterator, IntoParallelIterator, FromParallelIterator, ParallelExtend};
-use std::hash::{Hash, BuildHasher};
+use rayon::iter::{FromParallelIterator, IntoParallelIterator, ParallelExtend, ParallelIterator};
+use std::hash::{BuildHasher, Hash};
 
 use super::table;
 use HashMap;
 
 pub use self::table::{ParIntoIter, ParIter, ParIterMut};
 pub use self::table::{ParKeys, ParValues, ParValuesMut};
 
-
 impl<K: Sync, V, S> HashMap<K, V, S> {
     pub fn par_keys(&self) -> ParKeys<K, V> {
         self.table.par_keys()
@@ -29,17 +27,18 @@ impl<K, V: Send, S> HashMap<K, V, S> {
 }
 
 impl<K, V, S> HashMap<K, V, S>
-    where K: Eq + Hash + Sync,
-          V: PartialEq + Sync,
-          S: BuildHasher + Sync
+where
+    K: Eq + Hash + Sync,
+    V: PartialEq + Sync,
+    S: BuildHasher + Sync,
 {
     pub fn par_eq(&self, other: &Self) -> bool {
-        self.len() == other.len() &&
-        self.into_par_iter().all(|(key, value)| other.get(key).map_or(false, |v| *value == *v))
+        self.len() == other.len() && self
+            .into_par_iter()
+            .all(|(key, value)| other.get(key).map_or(false, |v| *value == *v))
     }
 }
 
-
 impl<K: Send, V: Send, S> IntoParallelIterator for HashMap<K, V, S> {
     type Item = (K, V);
     type Iter = ParIntoIter<K, V>;
@@ -67,58 +66,63 @@ impl<'a, K: Sync, V: Send, S> IntoParallelIterator for &'a mut HashMap<K, V, S>
     }
 }
 
-
 /// Collect (key, value) pairs from a parallel iterator into a
 /// hashmap. If multiple pairs correspond to the same key, then the
 /// ones produced earlier in the parallel iterator will be
 /// overwritten, just as with a sequential iterator.
 impl<K, V, S> FromParallelIterator<(K, V)> for HashMap<K, V, S>
-    where K: Eq + Hash + Send,
-          V: Send,
-          S: BuildHasher + Default + Send
+where
+    K: Eq + Hash + Send,
+    V: Send,
+    S: BuildHasher + Default + Send,
 {
     fn from_par_iter<P>(par_iter: P) -> Self
-        where P: IntoParallelIterator<Item = (K, V)>
+    where
+        P: IntoParallelIterator<Item = (K, V)>,
     {
         let mut map = HashMap::default();
         map.par_extend(par_iter);
         map
     }
 }
 
-
 /// Extend a hash map with items from a parallel iterator.
 impl<K, V, S> ParallelExtend<(K, V)> for HashMap<K, V, S>
-    where K: Eq + Hash + Send,
-          V: Send,
-          S: BuildHasher + Send
+where
+    K: Eq + Hash + Send,
+    V: Send,
+    S: BuildHasher + Send,
 {
     fn par_extend<I>(&mut self, par_iter: I)
-        where I: IntoParallelIterator<Item = (K, V)>
+    where
+        I: IntoParallelIterator<Item = (K, V)>,
     {
         extend(self, par_iter);
     }
 }
 
 /// Extend a hash map with copied items from a parallel iterator.
 impl<'a, K, V, S> ParallelExtend<(&'a K, &'a V)> for HashMap<K, V, S>
-    where K: Copy + Eq + Hash + Send + Sync,
-          V: Copy + Send + Sync,
-          S: BuildHasher + Send
+where
+    K: Copy + Eq + Hash + Send + Sync,
+    V: Copy + Send + Sync,
+    S: BuildHasher + Send,
 {
     fn par_extend<I>(&mut self, par_iter: I)
-        where I: IntoParallelIterator<Item = (&'a K, &'a V)>
+    where
+        I: IntoParallelIterator<Item = (&'a K, &'a V)>,
     {
         extend(self, par_iter);
     }
 }
 
 // This is equal to the normal `HashMap` -- no custom advantage.
 fn extend<K, V, S, I>(map: &mut HashMap<K, V, S>, par_iter: I)
-    where K: Eq + Hash,
-          S: BuildHasher,
-          I: IntoParallelIterator,
-          HashMap<K, V, S>: Extend<I::Item>
+where
+    K: Eq + Hash,
+    S: BuildHasher,
+    I: IntoParallelIterator,
+    HashMap<K, V, S>: Extend<I::Item>,
 {
     let (list, len) = super::collect(par_iter);
 
@@ -133,13 +137,12 @@ fn extend<K, V, S, I>(map: &mut HashMap<K, V, S>, par_iter: I)
     }
 }
 
-
 #[cfg(test)]
 mod test_par_map {
     use super::HashMap;
-    use std::sync::atomic::{AtomicUsize, Ordering};
-    use std::hash::{Hash, Hasher};
     use rayon::prelude::*;
+    use std::hash::{Hash, Hasher};
+    use std::sync::atomic::{AtomicUsize, Ordering};
 
     struct Dropable<'a> {
         k: usize,
@@ -150,7 +153,10 @@ mod test_par_map {
         fn new(k: usize, counter: &AtomicUsize) -> Dropable {
             counter.fetch_add(1, Ordering::Relaxed);
 
-            Dropable { k: k, counter: counter }
+            Dropable {
+                k: k,
+                counter: counter,
+            }
         }
     }
 
@@ -168,7 +174,8 @@ mod test_par_map {
 
     impl<'a> Hash for Dropable<'a> {
         fn hash<H>(&self, state: &mut H)
-            where H: Hasher
+        where
+            H: Hasher,
         {
             self.k.hash(state)
         }
@@ -213,7 +220,8 @@ mod test_par_map {
             assert_eq!(value.load(Ordering::Relaxed), 100);
 
             // retain only half
-            let _v: Vec<_> = hm.into_par_iter()
+            let _v: Vec<_> = hm
+                .into_par_iter()
                 .filter(|&(ref key, _)| key.k < 50)
                 .collect();
 
@@ -243,7 +251,7 @@ mod test_par_map {
     fn test_iterate() {
         let mut m = HashMap::with_capacity(4);
         for i in 0..32 {
-            assert!(m.insert(i, i*2).is_none());
+            assert!(m.insert(i, i * 2).is_none());
         }
         assert_eq!(m.len(), 32);
 
@@ -282,9 +290,7 @@ mod test_par_map {
     fn test_values_mut() {
         let vec = vec![(1, 1), (2, 2), (3, 3)];
         let mut map: HashMap<_, _> = vec.into_par_iter().collect();
-        map.par_values_mut().for_each(|value| {
-            *value = (*value) * 2
-        });
+        map.par_values_mut().for_each(|value| *value = (*value) * 2);
         let values: Vec<_> = map.par_values().cloned().collect();
         assert_eq!(values.len(), 3);
         assert!(values.contains(&2));

src/par/mod.rs

@@ -7,17 +7,16 @@ mod table;
 
 /// Helper for collecting parallel iterators to an intermediary
 fn collect<I: IntoParallelIterator>(iter: I) -> (LinkedList<Vec<I::Item>>, usize) {
-    let list = iter.into_par_iter()
+    let list = iter
+        .into_par_iter()
         .fold(Vec::new, |mut vec, elem| {
             vec.push(elem);
             vec
-        })
-        .map(|vec| {
+        }).map(|vec| {
             let mut list = LinkedList::new();
             list.push_back(vec);
             list
-        })
-        .reduce(LinkedList::new, |mut list1, mut list2| {
+        }).reduce(LinkedList::new, |mut list1, mut list2| {
             list1.append(&mut list2);
             list1
         });