From 51b32c1b4a7e132ba53d98d430c35dadd10cb204 Mon Sep 17 00:00:00 2001 From: Diggory Hardy Date: Wed, 21 Feb 2018 15:28:44 +0000 Subject: [PATCH] Update benchmark code based on dhardy/master --- benches/bench.rs | 34 ---------- benches/distributions.rs | 96 ++++++++++++++++++++++++++++ benches/distributions/exponential.rs | 18 ------ benches/distributions/gamma.rs | 31 --------- benches/distributions/mod.rs | 3 - benches/distributions/normal.rs | 18 ------ benches/generators.rs | 23 ++----- 7 files changed, 100 insertions(+), 123 deletions(-) delete mode 100644 benches/bench.rs create mode 100644 benches/distributions.rs delete mode 100644 benches/distributions/exponential.rs delete mode 100644 benches/distributions/gamma.rs delete mode 100644 benches/distributions/mod.rs delete mode 100644 benches/distributions/normal.rs diff --git a/benches/bench.rs b/benches/bench.rs deleted file mode 100644 index 4aa06511e1a..00000000000 --- a/benches/bench.rs +++ /dev/null @@ -1,34 +0,0 @@ -#![feature(test)] - -extern crate test; -extern crate rand; - -const RAND_BENCH_N: u64 = 1000; - -mod distributions; - -use std::mem::size_of; -use test::{black_box, Bencher}; -use rand::{StdRng, RngCore, NewRng}; - -#[bench] -fn rand_f32(b: &mut Bencher) { - let mut rng = StdRng::new().unwrap(); - b.iter(|| { - for _ in 0..RAND_BENCH_N { - black_box(rng.next_f32()); - } - }); - b.bytes = size_of::() as u64 * RAND_BENCH_N; -} - -#[bench] -fn rand_f64(b: &mut Bencher) { - let mut rng = StdRng::new().unwrap(); - b.iter(|| { - for _ in 0..RAND_BENCH_N { - black_box(rng.next_f64()); - } - }); - b.bytes = size_of::() as u64 * RAND_BENCH_N; -} diff --git a/benches/distributions.rs b/benches/distributions.rs new file mode 100644 index 00000000000..568d5024992 --- /dev/null +++ b/benches/distributions.rs @@ -0,0 +1,96 @@ +#![feature(test)] +#![cfg_attr(feature = "i128_support", feature(i128_type, i128))] + +extern crate test; +extern crate rand; + +const RAND_BENCH_N: u64 = 1000; + +use std::mem::size_of; +use test::{black_box, Bencher}; + +use rand::{Rng, NewRng, XorShiftRng}; +use rand::distributions::*; + +macro_rules! distr { + ($fnn:ident, $ty:ty, $distr:expr) => { + #[bench] + fn $fnn(b: &mut Bencher) { + let mut rng = XorShiftRng::new().unwrap(); + let distr = $distr; + + b.iter(|| { + for _ in 0..::RAND_BENCH_N { + let x: $ty = distr.sample(&mut rng); + black_box(x); + } + }); + b.bytes = size_of::<$ty>() as u64 * ::RAND_BENCH_N; + } + } +} + +// range +distr!(distr_range_i8, i8, Range::new(20i8, 100)); +distr!(distr_range_i16, i16, Range::new(-500i16, 2000)); +distr!(distr_range_i32, i32, Range::new(-200_000_000i32, 800_000_000)); +distr!(distr_range_i64, i64, Range::new(3i64, 12345678901234)); +#[cfg(feature = "i128_support")] +distr!(distr_range_i128, i128, Range::new(-12345678901234i128, 12345678901234567890)); + +distr!(distr_range_float32, f32, Range::new(2.26f32, 2.319)); +distr!(distr_range_float, f64, Range::new(2.26f64, 2.319)); + +// uniform +distr!(distr_uniform_i8, i8, Uniform); +distr!(distr_uniform_i16, i16, Uniform); +distr!(distr_uniform_i32, i32, Uniform); +distr!(distr_uniform_i64, i64, Uniform); +#[cfg(feature = "i128_support")] +distr!(distr_uniform_i128, i128, Uniform); + +distr!(distr_uniform_bool, bool, Uniform); +distr!(distr_uniform_codepoint, char, Uniform); + +distr!(distr_uniform01_float32, f32, Uniform); +distr!(distr_closed01_float32, f32, Closed01); +distr!(distr_open01_float32, f32, Open01); + +distr!(distr_uniform01_float, f64, Uniform); +distr!(distr_closed01_float, f64, Closed01); +distr!(distr_open01_float, f64, Open01); + +// distributions +distr!(distr_exp, f64, Exp::new(2.71828 * 3.14159)); +distr!(distr_normal, f64, Normal::new(-2.71828, 3.14159)); +distr!(distr_log_normal, f64, LogNormal::new(-2.71828, 3.14159)); +distr!(distr_gamma_large_shape, f64, Gamma::new(10., 1.0)); +distr!(distr_gamma_small_shape, f64, Gamma::new(0.1, 1.0)); + + +// construct and sample from a range +macro_rules! gen_range_int { + ($fnn:ident, $ty:ty, $low:expr, $high:expr) => { + #[bench] + fn $fnn(b: &mut Bencher) { + let mut rng = XorShiftRng::new().unwrap(); + let high = $high; + + b.iter(|| { + for _ in 0..::RAND_BENCH_N { + let x: $ty = rng.gen_range($low, high); + black_box(x); + black_box(high); + } + }); + b.bytes = size_of::<$ty>() as u64 * ::RAND_BENCH_N; + } + } +} + +gen_range_int!(gen_range_i8, i8, 20i8, 100); +gen_range_int!(gen_range_i16, i16, -500i16, 2000); +gen_range_int!(gen_range_i32, i32, -200_000_000i32, 800_000_000); +gen_range_int!(gen_range_i64, i64, 3i64, 12345678901234); +#[cfg(feature = "i128_support")] +gen_range_int!(gen_range_i128, i128, -12345678901234i128, 12345678901234567890); diff --git a/benches/distributions/exponential.rs b/benches/distributions/exponential.rs deleted file mode 100644 index 57c581a810d..00000000000 --- a/benches/distributions/exponential.rs +++ /dev/null @@ -1,18 +0,0 @@ -use std::mem::size_of; -use test::Bencher; -use rand; -use rand::distributions::exponential::Exp; -use rand::distributions::Distribution; - -#[bench] -fn rand_exp(b: &mut Bencher) { - let mut rng = rand::weak_rng(); - let exp = Exp::new(2.71828 * 3.14159); - - b.iter(|| { - for _ in 0..::RAND_BENCH_N { - exp.sample(&mut rng); - } - }); - b.bytes = size_of::() as u64 * ::RAND_BENCH_N; -} diff --git a/benches/distributions/gamma.rs b/benches/distributions/gamma.rs deleted file mode 100644 index 47c501f35fd..00000000000 --- a/benches/distributions/gamma.rs +++ /dev/null @@ -1,31 +0,0 @@ -use std::mem::size_of; -use test::Bencher; -use rand; -use rand::distributions::Distribution; -use rand::distributions::gamma::Gamma; - -#[bench] -fn bench_gamma_large_shape(b: &mut Bencher) { - let gamma = Gamma::new(10., 1.0); - let mut rng = rand::weak_rng(); - - b.iter(|| { - for _ in 0..::RAND_BENCH_N { - gamma.sample(&mut rng); - } - }); - b.bytes = size_of::() as u64 * ::RAND_BENCH_N; -} - -#[bench] -fn bench_gamma_small_shape(b: &mut Bencher) { - let gamma = Gamma::new(0.1, 1.0); - let mut rng = rand::weak_rng(); - - b.iter(|| { - for _ in 0..::RAND_BENCH_N { - gamma.sample(&mut rng); - } - }); - b.bytes = size_of::() as u64 * ::RAND_BENCH_N; -} diff --git a/benches/distributions/mod.rs b/benches/distributions/mod.rs deleted file mode 100644 index 49f6bd9c06c..00000000000 --- a/benches/distributions/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -mod exponential; -mod normal; -mod gamma; diff --git a/benches/distributions/normal.rs b/benches/distributions/normal.rs deleted file mode 100644 index 509f954857e..00000000000 --- a/benches/distributions/normal.rs +++ /dev/null @@ -1,18 +0,0 @@ -use std::mem::size_of; -use test::Bencher; -use rand; -use rand::distributions::Distribution; -use rand::distributions::normal::Normal; - -#[bench] -fn rand_normal(b: &mut Bencher) { - let mut rng = rand::weak_rng(); - let normal = Normal::new(-2.71828, 3.14159); - - b.iter(|| { - for _ in 0..::RAND_BENCH_N { - normal.sample(&mut rng); - } - }); - b.bytes = size_of::() as u64 * ::RAND_BENCH_N; -} diff --git a/benches/generators.rs b/benches/generators.rs index 906b0a93512..c1f81efcb82 100644 --- a/benches/generators.rs +++ b/benches/generators.rs @@ -52,34 +52,19 @@ macro_rules! gen_uint { } } -macro_rules! gen_uint_new { - ($fnn:ident, $ty:ty, $gen:ident) => { - #[bench] - fn $fnn(b: &mut Bencher) { - let mut rng = $gen::new().unwrap(); - b.iter(|| { - for _ in 0..RAND_BENCH_N { - black_box(rng.gen::<$ty>()); - } - }); - b.bytes = size_of::<$ty>() as u64 * RAND_BENCH_N; - } - } -} - gen_uint!(gen_u32_xorshift, u32, XorShiftRng); gen_uint!(gen_u32_hc128, u32, Hc128Rng); gen_uint!(gen_u32_isaac, u32, IsaacRng); gen_uint!(gen_u32_isaac64, u32, Isaac64Rng); -gen_uint_new!(gen_u32_std, u32, StdRng); -gen_uint_new!(gen_u32_os, u32, OsRng); +gen_uint!(gen_u32_std, u32, StdRng); +gen_uint!(gen_u32_os, u32, OsRng); gen_uint!(gen_u64_xorshift, u64, XorShiftRng); gen_uint!(gen_u64_hc128, u64, Hc128Rng); gen_uint!(gen_u64_isaac, u64, IsaacRng); gen_uint!(gen_u64_isaac64, u64, Isaac64Rng); -gen_uint_new!(gen_u64_std, u64, StdRng); -gen_uint_new!(gen_u64_os, u64, OsRng); +gen_uint!(gen_u64_std, u64, StdRng); +gen_uint!(gen_u64_os, u64, OsRng); // Do not test JitterRng like the others by running it RAND_BENCH_N times per, // measurement, because it is way too slow. Only run it once.