Added new versions of choose and choose_stable

benches/seq.rs

@@ -13,9 +13,9 @@ extern crate test;
 
 use test::Bencher;
 
+use core::mem::size_of;
 use rand::prelude::*;
 use rand::seq::*;
-use core::mem::size_of;
 
 // We force use of 32-bit RNG since seq code is optimised for use with 32-bit
 // generators on all platforms.
@@ -74,76 +74,6 @@ seq_slice_choose_multiple!(seq_slice_choose_multiple_950_of_1000, 950, 1000);
 seq_slice_choose_multiple!(seq_slice_choose_multiple_10_of_100, 10, 100);
 seq_slice_choose_multiple!(seq_slice_choose_multiple_90_of_100, 90, 100);
 
-#[bench]
-fn seq_iter_choose_from_1000(b: &mut Bencher) {
-    let mut rng = SmallRng::from_rng(thread_rng()).unwrap();
-    let x: &mut [usize] = &mut [1; 1000];
-    for (i, r) in x.iter_mut().enumerate() {
-        *r = i;
-    }
-    b.iter(|| {
-        let mut s = 0;
-        for _ in 0..RAND_BENCH_N {
-            s += x.iter().choose(&mut rng).unwrap();
-        }
-        s
-    });
-    b.bytes = size_of::<usize>() as u64 * crate::RAND_BENCH_N;
-}
-
-#[derive(Clone)]
-struct UnhintedIterator<I: Iterator + Clone> {
-    iter: I,
-}
-impl<I: Iterator + Clone> Iterator for UnhintedIterator<I> {
-    type Item = I::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
-    }
-}
-
-#[derive(Clone)]
-struct WindowHintedIterator<I: ExactSizeIterator + Iterator + Clone> {
-    iter: I,
-    window_size: usize,
-}
-impl<I: ExactSizeIterator + Iterator + Clone> Iterator for WindowHintedIterator<I> {
-    type Item = I::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (core::cmp::min(self.iter.len(), self.window_size), None)
-    }
-}
-
-#[bench]
-fn seq_iter_unhinted_choose_from_1000(b: &mut Bencher) {
-    let mut rng = SmallRng::from_rng(thread_rng()).unwrap();
-    let x: &[usize] = &[1; 1000];
-    b.iter(|| {
-        UnhintedIterator { iter: x.iter() }
-            .choose(&mut rng)
-            .unwrap()
-    })
-}
-
-#[bench]
-fn seq_iter_window_hinted_choose_from_1000(b: &mut Bencher) {
-    let mut rng = SmallRng::from_rng(thread_rng()).unwrap();
-    let x: &[usize] = &[1; 1000];
-    b.iter(|| {
-        WindowHintedIterator {
-            iter: x.iter(),
-            window_size: 7,
-        }
-        .choose(&mut rng)
-    })
-}
-
 #[bench]
 fn seq_iter_choose_multiple_10_of_100(b: &mut Bencher) {
     let mut rng = SmallRng::from_rng(thread_rng()).unwrap();

benches/seq_choose.rs

@@ -0,0 +1,163 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(test)]
+#![allow(non_snake_case)]
+#![feature(custom_inner_attributes)]
+// Rustfmt splits macro invocations to shorten lines; in this case longer-lines are more readable
+#![rustfmt::skip]
+
+extern crate test;
+
+use test::Bencher;
+use rand::prelude::*;
+
+// We force use of 32-bit RNG since seq code is optimised for use with 32-bit
+// generators on all platforms.
+use rand_chacha::ChaCha20Rng as CryptoRng;
+use rand_pcg::Pcg32 as SmallRng;
+
+const RAND_BENCH_N: u64 = 1000;
+
+#[derive(Clone)]
+struct UnhintedIterator<I: Iterator + Clone> {
+    iter: I, }
+impl<I: Iterator + Clone> Iterator for UnhintedIterator<I> {
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+}
+
+#[derive(Clone)]
+struct WindowHintedIterator<I: ExactSizeIterator + Iterator + Clone> {
+    iter: I, window_size: usize, }
+impl<I: ExactSizeIterator + Iterator + Clone> Iterator for WindowHintedIterator<I> {
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (core::cmp::min(self.iter.len(), self.window_size), None)
+    }
+}
+
+macro_rules! bench_seq_iter_size_hinted {
+    ($name:ident, $rng:ident, $fn:ident, $length:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let mut rng = $rng::from_rng(thread_rng()).unwrap();
+            let x: &mut [usize] = &mut [1; $length];
+            for (i, r) in x.iter_mut().enumerate() {
+                *r = i;
+            }
+            b.iter(|| {
+                let mut s = 0;
+                for _ in 0..RAND_BENCH_N {
+                    s += x.iter().$fn(&mut rng).unwrap();
+                }
+                s
+            });
+        }
+    };
+}
+
+macro_rules! bench_seq_iter_unhinted {
+    ($name:ident,$rng:ident, $fn:ident, $length:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let mut rng = $rng::from_rng(thread_rng()).unwrap();
+            let x: &[usize] = &[1; $length];
+            b.iter(|| UnhintedIterator { iter: x.iter() }.$fn(&mut rng).unwrap())
+        }
+    };
+}
+
+macro_rules! bench_seq_iter_window_hinted {
+    ($name:ident,$rng:ident, $fn:ident, $length:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let mut rng = $rng::from_rng(thread_rng()).unwrap();
+            let x: &[usize] = &[1; $length];
+            b.iter(|| {
+                WindowHintedIterator {
+                    iter: x.iter(), window_size: 7, }
+                .$fn(&mut rng)
+                .unwrap()
+            })
+        }
+    };
+}
+
+//Size Hinted
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_10000_cryptoRng, CryptoRng, choose, 10000);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_10000_smallRng, SmallRng, choose, 10000);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_1000_cryptoRng, CryptoRng, choose, 1000);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_1000_smallRng, SmallRng, choose, 1000);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_100_cryptoRng, CryptoRng, choose, 100);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_100_smallRng, SmallRng, choose, 100);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_10_smallRng, SmallRng, choose, 10);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_10_cryptoRng, CryptoRng, choose, 10);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_3_smallRng, SmallRng, choose, 3);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_3_cryptoRng, CryptoRng, choose, 3);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_2_smallRng, SmallRng, choose, 2);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_2_cryptoRng, CryptoRng, choose, 2);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_1_smallRng, SmallRng, choose, 1);
+bench_seq_iter_size_hinted!(seq_iter_size_hinted_choose_from_1_cryptoRng, CryptoRng, choose, 1);
+
+//Unhinted
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_10000_cryptoRng, CryptoRng, choose, 10000);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_10000_smallRng, SmallRng, choose, 10000);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_1000_cryptoRng, CryptoRng, choose, 1000);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_1000_smallRng, SmallRng, choose, 1000);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_100_cryptoRng, CryptoRng, choose, 100);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_100_smallRng, SmallRng, choose, 100);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_10_smallRng, SmallRng, choose, 10);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_10_cryptoRng, CryptoRng, choose, 10);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_3_smallRng, SmallRng, choose, 3);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_3_cryptoRng, CryptoRng, choose, 3);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_2_smallRng, SmallRng, choose, 2);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_2_cryptoRng, CryptoRng, choose, 2);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_1_smallRng, SmallRng, choose, 1);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_from_1_cryptoRng, CryptoRng, choose, 1);
+
+// Window hinted
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_10000_cryptoRng, CryptoRng, choose, 10000);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_10000_smallRng, SmallRng, choose, 10000);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_1000_cryptoRng, CryptoRng, choose, 1000);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_1000_smallRng, SmallRng, choose, 1000);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_100_cryptoRng, CryptoRng, choose, 100);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_100_smallRng, SmallRng, choose, 100);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_10_smallRng, SmallRng, choose, 10);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_10_cryptoRng, CryptoRng, choose, 10);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_3_smallRng, SmallRng, choose, 3);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_3_cryptoRng, CryptoRng, choose, 3);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_2_smallRng, SmallRng, choose, 2);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_2_cryptoRng, CryptoRng, choose, 2);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_1_smallRng, SmallRng, choose, 1);
+bench_seq_iter_window_hinted!(seq_iter_window_hinted_choose_from_1_cryptoRng, CryptoRng, choose, 1);
+
+//Choose Stable
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_10000_smallRng, SmallRng, choose_stable, 10000);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_10000_cryptoRng, CryptoRng, choose_stable, 10000);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_1000_smallRng, SmallRng, choose_stable, 1000);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_1000_cryptoRng, CryptoRng, choose_stable, 1000);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_100_smallRng, SmallRng, choose_stable, 100);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_100_cryptoRng, CryptoRng, choose_stable, 100);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_10_smallRng, SmallRng, choose_stable, 10);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_10_cryptoRng, CryptoRng, choose_stable, 10);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_3_smallRng, SmallRng, choose_stable, 3);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_3_cryptoRng, CryptoRng, choose_stable, 3);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_2_smallRng, SmallRng, choose_stable, 2);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_2_cryptoRng, CryptoRng, choose_stable, 2);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_1_smallRng, SmallRng, choose_stable, 1);
+bench_seq_iter_unhinted!(seq_iter_unhinted_choose_stable_from_1_cryptoRng, CryptoRng, choose_stable, 1);
+

