1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 use super::BitVec;
12 use rand::{Rng, weak_rng, XorShiftRng};
13
14 use test::{Bencher, black_box};
15
16 const BENCH_BITS : usize = 1 << 14;
17 const U32_BITS: usize = 32;
18
rng() -> XorShiftRng19 fn rng() -> XorShiftRng {
20 weak_rng()
21 }
22
23 #[bench]
bench_usize_small(b: &mut Bencher)24 fn bench_usize_small(b: &mut Bencher) {
25 let mut r = rng();
26 let mut bit_vec = 0 as usize;
27 b.iter(|| {
28 for _ in 0..100 {
29 bit_vec |= 1 << ((r.next_u32() as usize) % U32_BITS);
30 }
31 black_box(&bit_vec);
32 });
33 }
34
35 #[bench]
bench_bit_set_big_fixed(b: &mut Bencher)36 fn bench_bit_set_big_fixed(b: &mut Bencher) {
37 let mut r = rng();
38 let mut bit_vec = BitVec::from_elem(BENCH_BITS, false);
39 b.iter(|| {
40 for _ in 0..100 {
41 bit_vec.set((r.next_u32() as usize) % BENCH_BITS, true);
42 }
43 black_box(&bit_vec);
44 });
45 }
46
47 #[bench]
bench_bit_set_big_variable(b: &mut Bencher)48 fn bench_bit_set_big_variable(b: &mut Bencher) {
49 let mut r = rng();
50 let mut bit_vec = BitVec::from_elem(BENCH_BITS, false);
51 b.iter(|| {
52 for _ in 0..100 {
53 bit_vec.set((r.next_u32() as usize) % BENCH_BITS, r.gen());
54 }
55 black_box(&bit_vec);
56 });
57 }
58
59 #[bench]
bench_bit_set_small(b: &mut Bencher)60 fn bench_bit_set_small(b: &mut Bencher) {
61 let mut r = rng();
62 let mut bit_vec = BitVec::from_elem(U32_BITS, false);
63 b.iter(|| {
64 for _ in 0..100 {
65 bit_vec.set((r.next_u32() as usize) % U32_BITS, true);
66 }
67 black_box(&bit_vec);
68 });
69 }
70
71 #[bench]
bench_bit_vec_big_union(b: &mut Bencher)72 fn bench_bit_vec_big_union(b: &mut Bencher) {
73 let mut b1 = BitVec::from_elem(BENCH_BITS, false);
74 let b2 = BitVec::from_elem(BENCH_BITS, false);
75 b.iter(|| {
76 b1.union(&b2)
77 })
78 }
79
80 #[bench]
bench_bit_vec_small_iter(b: &mut Bencher)81 fn bench_bit_vec_small_iter(b: &mut Bencher) {
82 let bit_vec = BitVec::from_elem(U32_BITS, false);
83 b.iter(|| {
84 let mut sum = 0;
85 for _ in 0..10 {
86 for pres in &bit_vec {
87 sum += pres as usize;
88 }
89 }
90 sum
91 })
92 }
93
94 #[bench]
bench_bit_vec_big_iter(b: &mut Bencher)95 fn bench_bit_vec_big_iter(b: &mut Bencher) {
96 let bit_vec = BitVec::from_elem(BENCH_BITS, false);
97 b.iter(|| {
98 let mut sum = 0;
99 for pres in &bit_vec {
100 sum += pres as usize;
101 }
102 sum
103 })
104 }
105
106 #[bench]
bench_from_elem(b: &mut Bencher)107 fn bench_from_elem(b: &mut Bencher) {
108 let cap = black_box(BENCH_BITS);
109 let bit = black_box(true);
110 b.iter(|| {
111 // create a BitVec and popcount it
112 BitVec::from_elem(cap, bit).blocks()
113 .fold(0, |acc, b| acc + b.count_ones())
114 });
115 b.bytes = cap as u64 / 8;
116 }
117