1 mod setup;
2
3 use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion, Throughput};
4 use setup::{RodeoEmptySetup, RodeoFilledSetup, INPUT};
5
rodeo_std(c: &mut Criterion)6 fn rodeo_std(c: &mut Criterion) {
7 use std::collections::hash_map::RandomState;
8
9 let mut group = c.benchmark_group("Rodeo (std)");
10 group.throughput(Throughput::Bytes(INPUT.len() as u64));
11
12 let setup = RodeoEmptySetup::new(RandomState::default());
13 group.bench_function("get_or_intern (empty)", |b| {
14 b.iter_batched(
15 || setup.empty_rodeo(),
16 |mut rodeo| {
17 for &line in setup.lines() {
18 black_box(rodeo.get_or_intern(line));
19 }
20 },
21 BatchSize::PerIteration,
22 )
23 });
24
25 let mut setup = RodeoFilledSetup::new(RandomState::default());
26 group.bench_function("get_or_intern (filled)", |b| {
27 b.iter(|| {
28 for &line in setup.lines() {
29 black_box(setup.filled_rodeo_mut().get_or_intern(line));
30 }
31 })
32 });
33
34 let setup = RodeoEmptySetup::new(RandomState::default());
35 group.bench_function("try_get_or_intern (empty)", |b| {
36 b.iter_batched(
37 || setup.empty_rodeo(),
38 |mut rodeo| {
39 for &line in setup.lines() {
40 black_box(rodeo.try_get_or_intern(line).unwrap());
41 }
42 },
43 BatchSize::PerIteration,
44 )
45 });
46
47 let mut setup = RodeoFilledSetup::new(RandomState::default());
48 group.bench_function("try_get_or_intern (filled)", |b| {
49 b.iter(|| {
50 for &line in setup.lines() {
51 black_box(setup.filled_rodeo_mut().try_get_or_intern(line).unwrap());
52 }
53 })
54 });
55
56 let setup = RodeoEmptySetup::new(RandomState::default());
57 group.bench_function("get (empty)", |b| {
58 b.iter_batched(
59 || setup.empty_rodeo(),
60 |rodeo| {
61 for &line in setup.lines() {
62 black_box(rodeo.get(line));
63 }
64 },
65 BatchSize::PerIteration,
66 )
67 });
68
69 let setup = RodeoFilledSetup::new(RandomState::default());
70 group.bench_function("get (filled)", |b| {
71 b.iter_batched(
72 || setup.filled_rodeo(),
73 |rodeo| {
74 for &line in setup.lines() {
75 black_box(rodeo.get(line));
76 }
77 },
78 BatchSize::PerIteration,
79 )
80 });
81
82 let setup = RodeoFilledSetup::new(RandomState::default());
83 group.bench_function("resolve", |b| {
84 b.iter_batched(
85 || setup.filled_rodeo(),
86 |rodeo| {
87 for key in setup.keys() {
88 black_box(rodeo.resolve(key));
89 }
90 },
91 BatchSize::PerIteration,
92 )
93 });
94
95 let setup = RodeoFilledSetup::new(RandomState::default());
96 group.bench_function("try_resolve", |b| {
97 b.iter_batched(
98 || setup.filled_rodeo(),
99 |rodeo| {
100 for key in setup.keys() {
101 black_box(rodeo.try_resolve(key).unwrap());
102 }
103 },
104 BatchSize::PerIteration,
105 )
106 });
107
108 let setup = RodeoFilledSetup::new(RandomState::default());
109 group.bench_function("resolve_unchecked", |b| {
110 b.iter_batched(
111 || setup.filled_rodeo(),
112 |rodeo| {
113 for key in setup.keys() {
114 unsafe { black_box(rodeo.resolve_unchecked(key)) };
115 }
116 },
117 BatchSize::PerIteration,
118 )
119 });
120
121 group.finish();
122 }
123
rodeo_ahash(c: &mut Criterion)124 fn rodeo_ahash(c: &mut Criterion) {
125 use ahash::RandomState;
126
127 let mut group = c.benchmark_group("Rodeo (ahash)");
128 group.throughput(Throughput::Bytes(INPUT.len() as u64));
129
130 let setup = RodeoEmptySetup::new(RandomState::default());
131 group.bench_function("get_or_intern (empty)", |b| {
132 b.iter_batched(
133 || setup.empty_rodeo(),
134 |mut rodeo| {
135 for &line in setup.lines() {
136 black_box(rodeo.get_or_intern(line));
137 }
138 },
139 BatchSize::PerIteration,
140 )
141 });
142
143 let mut setup = RodeoFilledSetup::new(RandomState::default());
144 group.bench_function("get_or_intern (filled)", |b| {
145 b.iter(|| {
146 for &line in setup.lines() {
147 black_box(setup.filled_rodeo_mut().get_or_intern(line));
148 }
149 })
150 });
151
152 let setup = RodeoEmptySetup::new(RandomState::default());
153 group.bench_function("try_get_or_intern (empty)", |b| {
154 b.iter_batched(
155 || setup.empty_rodeo(),
156 |mut rodeo| {
157 for &line in setup.lines() {
158 black_box(rodeo.try_get_or_intern(line).unwrap());
159 }
160 },
161 BatchSize::PerIteration,
162 )
163 });
164
165 let mut setup = RodeoFilledSetup::new(RandomState::default());
166 group.bench_function("try_get_or_intern (filled)", |b| {
167 b.iter(|| {
168 for &line in setup.lines() {
169 black_box(setup.filled_rodeo_mut().try_get_or_intern(line).unwrap());
170 }
171 })
172 });
173
174 let setup = RodeoEmptySetup::new(RandomState::default());
175 group.bench_function("get (empty)", |b| {
176 b.iter_batched(
177 || setup.empty_rodeo(),
178 |rodeo| {
179 for &line in setup.lines() {
180 black_box(rodeo.get(line));
181 }
182 },
183 BatchSize::PerIteration,
184 )
185 });
186
187 let setup = RodeoFilledSetup::new(RandomState::default());
188 group.bench_function("get (filled)", |b| {
189 b.iter_batched(
190 || setup.filled_rodeo(),
191 |rodeo| {
192 for &line in setup.lines() {
193 black_box(rodeo.get(line));
194 }
195 },
196 BatchSize::PerIteration,
197 )
198 });
199
200 let setup = RodeoFilledSetup::new(RandomState::default());
201 group.bench_function("resolve", |b| {
202 b.iter_batched(
203 || setup.filled_rodeo(),
204 |rodeo| {
205 for key in setup.keys() {
206 black_box(rodeo.resolve(key));
207 }
208 },
209 BatchSize::PerIteration,
210 )
211 });
212
213 let setup = RodeoFilledSetup::new(RandomState::default());
214 group.bench_function("try_resolve", |b| {
215 b.iter_batched(
216 || setup.filled_rodeo(),
217 |rodeo| {
218 for key in setup.keys() {
219 black_box(rodeo.try_resolve(key).unwrap());
220 }
221 },
222 BatchSize::PerIteration,
223 )
224 });
225
226 let setup = RodeoFilledSetup::new(RandomState::default());
227 group.bench_function("resolve_unchecked", |b| {
228 b.iter_batched(
229 || setup.filled_rodeo(),
230 |rodeo| {
231 for key in setup.keys() {
232 unsafe { black_box(rodeo.resolve_unchecked(key)) };
233 }
234 },
235 BatchSize::PerIteration,
236 )
237 });
238
239 group.finish();
240 }
241
rodeo_fxhash(c: &mut Criterion)242 fn rodeo_fxhash(c: &mut Criterion) {
243 use fxhash::FxBuildHasher;
244
245 let mut group = c.benchmark_group("Rodeo (fxhash)");
246 group.throughput(Throughput::Bytes(INPUT.len() as u64));
247
248 let setup = RodeoEmptySetup::new(FxBuildHasher::default());
249 group.bench_function("get_or_intern (empty)", |b| {
250 b.iter_batched(
251 || setup.empty_rodeo(),
252 |mut rodeo| {
253 for &line in setup.lines() {
254 black_box(rodeo.get_or_intern(line));
255 }
256 },
257 BatchSize::PerIteration,
258 )
259 });
260
261 let mut setup = RodeoFilledSetup::new(FxBuildHasher::default());
262 group.bench_function("get_or_intern (filled)", |b| {
263 b.iter(|| {
264 for &line in setup.lines() {
265 black_box(setup.filled_rodeo_mut().get_or_intern(line));
266 }
267 })
268 });
269
270 let setup = RodeoEmptySetup::new(FxBuildHasher::default());
271 group.bench_function("try_get_or_intern (empty)", |b| {
272 b.iter_batched(
273 || setup.empty_rodeo(),
274 |mut rodeo| {
275 for &line in setup.lines() {
276 black_box(rodeo.try_get_or_intern(line).unwrap());
277 }
278 },
279 BatchSize::PerIteration,
280 )
281 });
282
283 let mut setup = RodeoFilledSetup::new(FxBuildHasher::default());
284 group.bench_function("try_get_or_intern (filled)", |b| {
285 b.iter(|| {
286 for &line in setup.lines() {
287 black_box(setup.filled_rodeo_mut().try_get_or_intern(line).unwrap());
288 }
289 })
290 });
291
292 let setup = RodeoEmptySetup::new(FxBuildHasher::default());
293 group.bench_function("get (empty)", |b| {
294 b.iter_batched(
295 || setup.empty_rodeo(),
296 |rodeo| {
297 for &line in setup.lines() {
298 black_box(rodeo.get(line));
299 }
300 },
301 BatchSize::PerIteration,
302 )
303 });
304
305 let setup = RodeoFilledSetup::new(FxBuildHasher::default());
306 group.bench_function("get (filled)", |b| {
307 b.iter_batched(
308 || setup.filled_rodeo(),
309 |rodeo| {
310 for &line in setup.lines() {
311 black_box(rodeo.get(line));
312 }
313 },
314 BatchSize::PerIteration,
315 )
316 });
317
318 let setup = RodeoFilledSetup::new(FxBuildHasher::default());
319 group.bench_function("resolve", |b| {
320 b.iter_batched(
321 || setup.filled_rodeo(),
322 |rodeo| {
323 for key in setup.keys() {
324 black_box(rodeo.resolve(key));
325 }
326 },
327 BatchSize::PerIteration,
328 )
329 });
330
331 let setup = RodeoFilledSetup::new(FxBuildHasher::default());
332 group.bench_function("try_resolve", |b| {
333 b.iter_batched(
334 || setup.filled_rodeo(),
335 |rodeo| {
336 for key in setup.keys() {
337 black_box(rodeo.try_resolve(key).unwrap());
338 }
339 },
340 BatchSize::PerIteration,
341 )
342 });
343
344 let setup = RodeoFilledSetup::new(FxBuildHasher::default());
345 group.bench_function("resolve_unchecked", |b| {
346 b.iter_batched(
347 || setup.filled_rodeo(),
348 |rodeo| {
349 for key in setup.keys() {
350 unsafe { black_box(rodeo.resolve_unchecked(key)) };
351 }
352 },
353 BatchSize::PerIteration,
354 )
355 });
356
357 group.finish();
358 }
359
360 criterion_group!(benches, rodeo_std, rodeo_ahash, rodeo_fxhash);
361 criterion_main!(benches);
362