src/seq/coin_flipper.rs

@@ -0,0 +1,138 @@
+use crate::RngCore;
+
+pub(crate) struct CoinFlipper<R: RngCore> {
+    pub rng: R,
+    chunk: u32,
+    chunk_remaining: u32,
+}
+
+impl<R: RngCore> CoinFlipper<R> {
+    pub fn new(rng: R) -> Self {
+        Self {
+            rng,
+            chunk: 0,
+            chunk_remaining: 0,
+        }
+    }
+
+    #[inline]
+    /// Returns true with a probability of 1 / d
+    /// Uses an expected two bits of randomness
+    pub fn gen_ratio_one_over(&mut self, d: usize) -> bool {
+        // This uses the same logic as `gen_ratio` but is optimized for the case that the starting numerator is one (which it always is for `Sequence::Choose()`)
+
+        // In this case (unlike in `gen_ratio`), this way of calculating c is always accurate
+        let c = (usize::BITS - 1 - d.leading_zeros()).min(32);
+
+        if self.flip_until_tails(c) {
+            let numerator = 1 << c;
+            return self.gen_ratio(numerator, d);
+        } else {
+            return false;
+        }
+    }
+
+    #[inline]
+    /// Returns true with a probability of n / d
+    /// Uses an expected two bits of randomness
+    fn gen_ratio(&mut self, mut n: usize, d: usize) -> bool {
+        // Explanation:        
+        // We are trying to return true with a probability of n / d
+        // If n >= d, we can just return true
+        // Otherwise there are two possibilities 2n < d and 2n >= d
+        // In either case we flip a coin.
+        // If 2n < d
+        //  If it comes up tails, return false
+        //  If it comes up heads, double n and start again
+        //  This is fair because (0.5 * 0) + (0.5 * 2n / d) = n / d and 2n is less than d (if 2n was greater than d we would effectively round it down to 1 by returning true)
+        // If 2n >= d
+        //   If it comes up tails, set n to 2n - d and start again
+        //   If it comes up heads, return true
+        //   This is fair because (0.5 * 1) + (0.5 * (2n - d) / d) = n / d
+        //   Note that if 2n = d and the coin comes up tails, n will be set to 0 before restarting which is equivalent to returning false.
+
+        // As a performance optimization we can flip multiple coins at once (using the `lzcnt` intrinsic)
+        // We can check up to 32 flips at once but we only receive one bit of information - all heads or at least one tail.
+        // Let c be the number of coins to flip. 1 <= c <= 32
+        // If 2n < d, n * 2^c < d
+        // If the result is all heads, then set n to n * 2^c
+        // If there was at least one tail, return false
+        // If 2n >= d, the order of the heads and tails matters so we flip one coin at a time so c = 1
+        // Ideally, c will be as high as possible within these constraints
+
+        while n < d {
+            //Find a good value for c by counting leading zeros
+            //This will either give the highest possible c, or 1 less than that
+            let c = n.leading_zeros().saturating_sub(d.leading_zeros() + 1).min(32).max(1);
+
+            // set next_n to n * 2^c (checked_shl will fail if 2n >= `usize::max`)
+            if let Some(next_n) = n.checked_shl(c) {
+                if self.flip_until_tails(c) {
+                    //All heads
+                    //if 2n < d, set n to 2n
+                    //if 2n >= d, the while loop will exit and we will return `true`
+                    n = next_n
+                } else {
+                    //At least one tail - either return false or set n to 2n-d
+                    n = next_n.saturating_sub(d);
+
+                    if n == 0 {                        
+                        //Because we used saturating_sub, n will be zero if 2n was less than d or 2n was equal to d, in either case we can return false.
+                        return false;
+                    }
+                }
+            } else {
+                // This branch will only be reached when 2n >= `usize::max`
+                // Obviously 2n > d
+                if self.flip_until_tails(1) {
+                    //heads
+                    return true;
+                } else {
+                    //tails
+                    n = n.saturating_add(n).saturating_sub(d); // set n to 2n -d
+                }
+            }
+        }
+        true
+    }
+
+    /// If the next `c` bits of randomness are all zeroes, consume them and return true.
+    /// Otherwise return false and consume the number of zeroes plus one
+    /// Generates new bits of randomness when necessary (int 32 bit chunks)
+    /// Has a one in 2 to the `c` chance of returning true
+    /// `c` must be less than or equal to 32
+    fn flip_until_tails(&mut self, mut c: u32) -> bool {
+        debug_assert!(c <= 32); //If `c` > 32 this wil always return false
+                                //Note that zeros on the left of the chunk represent heads. It needs to be this way round because zeros are filled in when left shifting
+        loop {
+            let zeros = self.chunk.leading_zeros();
+
+            if zeros < c {
+                // The happy path - we found a 1 and can return false
+                // Note that because a 1 bit was detected, we cannot have run out of random bits so we don't need to check
+
+                // First consume all of the bits read
+                self.chunk = self.chunk.wrapping_shl(zeros + 1);
+                self.chunk_remaining = self.chunk_remaining.saturating_sub(zeros + 1);
+                return false;
+            } else {
+                // The number of zeros is larger than `c`
+                //There are two possibilities
+                if let Some(new_remaining) = self.chunk_remaining.checked_sub(c) {
+                    //Those zeroes were all part of our random chunk, so throw away `c` bits of randomness and return true
+                    self.chunk_remaining = new_remaining;
+                    self.chunk <<= c;
+                    return true;
+                } else {
+                    // Some of those zeroes were part of the random chunk and some were part of the space behind it
+                    c -= self.chunk_remaining; //Take into account the zeroes that were random
+
+                    // Generate a new chunk
+                    self.chunk = self.rng.next_u32();
+                    self.chunk_remaining = 32;
+                    //Go back to start of loop
+                }
+            }
+        }
+    }
+}