1 mod setup;
2
3 use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion, Throughput};
4 use setup::{ReaderEmptySetup, ReaderFilledSetup, INPUT, NUM_THREADS};
5
reader_std(c: &mut Criterion)6 fn reader_std(c: &mut Criterion) {
7 use std::collections::hash_map::RandomState;
8
9 let mut group = c.benchmark_group("RodeoReader 1 Thread (std)");
10 group.throughput(Throughput::Bytes(INPUT.len() as u64));
11
12 let setup = ReaderEmptySetup::new(RandomState::default());
13 group.bench_function("get (empty)", |b| {
14 b.iter_batched(
15 || setup.empty_rodeo(),
16 |rodeo| {
17 for &line in setup.lines() {
18 black_box(rodeo.get(line));
19 }
20 },
21 BatchSize::PerIteration,
22 )
23 });
24
25 let setup = ReaderFilledSetup::new(RandomState::default());
26 group.bench_function("get (filled)", |b| {
27 b.iter_batched(
28 || setup.filled_rodeo(),
29 |rodeo| {
30 for &line in setup.lines() {
31 black_box(rodeo.get(line));
32 }
33 },
34 BatchSize::PerIteration,
35 )
36 });
37
38 let setup = ReaderFilledSetup::new(RandomState::default());
39 group.bench_function("resolve", |b| {
40 b.iter_batched(
41 || setup.filled_rodeo(),
42 |rodeo| {
43 for key in setup.keys() {
44 black_box(rodeo.resolve(key));
45 }
46 },
47 BatchSize::PerIteration,
48 )
49 });
50
51 let setup = ReaderFilledSetup::new(RandomState::default());
52 group.bench_function("try_resolve", |b| {
53 b.iter_batched(
54 || setup.filled_rodeo(),
55 |rodeo| {
56 for key in setup.keys() {
57 black_box(rodeo.try_resolve(key).unwrap());
58 }
59 },
60 BatchSize::PerIteration,
61 )
62 });
63
64 let setup = ReaderFilledSetup::new(RandomState::default());
65 group.bench_function("resolve_unchecked", |b| {
66 b.iter_batched(
67 || setup.filled_rodeo(),
68 |rodeo| {
69 for key in setup.keys() {
70 unsafe { black_box(rodeo.resolve_unchecked(key)) };
71 }
72 },
73 BatchSize::PerIteration,
74 )
75 });
76
77 group.finish();
78 }
79
reader_std_threaded(c: &mut Criterion)80 fn reader_std_threaded(c: &mut Criterion) {
81 use std::collections::hash_map::RandomState;
82
83 let mut group = c.benchmark_group("RodeoReader 24 Thread (std)");
84 group.throughput(Throughput::Bytes(INPUT.len() as u64));
85
86 group.bench_function("get", |b| {
87 b.iter_custom(|iters| {
88 setup::run_reader_filled(
89 |reader, _| {
90 for &line in setup::bench_lines() {
91 black_box(reader.get(line));
92 }
93 },
94 RandomState::new(),
95 NUM_THREADS,
96 iters,
97 )
98 })
99 });
100
101 group.bench_function("resolve", |b| {
102 b.iter_custom(|iters| {
103 setup::run_reader_filled(
104 |reader, keys| {
105 for key in keys {
106 black_box(reader.resolve(key));
107 }
108 },
109 RandomState::new(),
110 NUM_THREADS,
111 iters,
112 )
113 })
114 });
115
116 group.bench_function("try_resolve", |b| {
117 b.iter_custom(|iters| {
118 setup::run_reader_filled(
119 |reader, keys| {
120 for key in keys {
121 black_box(reader.try_resolve(key).unwrap());
122 }
123 },
124 RandomState::new(),
125 NUM_THREADS,
126 iters,
127 )
128 })
129 });
130
131 group.bench_function("resolve_unchecked", |b| {
132 b.iter_custom(|iters| {
133 setup::run_reader_filled(
134 |reader, keys| {
135 for key in keys {
136 unsafe { black_box(reader.resolve_unchecked(key)) };
137 }
138 },
139 RandomState::new(),
140 NUM_THREADS,
141 iters,
142 )
143 })
144 });
145
146 group.finish();
147 }
148
reader_ahash(c: &mut Criterion)149 fn reader_ahash(c: &mut Criterion) {
150 use ahash::RandomState;
151
152 let mut group = c.benchmark_group("RodeoReader 1 Thread (ahash)");
153 group.throughput(Throughput::Bytes(INPUT.len() as u64));
154
155 let setup = ReaderEmptySetup::new(RandomState::default());
156 group.bench_function("get (empty)", |b| {
157 b.iter_batched(
158 || setup.empty_rodeo(),
159 |rodeo| {
160 for &line in setup.lines() {
161 black_box(rodeo.get(line));
162 }
163 },
164 BatchSize::PerIteration,
165 )
166 });
167
168 let setup = ReaderFilledSetup::new(RandomState::default());
169 group.bench_function("get (filled)", |b| {
170 b.iter_batched(
171 || setup.filled_rodeo(),
172 |rodeo| {
173 for &line in setup.lines() {
174 black_box(rodeo.get(line));
175 }
176 },
177 BatchSize::PerIteration,
178 )
179 });
180
181 let setup = ReaderFilledSetup::new(RandomState::default());
182 group.bench_function("resolve", |b| {
183 b.iter_batched(
184 || setup.filled_rodeo(),
185 |rodeo| {
186 for key in setup.keys() {
187 black_box(rodeo.resolve(key));
188 }
189 },
190 BatchSize::PerIteration,
191 )
192 });
193
194 let setup = ReaderFilledSetup::new(RandomState::default());
195 group.bench_function("try_resolve", |b| {
196 b.iter_batched(
197 || setup.filled_rodeo(),
198 |rodeo| {
199 for key in setup.keys() {
200 black_box(rodeo.try_resolve(key).unwrap());
201 }
202 },
203 BatchSize::PerIteration,
204 )
205 });
206
207 let setup = ReaderFilledSetup::new(RandomState::default());
208 group.bench_function("resolve_unchecked", |b| {
209 b.iter_batched(
210 || setup.filled_rodeo(),
211 |rodeo| {
212 for key in setup.keys() {
213 unsafe { black_box(rodeo.resolve_unchecked(key)) };
214 }
215 },
216 BatchSize::PerIteration,
217 )
218 });
219
220 group.finish();
221 }
222
reader_ahash_threaded(c: &mut Criterion)223 fn reader_ahash_threaded(c: &mut Criterion) {
224 use ahash::RandomState;
225
226 let mut group = c.benchmark_group("RodeoReader 24 Thread (ahash)");
227 group.throughput(Throughput::Bytes(INPUT.len() as u64));
228
229 group.bench_function("get", |b| {
230 b.iter_custom(|iters| {
231 setup::run_reader_filled(
232 |reader, _| {
233 for &line in setup::bench_lines() {
234 black_box(reader.get(line));
235 }
236 },
237 RandomState::new(),
238 NUM_THREADS,
239 iters,
240 )
241 })
242 });
243
244 group.bench_function("resolve", |b| {
245 b.iter_custom(|iters| {
246 setup::run_reader_filled(
247 |reader, keys| {
248 for key in keys {
249 black_box(reader.resolve(key));
250 }
251 },
252 RandomState::new(),
253 NUM_THREADS,
254 iters,
255 )
256 })
257 });
258
259 group.bench_function("try_resolve", |b| {
260 b.iter_custom(|iters| {
261 setup::run_reader_filled(
262 |reader, keys| {
263 for key in keys {
264 black_box(reader.try_resolve(key).unwrap());
265 }
266 },
267 RandomState::new(),
268 NUM_THREADS,
269 iters,
270 )
271 })
272 });
273
274 group.bench_function("resolve_unchecked", |b| {
275 b.iter_custom(|iters| {
276 setup::run_reader_filled(
277 |reader, keys| {
278 for key in keys {
279 unsafe { black_box(reader.resolve_unchecked(key)) };
280 }
281 },
282 RandomState::new(),
283 NUM_THREADS,
284 iters,
285 )
286 })
287 });
288
289 group.finish();
290 }
291
reader_fxhash(c: &mut Criterion)292 fn reader_fxhash(c: &mut Criterion) {
293 use fxhash::FxBuildHasher;
294
295 let mut group = c.benchmark_group("RodeoReader 1 Thread (fxhash)");
296 group.throughput(Throughput::Bytes(INPUT.len() as u64));
297
298 let setup = ReaderEmptySetup::new(FxBuildHasher::default());
299 group.bench_function("get (empty)", |b| {
300 b.iter_batched(
301 || setup.empty_rodeo(),
302 |rodeo| {
303 for &line in setup.lines() {
304 black_box(rodeo.get(line));
305 }
306 },
307 BatchSize::PerIteration,
308 )
309 });
310
311 let setup = ReaderFilledSetup::new(FxBuildHasher::default());
312 group.bench_function("get (filled)", |b| {
313 b.iter_batched(
314 || setup.filled_rodeo(),
315 |rodeo| {
316 for &line in setup.lines() {
317 black_box(rodeo.get(line));
318 }
319 },
320 BatchSize::PerIteration,
321 )
322 });
323
324 let setup = ReaderFilledSetup::new(FxBuildHasher::default());
325 group.bench_function("resolve", |b| {
326 b.iter_batched(
327 || setup.filled_rodeo(),
328 |rodeo| {
329 for key in setup.keys() {
330 black_box(rodeo.resolve(key));
331 }
332 },
333 BatchSize::PerIteration,
334 )
335 });
336
337 let setup = ReaderFilledSetup::new(FxBuildHasher::default());
338 group.bench_function("try_resolve", |b| {
339 b.iter_batched(
340 || setup.filled_rodeo(),
341 |rodeo| {
342 for key in setup.keys() {
343 black_box(rodeo.try_resolve(key).unwrap());
344 }
345 },
346 BatchSize::PerIteration,
347 )
348 });
349
350 let setup = ReaderFilledSetup::new(FxBuildHasher::default());
351 group.bench_function("resolve_unchecked", |b| {
352 b.iter_batched(
353 || setup.filled_rodeo(),
354 |rodeo| {
355 for key in setup.keys() {
356 unsafe { black_box(rodeo.resolve_unchecked(key)) };
357 }
358 },
359 BatchSize::PerIteration,
360 )
361 });
362
363 group.finish();
364 }
365
reader_fxhash_threaded(c: &mut Criterion)366 fn reader_fxhash_threaded(c: &mut Criterion) {
367 use fxhash::FxBuildHasher;
368
369 let mut group = c.benchmark_group("RodeoReader 24 Thread (fxhash)");
370 group.throughput(Throughput::Bytes(INPUT.len() as u64));
371
372 group.bench_function("get", |b| {
373 b.iter_custom(|iters| {
374 setup::run_reader_filled(
375 |reader, _| {
376 for &line in setup::bench_lines() {
377 black_box(reader.get(line));
378 }
379 },
380 FxBuildHasher::default(),
381 NUM_THREADS,
382 iters,
383 )
384 })
385 });
386
387 group.bench_function("resolve", |b| {
388 b.iter_custom(|iters| {
389 setup::run_reader_filled(
390 |reader, keys| {
391 for key in keys {
392 black_box(reader.resolve(key));
393 }
394 },
395 FxBuildHasher::default(),
396 NUM_THREADS,
397 iters,
398 )
399 })
400 });
401
402 group.bench_function("try_resolve", |b| {
403 b.iter_custom(|iters| {
404 setup::run_reader_filled(
405 |reader, keys| {
406 for key in keys {
407 black_box(reader.try_resolve(key).unwrap());
408 }
409 },
410 FxBuildHasher::default(),
411 NUM_THREADS,
412 iters,
413 )
414 })
415 });
416
417 group.bench_function("resolve_unchecked", |b| {
418 b.iter_custom(|iters| {
419 setup::run_reader_filled(
420 |reader, keys| {
421 for key in keys {
422 unsafe { black_box(reader.resolve_unchecked(key)) };
423 }
424 },
425 FxBuildHasher::default(),
426 NUM_THREADS,
427 iters,
428 )
429 })
430 });
431
432 group.finish();
433 }
434
435 criterion_group!(
436 benches,
437 reader_std,
438 reader_ahash,
439 reader_fxhash,
440 reader_std_threaded,
441 reader_ahash_threaded,
442 reader_fxhash_threaded
443 );
444 criterion_main!(benches);
445