Skip to content

Commit f8bd579

Browse files
arthurprsarthurprs
committed
improve benchmarks
1 parent 3ae9925 commit f8bd579

File tree

1 file changed

+115
-38
lines changed

1 file changed

+115
-38
lines changed

‎benches/bench.rs

Lines changed: 115 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,6 @@ extern crate fnv;
66
extern crate lazy_static;
77
extern crate hashmap2;
88

9-
109
macro_rules! bench_mod {
1110
($modname: ident, $hashmap: ident) => {
1211
mod $modname {
@@ -43,7 +42,7 @@ macro_rules! bench_mod {
4342
b.iter(|| {
4443
let mut map = $hashmap::with_capacity(c);
4544
for x in 0..c {
46-
map.insert(x, ());
45+
map.insert(x, x);
4746
}
4847
map
4948
});
@@ -52,10 +51,11 @@ macro_rules! bench_mod {
5251
#[bench]
5352
fn insert_string_10_000(b: &mut Bencher) {
5453
let c = 10_000usize;
54+
let ss = Vec::from_iter((0..c).map(|x| x.to_string()));
5555
b.iter(|| {
5656
let mut map = $hashmap::with_capacity(c);
57-
for x in 0..c {
58-
map.insert(x.to_string(), ());
57+
for key in &ss {
58+
map.insert(key.clone(), 0usize);
5959
}
6060
map
6161
});
@@ -68,7 +68,7 @@ macro_rules! bench_mod {
6868
b.iter(|| {
6969
let mut map = $hashmap::with_capacity(c);
7070
for key in &ss {
71-
map.insert(&key[..], ());
71+
map.insert(&key[..], 0usize);
7272
}
7373
map
7474
});
@@ -94,7 +94,7 @@ macro_rules! bench_mod {
9494
b.iter(|| {
9595
let mut map = $hashmap::with_capacity(c);
9696
for x in 0..c {
97-
map.insert(x, ());
97+
map.insert(x, x);
9898
}
9999
map
100100
});
@@ -106,7 +106,7 @@ macro_rules! bench_mod {
106106
b.iter(|| {
107107
let mut map = $hashmap::with_capacity(c);
108108
for x in 0..c {
109-
map.insert(x, ());
109+
map.insert(x, x);
110110
}
111111
map
112112
});
@@ -118,7 +118,7 @@ macro_rules! bench_mod {
118118
b.iter(|| {
119119
let mut map = $hashmap::with_capacity(c);
120120
for x in 0..c {
121-
map.insert(x, ());
121+
map.insert(x, x);
122122
}
123123
map
124124
});
@@ -130,7 +130,7 @@ macro_rules! bench_mod {
130130
let mut map = $hashmap::with_capacity(c);
131131
let len = c - c/10;
132132
for x in 0..len {
133-
map.insert(x, ());
133+
map.insert(x, x);
134134
}
135135
assert_eq!(map.len(), len);
136136
b.iter(|| {
@@ -157,15 +157,15 @@ macro_rules! bench_mod {
157157
}
158158
b.iter(|| {
159159
let mut found = 0;
160-
for key in 5000..c {
161-
found += map.get(&key).is_some() as i32;
160+
for key in 0..5000 {
161+
found += *map.get(&key).unwrap();
162162
}
163163
found
164164
});
165165
}
166166

167167
#[bench]
168-
fn lookup_hashmap_10_000_noexist(b: &mut Bencher) {
168+
fn lookup_10_000_noexist(b: &mut Bencher) {
169169
let c = 10_000usize;
170170
let mut map = HashMap::with_capacity(c);
171171
let keys = shuffled_keys(0..c);
@@ -174,29 +174,89 @@ macro_rules! bench_mod {
174174
}
175175
b.iter(|| {
176176
let mut found = 0;
177-
for key in c..15000 {
178-
found += map.get(&key).is_some() as i32;
177+
for key in c..c+5000 {
178+
found += map.get(&key).is_none() as u32;
179179
}
180180
found
181181
});
182182
}
183183

184184

185185
// number of items to look up
186-
const LOOKUP_MAP_SIZE: usize = 100_000_usize;
187186
const LOOKUP_SAMPLE_SIZE: usize = 5000;
188187

189188

190189
lazy_static! {
190+
static ref HMAP_10K: $hashmap<usize, usize> = {
191+
let c = 10_000_usize;
192+
let mut map = $hashmap::with_capacity(c as usize);
193+
let keys = shuffled_keys(0..c);
194+
for &key in &keys {
195+
map.insert(key, key);
196+
}
197+
map
198+
};
199+
191200
static ref HMAP_100K: $hashmap<usize, usize> = {
192-
let c = LOOKUP_MAP_SIZE;
201+
let c = 100_000_usize;
202+
let mut map = $hashmap::with_capacity(c as usize);
203+
let keys = shuffled_keys(0..c);
204+
for &key in &keys {
205+
map.insert(key, key);
206+
}
207+
map
208+
};
209+
210+
static ref HMAP_1M: $hashmap<usize, usize> = {
211+
let c = 1_000_000usize;
193212
let mut map = $hashmap::with_capacity(c as usize);
194213
let keys = shuffled_keys(0..c);
195214
for &key in &keys {
196215
map.insert(key, key);
197216
}
198217
map
199218
};
219+
220+
static ref HMAP_10K_BIG: $hashmap<usize, [u64; 10]> = {
221+
let c = 10_000_usize;
222+
let mut map = $hashmap::with_capacity(c as usize);
223+
let keys = shuffled_keys(0..c);
224+
for &key in &keys {
225+
map.insert(key, [0u64; 10]);
226+
}
227+
map
228+
};
229+
static ref HMAP_100K_BIG: $hashmap<usize, [u64; 10]> = {
230+
let c = 100_000_usize;
231+
let mut map = $hashmap::with_capacity(c as usize);
232+
let keys = shuffled_keys(0..c);
233+
for &key in &keys {
234+
map.insert(key, [0u64; 10]);
235+
}
236+
map
237+
};
238+
239+
static ref HMAP_1M_BIG: $hashmap<usize, [u64; 10]> = {
240+
let c = 1_000_000_usize;
241+
let mut map = $hashmap::with_capacity(c as usize);
242+
let keys = shuffled_keys(0..c);
243+
for &key in &keys {
244+
map.insert(key, [0u64; 10]);
245+
}
246+
map
247+
};
248+
}
249+
250+
#[bench]
251+
fn lookup_10_000_multi(b: &mut Bencher) {
252+
let map = &*HMAP_10K;
253+
b.iter(|| {
254+
let mut found = 0;
255+
for key in 0..LOOKUP_SAMPLE_SIZE {
256+
found += *map.get(&key).unwrap();
257+
}
258+
found
259+
});
200260
}
201261

202262
#[bench]
@@ -205,42 +265,59 @@ macro_rules! bench_mod {
205265
b.iter(|| {
206266
let mut found = 0;
207267
for key in 0..LOOKUP_SAMPLE_SIZE {
208-
found += map.get(&key).is_some() as u32;
268+
found += *map.get(&key).unwrap();
209269
}
210270
found
211271
});
212272
}
213273

214274
#[bench]
215-
fn lookup_100_000_multi_10p(b: &mut Bencher) {
216-
let map = &*HMAP_100K;
275+
fn lookup_1_000_000_multi(b: &mut Bencher) {
276+
let map = &*HMAP_1M;
217277
b.iter(|| {
218278
let mut found = 0;
219-
for key in 0..LOOKUP_SAMPLE_SIZE / 10 {
220-
found += map.get(&key).is_some() as u32;
279+
for key in 0..LOOKUP_SAMPLE_SIZE {
280+
found += *map.get(&key).unwrap();
221281
}
222282
found
223283
});
224284
}
225285

226286

287+
227288
#[bench]
228-
fn lookup_100_000_single(b: &mut Bencher) {
229-
let map = &*HMAP_100K;
230-
let mut iter = (0..LOOKUP_MAP_SIZE + LOOKUP_SAMPLE_SIZE).cycle();
289+
fn lookup_10_000_multi_bigvalue(b: &mut Bencher) {
290+
let map = &*HMAP_10K_BIG;
231291
b.iter(|| {
232-
let key = iter.next().unwrap();
233-
map.get(&key).is_some()
292+
let mut found = 0;
293+
for key in 0..LOOKUP_SAMPLE_SIZE {
294+
found += map.get(&key).unwrap()[0];
295+
}
296+
found
234297
});
235298
}
236299

237300
#[bench]
238-
fn lookup_100_000_single_10p(b: &mut Bencher) {
239-
let map = &*HMAP_100K;
240-
let mut iter = (0..LOOKUP_MAP_SIZE / 10).cycle();
301+
fn lookup_100_000_multi_bigvalue(b: &mut Bencher) {
302+
let map = &*HMAP_100K_BIG;
241303
b.iter(|| {
242-
let key = iter.next().unwrap();
243-
map.get(&key).is_some()
304+
let mut found = 0;
305+
for key in 0..LOOKUP_SAMPLE_SIZE {
306+
found += map.get(&key).unwrap()[0];
307+
}
308+
found
309+
});
310+
}
311+
312+
#[bench]
313+
fn lookup_1_000_000_multi_bigvalue(b: &mut Bencher) {
314+
let map = &*HMAP_1M_BIG;
315+
b.iter(|| {
316+
let mut found = 0;
317+
for key in 0..LOOKUP_SAMPLE_SIZE {
318+
found += map.get(&key).unwrap()[0];
319+
}
320+
found
244321
});
245322
}
246323

@@ -251,7 +328,7 @@ macro_rules! bench_mod {
251328
b.iter(|| {
252329
let mut map = $hashmap::new();
253330
for x in 0..c {
254-
map.insert(x, ());
331+
map.insert(x, x);
255332
}
256333
map
257334
});
@@ -263,7 +340,7 @@ macro_rules! bench_mod {
263340
b.iter(|| {
264341
let mut map: $hashmap<_, _, FnvBuilder> = $hashmap::default();
265342
for x in 0..c {
266-
map.insert(x, ());
343+
map.insert(x, x);
267344
}
268345
map
269346
});
@@ -272,8 +349,8 @@ macro_rules! bench_mod {
272349
const MERGE: usize = 10_000usize;
273350
#[bench]
274351
fn merge_simple(b: &mut Bencher) {
275-
let first_map: $hashmap<usize, _> = (0..MERGE).map(|i| (i, ())).collect();
276-
let second_map: $hashmap<usize, _> = (MERGE..MERGE * 2).map(|i| (i, ())).collect();
352+
let first_map: $hashmap<usize, usize> = (0..MERGE).map(|i| (i, i)).collect();
353+
let second_map: $hashmap<usize, usize> = (MERGE..MERGE * 2).map(|i| (i, i)).collect();
277354
b.iter(|| {
278355
let mut merged = first_map.clone();
279356
merged.extend(second_map.iter().map(|(&k, &v)| (k, v)));
@@ -283,8 +360,8 @@ macro_rules! bench_mod {
283360

284361
#[bench]
285362
fn merge_shuffle(b: &mut Bencher) {
286-
let first_map: $hashmap<usize, _> = (0..MERGE).map(|i| (i, ())).collect();
287-
let second_map: $hashmap<usize, _> = (MERGE..MERGE * 2).map(|i| (i, ())).collect();
363+
let first_map: $hashmap<usize, usize> = (0..MERGE).map(|i| (i, i)).collect();
364+
let second_map: $hashmap<usize, usize> = (MERGE..MERGE * 2).map(|i| (i, i)).collect();
288365
let mut v = Vec::new();
289366
let mut rng = weak_rng();
290367
b.iter(|| {
@@ -300,4 +377,4 @@ macro_rules! bench_mod {
300377
}
301378

302379
bench_mod!(hashmap, HashMap);
303-
bench_mod!(hhhkvjv, HashMap2);
380+
bench_mod!(hhkvkv, HashMap2);

0 commit comments

Comments
 (0)