@@ -12,6 +12,46 @@ use test::{black_box, Bencher};
12
12
use rand:: { Rng , NewRng , XorShiftRng } ;
13
13
use rand:: distributions:: * ;
14
14
15
+ macro_rules! distr_int {
16
+ ( $fnn: ident, $ty: ty, $distr: expr) => {
17
+ #[ bench]
18
+ fn $fnn( b: & mut Bencher ) {
19
+ let mut rng = XorShiftRng :: new( ) ;
20
+ let distr = $distr;
21
+
22
+ b. iter( || {
23
+ let mut accum = 0 as $ty;
24
+ for _ in 0 ..:: RAND_BENCH_N {
25
+ let x: $ty = distr. sample( & mut rng) ;
26
+ accum = accum. wrapping_add( x) ;
27
+ }
28
+ black_box( accum) ;
29
+ } ) ;
30
+ b. bytes = size_of:: <$ty>( ) as u64 * :: RAND_BENCH_N ;
31
+ }
32
+ }
33
+ }
34
+
35
+ macro_rules! distr_float {
36
+ ( $fnn: ident, $ty: ty, $distr: expr) => {
37
+ #[ bench]
38
+ fn $fnn( b: & mut Bencher ) {
39
+ let mut rng = XorShiftRng :: new( ) ;
40
+ let distr = $distr;
41
+
42
+ b. iter( || {
43
+ let mut accum = 0.0 ;
44
+ for _ in 0 ..:: RAND_BENCH_N {
45
+ let x: $ty = distr. sample( & mut rng) ;
46
+ accum = accum + x;
47
+ }
48
+ black_box( accum) ;
49
+ } ) ;
50
+ b. bytes = size_of:: <$ty>( ) as u64 * :: RAND_BENCH_N ;
51
+ }
52
+ }
53
+ }
54
+
15
55
macro_rules! distr {
16
56
( $fnn: ident, $ty: ty, $distr: expr) => {
17
57
#[ bench]
@@ -31,62 +71,64 @@ macro_rules! distr {
31
71
}
32
72
33
73
// range
34
- distr ! ( distr_range_i8, i8 , Range :: new( 20i8 , 100 ) ) ;
35
- distr ! ( distr_range_i16, i16 , Range :: new( -500i16 , 2000 ) ) ;
36
- distr ! ( distr_range_i32, i32 , Range :: new( -200_000_000i32 , 800_000_000 ) ) ;
37
- distr ! ( distr_range_i64, i64 , Range :: new( 3i64 , 12345678901234 ) ) ;
74
+ distr_int ! ( distr_range_i8, i8 , Range :: new( 20i8 , 100 ) ) ;
75
+ distr_int ! ( distr_range_i16, i16 , Range :: new( -500i16 , 2000 ) ) ;
76
+ distr_int ! ( distr_range_i32, i32 , Range :: new( -200_000_000i32 , 800_000_000 ) ) ;
77
+ distr_int ! ( distr_range_i64, i64 , Range :: new( 3i64 , 12345678901234 ) ) ;
38
78
#[ cfg( feature = "i128_support" ) ]
39
- distr ! ( distr_range_i128, i128 , Range :: new( -12345678901234i128 , 12345678901234567890 ) ) ;
79
+ distr_int ! ( distr_range_i128, i128 , Range :: new( -12345678901234i128 , 12345678901234567890 ) ) ;
40
80
41
- distr ! ( distr_range_f32, f32 , Range :: new( 2.26f32 , 2.319 ) ) ;
42
- distr ! ( distr_range_f64, f64 , Range :: new( 2.26f64 , 2.319 ) ) ;
81
+ distr_float ! ( distr_range_f32, f32 , Range :: new( 2.26f32 , 2.319 ) ) ;
82
+ distr_float ! ( distr_range_f64, f64 , Range :: new( 2.26f64 , 2.319 ) ) ;
43
83
44
84
// uniform
45
- distr ! ( distr_uniform_i8, i8 , Uniform ) ;
46
- distr ! ( distr_uniform_i16, i16 , Uniform ) ;
47
- distr ! ( distr_uniform_i32, i32 , Uniform ) ;
48
- distr ! ( distr_uniform_i64, i64 , Uniform ) ;
85
+ distr_int ! ( distr_uniform_i8, i8 , Uniform ) ;
86
+ distr_int ! ( distr_uniform_i16, i16 , Uniform ) ;
87
+ distr_int ! ( distr_uniform_i32, i32 , Uniform ) ;
88
+ distr_int ! ( distr_uniform_i64, i64 , Uniform ) ;
49
89
#[ cfg( feature = "i128_support" ) ]
50
- distr ! ( distr_uniform_i128, i128 , Uniform ) ;
90
+ distr_int ! ( distr_uniform_i128, i128 , Uniform ) ;
51
91
52
92
distr ! ( distr_uniform_bool, bool , Uniform ) ;
53
93
distr ! ( distr_uniform_alphanumeric, char , Alphanumeric ) ;
54
94
distr ! ( distr_uniform_codepoint, char , Uniform ) ;
55
95
56
- distr ! ( distr_uniform_f32, f32 , Uniform ) ;
57
- distr ! ( distr_uniform_f64, f64 , Uniform ) ;
96
+ distr_float ! ( distr_uniform_f32, f32 , Uniform ) ;
97
+ distr_float ! ( distr_uniform_f64, f64 , Uniform ) ;
58
98
59
99
// distributions
60
- distr ! ( distr_exp, f64 , Exp :: new( 2.71828 * 3.14159 ) ) ;
61
- distr ! ( distr_normal, f64 , Normal :: new( -2.71828 , 3.14159 ) ) ;
62
- distr ! ( distr_log_normal, f64 , LogNormal :: new( -2.71828 , 3.14159 ) ) ;
63
- distr ! ( distr_gamma_large_shape, f64 , Gamma :: new( 10. , 1.0 ) ) ;
64
- distr ! ( distr_gamma_small_shape, f64 , Gamma :: new( 0.1 , 1.0 ) ) ;
65
- distr ! ( distr_binomial, u64 , Binomial :: new( 20 , 0.7 ) ) ;
66
- distr ! ( distr_poisson, u64 , Poisson :: new( 4.0 ) ) ;
100
+ distr_float ! ( distr_exp, f64 , Exp :: new( 2.71828 * 3.14159 ) ) ;
101
+ distr_float ! ( distr_normal, f64 , Normal :: new( -2.71828 , 3.14159 ) ) ;
102
+ distr_float ! ( distr_log_normal, f64 , LogNormal :: new( -2.71828 , 3.14159 ) ) ;
103
+ distr_float ! ( distr_gamma_large_shape, f64 , Gamma :: new( 10. , 1.0 ) ) ;
104
+ distr_float ! ( distr_gamma_small_shape, f64 , Gamma :: new( 0.1 , 1.0 ) ) ;
105
+ distr_int ! ( distr_binomial, u64 , Binomial :: new( 20 , 0.7 ) ) ;
106
+ distr_int ! ( distr_poisson, u64 , Poisson :: new( 4.0 ) ) ;
67
107
68
108
69
109
// construct and sample from a range
70
110
macro_rules! gen_range_int {
71
- ( $fnn: ident, $ty: ty , $low: expr, $high: expr) => {
111
+ ( $fnn: ident, $ty: ident , $low: expr, $high: expr) => {
72
112
#[ bench]
73
113
fn $fnn( b: & mut Bencher ) {
74
114
let mut rng = XorShiftRng :: new( ) ;
75
- let high = $high;
76
115
77
116
b. iter( || {
117
+ let mut high = $high;
118
+ let mut accum: $ty = 0 ;
78
119
for _ in 0 ..:: RAND_BENCH_N {
79
- let x : $ty = rng. gen_range( $low, high) ;
80
- black_box ( x ) ;
81
- black_box ( high) ;
120
+ accum = accum . wrapping_add ( rng. gen_range( $low, high) ) ;
121
+ // force recalculation of range each time
122
+ high = high . wrapping_add ( 1 ) & std :: $ty :: MAX ;
82
123
}
124
+ black_box( accum) ;
83
125
} ) ;
84
126
b. bytes = size_of:: <$ty>( ) as u64 * :: RAND_BENCH_N ;
85
127
}
86
128
}
87
129
}
88
130
89
- gen_range_int ! ( gen_range_i8, i8 , 20i8 , 100 ) ;
131
+ gen_range_int ! ( gen_range_i8, i8 , - 20i8 , 100 ) ;
90
132
gen_range_int ! ( gen_range_i16, i16 , -500i16 , 2000 ) ;
91
133
gen_range_int ! ( gen_range_i32, i32 , -200_000_000i32 , 800_000_000 ) ;
92
134
gen_range_int ! ( gen_range_i64, i64 , 3i64 , 12345678901234 ) ;
0 commit comments