1 //! This file contains benchmarks for the ops traits implemented by HashSet.
2 //! Each test is intended to have a defined larger and smaller set,
3 //! but using a larger size for the "small" set works just as well.
4 //!
5 //! Each assigning test is done in the configuration that is faster. Cheating, I know.
6 //! The exception to this is Sub, because there the result differs. So I made two benchmarks for Sub.
7
8 #![feature(test)]
9
10 extern crate test;
11
12 use hashbrown::HashSet;
13 use test::Bencher;
14
15 /// The number of items to generate for the larger of the sets.
16 const LARGE_SET_SIZE: usize = 1000;
17
18 /// The number of items to generate for the smaller of the sets.
19 const SMALL_SET_SIZE: usize = 100;
20
21 /// The number of keys present in both sets.
22 const OVERLAP: usize =
23 [LARGE_SET_SIZE, SMALL_SET_SIZE][(LARGE_SET_SIZE < SMALL_SET_SIZE) as usize] / 2;
24
25 /// Creates a set containing end - start unique string elements.
create_set(start: usize, end: usize) -> HashSet<String>26 fn create_set(start: usize, end: usize) -> HashSet<String> {
27 (start..end).map(|nr| format!("key{}", nr)).collect()
28 }
29
30 #[bench]
set_ops_bit_or(b: &mut Bencher)31 fn set_ops_bit_or(b: &mut Bencher) {
32 let large_set = create_set(0, LARGE_SET_SIZE);
33 let small_set = create_set(
34 LARGE_SET_SIZE - OVERLAP,
35 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
36 );
37 b.iter(|| &large_set | &small_set)
38 }
39
40 #[bench]
set_ops_bit_and(b: &mut Bencher)41 fn set_ops_bit_and(b: &mut Bencher) {
42 let large_set = create_set(0, LARGE_SET_SIZE);
43 let small_set = create_set(
44 LARGE_SET_SIZE - OVERLAP,
45 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
46 );
47 b.iter(|| &large_set & &small_set)
48 }
49
50 #[bench]
set_ops_bit_xor(b: &mut Bencher)51 fn set_ops_bit_xor(b: &mut Bencher) {
52 let large_set = create_set(0, LARGE_SET_SIZE);
53 let small_set = create_set(
54 LARGE_SET_SIZE - OVERLAP,
55 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
56 );
57 b.iter(|| &large_set ^ &small_set)
58 }
59
60 #[bench]
set_ops_sub_large_small(b: &mut Bencher)61 fn set_ops_sub_large_small(b: &mut Bencher) {
62 let large_set = create_set(0, LARGE_SET_SIZE);
63 let small_set = create_set(
64 LARGE_SET_SIZE - OVERLAP,
65 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
66 );
67 b.iter(|| &large_set - &small_set)
68 }
69
70 #[bench]
set_ops_sub_small_large(b: &mut Bencher)71 fn set_ops_sub_small_large(b: &mut Bencher) {
72 let large_set = create_set(0, LARGE_SET_SIZE);
73 let small_set = create_set(
74 LARGE_SET_SIZE - OVERLAP,
75 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
76 );
77 b.iter(|| &small_set - &large_set)
78 }
79
80 #[bench]
set_ops_bit_or_assign(b: &mut Bencher)81 fn set_ops_bit_or_assign(b: &mut Bencher) {
82 let large_set = create_set(0, LARGE_SET_SIZE);
83 let small_set = create_set(
84 LARGE_SET_SIZE - OVERLAP,
85 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
86 );
87 b.iter(|| {
88 let mut set = large_set.clone();
89 set |= &small_set;
90 set
91 });
92 }
93
94 #[bench]
set_ops_bit_and_assign(b: &mut Bencher)95 fn set_ops_bit_and_assign(b: &mut Bencher) {
96 let large_set = create_set(0, LARGE_SET_SIZE);
97 let small_set = create_set(
98 LARGE_SET_SIZE - OVERLAP,
99 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
100 );
101 b.iter(|| {
102 let mut set = small_set.clone();
103 set &= &large_set;
104 set
105 });
106 }
107
108 #[bench]
set_ops_bit_xor_assign(b: &mut Bencher)109 fn set_ops_bit_xor_assign(b: &mut Bencher) {
110 let large_set = create_set(0, LARGE_SET_SIZE);
111 let small_set = create_set(
112 LARGE_SET_SIZE - OVERLAP,
113 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
114 );
115 b.iter(|| {
116 let mut set = large_set.clone();
117 set ^= &small_set;
118 set
119 });
120 }
121
122 #[bench]
set_ops_sub_assign_large_small(b: &mut Bencher)123 fn set_ops_sub_assign_large_small(b: &mut Bencher) {
124 let large_set = create_set(0, LARGE_SET_SIZE);
125 let small_set = create_set(
126 LARGE_SET_SIZE - OVERLAP,
127 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
128 );
129 b.iter(|| {
130 let mut set = large_set.clone();
131 set -= &small_set;
132 set
133 });
134 }
135
136 #[bench]
set_ops_sub_assign_small_large(b: &mut Bencher)137 fn set_ops_sub_assign_small_large(b: &mut Bencher) {
138 let large_set = create_set(0, LARGE_SET_SIZE);
139 let small_set = create_set(
140 LARGE_SET_SIZE - OVERLAP,
141 LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
142 );
143 b.iter(|| {
144 let mut set = small_set.clone();
145 set -= &large_set;
146 set
147 });
148 }
149