1 use criterion::{Bencher, Criterion};
2
3 use crate::{
4 define,
5 memchr::{
6 imp::{
7 fallback1_count, fallback2_count, fallback3_count, memchr1_count,
8 memchr2_count, memchr3_count, memrchr1_count, memrchr2_count,
9 memrchr3_count, naive1_count, naive2_count, naive3_count,
10 },
11 inputs::{Input, Search1, Search2, Search3, EMPTY, HUGE, SMALL, TINY},
12 },
13 };
14
15 #[path = "../../../src/memchr/c.rs"]
16 mod c;
17 #[allow(dead_code)]
18 #[path = "../../../src/memchr/fallback.rs"]
19 mod fallback;
20 mod imp;
21 mod inputs;
22 #[path = "../../../src/memchr/naive.rs"]
23 mod naive;
24
all(c: &mut Criterion)25 pub fn all(c: &mut Criterion) {
26 define_memchr_input1(c, "memchr1/krate/huge", HUGE, move |search, b| {
27 b.iter(|| {
28 assert_eq!(
29 search.byte1.count,
30 memchr1_count(search.byte1.byte, search.corpus),
31 );
32 });
33 });
34 define_memchr_input1(c, "memchr1/krate/small", SMALL, move |search, b| {
35 b.iter(|| {
36 assert_eq!(
37 search.byte1.count,
38 memchr1_count(search.byte1.byte, search.corpus),
39 );
40 });
41 });
42 define_memchr_input1(c, "memchr1/krate/tiny", TINY, move |search, b| {
43 b.iter(|| {
44 assert_eq!(
45 search.byte1.count,
46 memchr1_count(search.byte1.byte, search.corpus),
47 );
48 });
49 });
50 define_memchr_input1(c, "memchr1/krate/empty", EMPTY, move |search, b| {
51 b.iter(|| {
52 assert_eq!(
53 search.byte1.count,
54 memchr1_count(search.byte1.byte, search.corpus),
55 );
56 });
57 });
58
59 define_memchr_input1(c, "memchr1/libc/huge", HUGE, move |search, b| {
60 b.iter(|| {
61 assert_eq!(
62 search.byte1.count,
63 imp::memchr1_libc_count(search.byte1.byte, search.corpus),
64 );
65 });
66 });
67 define_memchr_input1(c, "memchr1/libc/small", SMALL, move |search, b| {
68 b.iter(|| {
69 assert_eq!(
70 search.byte1.count,
71 imp::memchr1_libc_count(search.byte1.byte, search.corpus),
72 );
73 });
74 });
75 define_memchr_input1(c, "memchr1/libc/tiny", TINY, move |search, b| {
76 b.iter(|| {
77 assert_eq!(
78 search.byte1.count,
79 imp::memchr1_libc_count(search.byte1.byte, search.corpus),
80 );
81 });
82 });
83 define_memchr_input1(c, "memchr1/libc/empty", EMPTY, move |search, b| {
84 b.iter(|| {
85 assert_eq!(
86 search.byte1.count,
87 imp::memchr1_libc_count(search.byte1.byte, search.corpus),
88 );
89 });
90 });
91
92 define_memchr_input1(
93 c,
94 "memchr1/fallback/huge",
95 HUGE,
96 move |search, b| {
97 b.iter(|| {
98 assert_eq!(
99 search.byte1.count,
100 fallback1_count(search.byte1.byte, search.corpus),
101 );
102 });
103 },
104 );
105 define_memchr_input1(
106 c,
107 "memchr1/fallback/small",
108 SMALL,
109 move |search, b| {
110 b.iter(|| {
111 assert_eq!(
112 search.byte1.count,
113 fallback1_count(search.byte1.byte, search.corpus),
114 );
115 });
116 },
117 );
118 define_memchr_input1(
119 c,
120 "memchr1/fallback/tiny",
121 TINY,
122 move |search, b| {
123 b.iter(|| {
124 assert_eq!(
125 search.byte1.count,
126 fallback1_count(search.byte1.byte, search.corpus),
127 );
128 });
129 },
130 );
131 define_memchr_input1(
132 c,
133 "memchr1/fallback/empty",
134 EMPTY,
135 move |search, b| {
136 b.iter(|| {
137 assert_eq!(
138 search.byte1.count,
139 fallback1_count(search.byte1.byte, search.corpus),
140 );
141 });
142 },
143 );
144
145 define_memchr_input1(c, "memchr1/naive/huge", HUGE, move |search, b| {
146 b.iter(|| {
147 assert_eq!(
148 search.byte1.count,
149 naive1_count(search.byte1.byte, search.corpus),
150 );
151 });
152 });
153 define_memchr_input1(c, "memchr1/naive/small", SMALL, move |search, b| {
154 b.iter(|| {
155 assert_eq!(
156 search.byte1.count,
157 naive1_count(search.byte1.byte, search.corpus),
158 );
159 });
160 });
161 define_memchr_input1(c, "memchr1/naive/tiny", TINY, move |search, b| {
162 b.iter(|| {
163 assert_eq!(
164 search.byte1.count,
165 naive1_count(search.byte1.byte, search.corpus),
166 );
167 });
168 });
169 define_memchr_input1(c, "memchr1/naive/empty", EMPTY, move |search, b| {
170 b.iter(|| {
171 assert_eq!(
172 search.byte1.count,
173 naive1_count(search.byte1.byte, search.corpus),
174 );
175 });
176 });
177
178 define_memchr_input2(c, "memchr2/krate/huge", HUGE, move |search, b| {
179 b.iter(|| {
180 assert_eq!(
181 search.byte1.count + search.byte2.count,
182 memchr2_count(
183 search.byte1.byte,
184 search.byte2.byte,
185 search.corpus,
186 )
187 );
188 });
189 });
190 define_memchr_input2(c, "memchr2/krate/small", SMALL, move |search, b| {
191 b.iter(|| {
192 assert_eq!(
193 search.byte1.count + search.byte2.count,
194 memchr2_count(
195 search.byte1.byte,
196 search.byte2.byte,
197 search.corpus,
198 )
199 );
200 });
201 });
202 define_memchr_input2(c, "memchr2/krate/tiny", TINY, move |search, b| {
203 b.iter(|| {
204 assert_eq!(
205 search.byte1.count + search.byte2.count,
206 memchr2_count(
207 search.byte1.byte,
208 search.byte2.byte,
209 search.corpus,
210 )
211 );
212 });
213 });
214 define_memchr_input2(c, "memchr2/krate/empty", EMPTY, move |search, b| {
215 b.iter(|| {
216 assert_eq!(
217 search.byte1.count + search.byte2.count,
218 memchr2_count(
219 search.byte1.byte,
220 search.byte2.byte,
221 search.corpus,
222 )
223 );
224 });
225 });
226
227 define_memchr_input2(
228 c,
229 "memchr2/fallback/huge",
230 HUGE,
231 move |search, b| {
232 b.iter(|| {
233 assert_eq!(
234 search.byte1.count + search.byte2.count,
235 fallback2_count(
236 search.byte1.byte,
237 search.byte2.byte,
238 search.corpus,
239 )
240 );
241 });
242 },
243 );
244 define_memchr_input2(
245 c,
246 "memchr2/fallback/small",
247 SMALL,
248 move |search, b| {
249 b.iter(|| {
250 assert_eq!(
251 search.byte1.count + search.byte2.count,
252 fallback2_count(
253 search.byte1.byte,
254 search.byte2.byte,
255 search.corpus,
256 )
257 );
258 });
259 },
260 );
261 define_memchr_input2(
262 c,
263 "memchr2/fallback/tiny",
264 TINY,
265 move |search, b| {
266 b.iter(|| {
267 assert_eq!(
268 search.byte1.count + search.byte2.count,
269 fallback2_count(
270 search.byte1.byte,
271 search.byte2.byte,
272 search.corpus,
273 )
274 );
275 });
276 },
277 );
278 define_memchr_input2(
279 c,
280 "memchr2/fallback/empty",
281 EMPTY,
282 move |search, b| {
283 b.iter(|| {
284 assert_eq!(
285 search.byte1.count + search.byte2.count,
286 fallback2_count(
287 search.byte1.byte,
288 search.byte2.byte,
289 search.corpus,
290 )
291 );
292 });
293 },
294 );
295
296 define_memchr_input2(c, "memchr2/naive/huge", HUGE, move |search, b| {
297 b.iter(|| {
298 assert_eq!(
299 search.byte1.count + search.byte2.count,
300 naive2_count(
301 search.byte1.byte,
302 search.byte2.byte,
303 search.corpus,
304 )
305 );
306 });
307 });
308 define_memchr_input2(c, "memchr2/naive/small", SMALL, move |search, b| {
309 b.iter(|| {
310 assert_eq!(
311 search.byte1.count + search.byte2.count,
312 naive2_count(
313 search.byte1.byte,
314 search.byte2.byte,
315 search.corpus,
316 )
317 );
318 });
319 });
320 define_memchr_input2(c, "memchr2/naive/tiny", TINY, move |search, b| {
321 b.iter(|| {
322 assert_eq!(
323 search.byte1.count + search.byte2.count,
324 naive2_count(
325 search.byte1.byte,
326 search.byte2.byte,
327 search.corpus,
328 )
329 );
330 });
331 });
332 define_memchr_input2(c, "memchr2/naive/empty", EMPTY, move |search, b| {
333 b.iter(|| {
334 assert_eq!(
335 search.byte1.count + search.byte2.count,
336 naive2_count(
337 search.byte1.byte,
338 search.byte2.byte,
339 search.corpus,
340 )
341 );
342 });
343 });
344
345 define_memchr_input3(c, "memchr3/krate/huge", HUGE, move |search, b| {
346 b.iter(|| {
347 assert_eq!(
348 search.byte1.count + search.byte2.count + search.byte3.count,
349 memchr3_count(
350 search.byte1.byte,
351 search.byte2.byte,
352 search.byte3.byte,
353 search.corpus,
354 )
355 );
356 });
357 });
358 define_memchr_input3(c, "memchr3/krate/small", SMALL, move |search, b| {
359 b.iter(|| {
360 assert_eq!(
361 search.byte1.count + search.byte2.count + search.byte3.count,
362 memchr3_count(
363 search.byte1.byte,
364 search.byte2.byte,
365 search.byte3.byte,
366 search.corpus,
367 )
368 );
369 });
370 });
371 define_memchr_input3(c, "memchr3/krate/tiny", TINY, move |search, b| {
372 b.iter(|| {
373 assert_eq!(
374 search.byte1.count + search.byte2.count + search.byte3.count,
375 memchr3_count(
376 search.byte1.byte,
377 search.byte2.byte,
378 search.byte3.byte,
379 search.corpus,
380 )
381 );
382 });
383 });
384 define_memchr_input3(c, "memchr3/krate/empty", EMPTY, move |search, b| {
385 b.iter(|| {
386 assert_eq!(
387 search.byte1.count + search.byte2.count + search.byte3.count,
388 memchr3_count(
389 search.byte1.byte,
390 search.byte2.byte,
391 search.byte3.byte,
392 search.corpus,
393 )
394 );
395 });
396 });
397
398 define_memchr_input3(
399 c,
400 "memchr3/fallback/huge",
401 HUGE,
402 move |search, b| {
403 b.iter(|| {
404 assert_eq!(
405 search.byte1.count
406 + search.byte2.count
407 + search.byte3.count,
408 fallback3_count(
409 search.byte1.byte,
410 search.byte2.byte,
411 search.byte3.byte,
412 search.corpus,
413 )
414 );
415 });
416 },
417 );
418 define_memchr_input3(
419 c,
420 "memchr3/fallback/small",
421 SMALL,
422 move |search, b| {
423 b.iter(|| {
424 assert_eq!(
425 search.byte1.count
426 + search.byte2.count
427 + search.byte3.count,
428 fallback3_count(
429 search.byte1.byte,
430 search.byte2.byte,
431 search.byte3.byte,
432 search.corpus,
433 )
434 );
435 });
436 },
437 );
438 define_memchr_input3(
439 c,
440 "memchr3/fallback/tiny",
441 TINY,
442 move |search, b| {
443 b.iter(|| {
444 assert_eq!(
445 search.byte1.count
446 + search.byte2.count
447 + search.byte3.count,
448 fallback3_count(
449 search.byte1.byte,
450 search.byte2.byte,
451 search.byte3.byte,
452 search.corpus,
453 )
454 );
455 });
456 },
457 );
458 define_memchr_input3(
459 c,
460 "memchr3/fallback/empty",
461 EMPTY,
462 move |search, b| {
463 b.iter(|| {
464 assert_eq!(
465 search.byte1.count
466 + search.byte2.count
467 + search.byte3.count,
468 fallback3_count(
469 search.byte1.byte,
470 search.byte2.byte,
471 search.byte3.byte,
472 search.corpus,
473 )
474 );
475 });
476 },
477 );
478
479 define_memchr_input3(c, "memchr3/naive/huge", HUGE, move |search, b| {
480 b.iter(|| {
481 assert_eq!(
482 search.byte1.count + search.byte2.count + search.byte3.count,
483 naive3_count(
484 search.byte1.byte,
485 search.byte2.byte,
486 search.byte3.byte,
487 search.corpus,
488 )
489 );
490 });
491 });
492 define_memchr_input3(c, "memchr3/naive/small", SMALL, move |search, b| {
493 b.iter(|| {
494 assert_eq!(
495 search.byte1.count + search.byte2.count + search.byte3.count,
496 naive3_count(
497 search.byte1.byte,
498 search.byte2.byte,
499 search.byte3.byte,
500 search.corpus,
501 )
502 );
503 });
504 });
505 define_memchr_input3(c, "memchr3/naive/tiny", TINY, move |search, b| {
506 b.iter(|| {
507 assert_eq!(
508 search.byte1.count + search.byte2.count + search.byte3.count,
509 naive3_count(
510 search.byte1.byte,
511 search.byte2.byte,
512 search.byte3.byte,
513 search.corpus,
514 )
515 );
516 });
517 });
518 define_memchr_input3(c, "memchr3/naive/empty", EMPTY, move |search, b| {
519 b.iter(|| {
520 assert_eq!(
521 search.byte1.count + search.byte2.count + search.byte3.count,
522 naive3_count(
523 search.byte1.byte,
524 search.byte2.byte,
525 search.byte3.byte,
526 search.corpus,
527 )
528 );
529 });
530 });
531
532 define_memchr_input1(c, "memrchr1/krate/huge", HUGE, move |search, b| {
533 b.iter(|| {
534 assert_eq!(
535 search.byte1.count,
536 memrchr1_count(search.byte1.byte, search.corpus)
537 );
538 });
539 });
540 define_memchr_input1(
541 c,
542 "memrchr1/krate/small",
543 SMALL,
544 move |search, b| {
545 b.iter(|| {
546 assert_eq!(
547 search.byte1.count,
548 memrchr1_count(search.byte1.byte, search.corpus)
549 );
550 });
551 },
552 );
553 define_memchr_input1(c, "memrchr1/krate/tiny", TINY, move |search, b| {
554 b.iter(|| {
555 assert_eq!(
556 search.byte1.count,
557 memrchr1_count(search.byte1.byte, search.corpus)
558 );
559 });
560 });
561 define_memchr_input1(
562 c,
563 "memrchr1/krate/empty",
564 EMPTY,
565 move |search, b| {
566 b.iter(|| {
567 assert_eq!(
568 search.byte1.count,
569 memrchr1_count(search.byte1.byte, search.corpus)
570 );
571 });
572 },
573 );
574
575 #[cfg(all(target_os = "linux"))]
576 {
577 define_memchr_input1(
578 c,
579 "memrchr1/libc/huge",
580 HUGE,
581 move |search, b| {
582 b.iter(|| {
583 assert_eq!(
584 search.byte1.count,
585 imp::memrchr1_libc_count(
586 search.byte1.byte,
587 search.corpus
588 )
589 );
590 });
591 },
592 );
593 define_memchr_input1(
594 c,
595 "memrchr1/libc/small",
596 SMALL,
597 move |search, b| {
598 b.iter(|| {
599 assert_eq!(
600 search.byte1.count,
601 imp::memrchr1_libc_count(
602 search.byte1.byte,
603 search.corpus
604 )
605 );
606 });
607 },
608 );
609 define_memchr_input1(
610 c,
611 "memrchr1/libc/tiny",
612 TINY,
613 move |search, b| {
614 b.iter(|| {
615 assert_eq!(
616 search.byte1.count,
617 imp::memrchr1_libc_count(
618 search.byte1.byte,
619 search.corpus
620 )
621 );
622 });
623 },
624 );
625 define_memchr_input1(
626 c,
627 "memrchr1/libc/empty",
628 EMPTY,
629 move |search, b| {
630 b.iter(|| {
631 assert_eq!(
632 search.byte1.count,
633 imp::memrchr1_libc_count(
634 search.byte1.byte,
635 search.corpus
636 )
637 );
638 });
639 },
640 );
641 }
642
643 define_memchr_input2(c, "memrchr2/krate/huge", HUGE, move |search, b| {
644 b.iter(|| {
645 assert_eq!(
646 search.byte1.count + search.byte2.count,
647 memrchr2_count(
648 search.byte1.byte,
649 search.byte2.byte,
650 search.corpus,
651 )
652 );
653 });
654 });
655 define_memchr_input2(
656 c,
657 "memrchr2/krate/small",
658 SMALL,
659 move |search, b| {
660 b.iter(|| {
661 assert_eq!(
662 search.byte1.count + search.byte2.count,
663 memrchr2_count(
664 search.byte1.byte,
665 search.byte2.byte,
666 search.corpus,
667 )
668 );
669 });
670 },
671 );
672 define_memchr_input2(c, "memrchr2/krate/tiny", TINY, move |search, b| {
673 b.iter(|| {
674 assert_eq!(
675 search.byte1.count + search.byte2.count,
676 memrchr2_count(
677 search.byte1.byte,
678 search.byte2.byte,
679 search.corpus,
680 )
681 );
682 });
683 });
684 define_memchr_input2(
685 c,
686 "memrchr2/krate/empty",
687 EMPTY,
688 move |search, b| {
689 b.iter(|| {
690 assert_eq!(
691 search.byte1.count + search.byte2.count,
692 memrchr2_count(
693 search.byte1.byte,
694 search.byte2.byte,
695 search.corpus,
696 )
697 );
698 });
699 },
700 );
701
702 define_memchr_input3(c, "memrchr3/krate/huge", HUGE, move |search, b| {
703 b.iter(|| {
704 assert_eq!(
705 search.byte1.count + search.byte2.count + search.byte3.count,
706 memrchr3_count(
707 search.byte1.byte,
708 search.byte2.byte,
709 search.byte3.byte,
710 search.corpus,
711 )
712 );
713 });
714 });
715 define_memchr_input3(
716 c,
717 "memrchr3/krate/small",
718 SMALL,
719 move |search, b| {
720 b.iter(|| {
721 assert_eq!(
722 search.byte1.count
723 + search.byte2.count
724 + search.byte3.count,
725 memrchr3_count(
726 search.byte1.byte,
727 search.byte2.byte,
728 search.byte3.byte,
729 search.corpus,
730 )
731 );
732 });
733 },
734 );
735 define_memchr_input3(c, "memrchr3/krate/tiny", TINY, move |search, b| {
736 b.iter(|| {
737 assert_eq!(
738 search.byte1.count + search.byte2.count + search.byte3.count,
739 memrchr3_count(
740 search.byte1.byte,
741 search.byte2.byte,
742 search.byte3.byte,
743 search.corpus,
744 )
745 );
746 });
747 });
748 define_memchr_input3(
749 c,
750 "memrchr3/krate/empty",
751 EMPTY,
752 move |search, b| {
753 b.iter(|| {
754 assert_eq!(
755 search.byte1.count
756 + search.byte2.count
757 + search.byte3.count,
758 memrchr3_count(
759 search.byte1.byte,
760 search.byte2.byte,
761 search.byte3.byte,
762 search.corpus,
763 )
764 );
765 });
766 },
767 );
768 }
769
define_memchr_input1<'i>( c: &mut Criterion, group: &str, input: Input, bench: impl FnMut(Search1, &mut Bencher<'_>) + Clone + 'static, )770 fn define_memchr_input1<'i>(
771 c: &mut Criterion,
772 group: &str,
773 input: Input,
774 bench: impl FnMut(Search1, &mut Bencher<'_>) + Clone + 'static,
775 ) {
776 macro_rules! def {
777 ($name:expr, $kind:ident) => {
778 if let Some(search) = input.$kind() {
779 let corp = input.corpus;
780 let name = format!("{}/{}", group, $name);
781 let mut bench = bench.clone();
782 define(c, &name, corp, Box::new(move |b| bench(search, b)));
783 }
784 };
785 }
786 def!("never", never1);
787 def!("rare", rare1);
788 def!("uncommon", uncommon1);
789 def!("common", common1);
790 def!("verycommon", verycommon1);
791 def!("supercommon", supercommon1);
792 }
793
define_memchr_input2<'i>( c: &mut Criterion, group: &str, input: Input, bench: impl FnMut(Search2, &mut Bencher<'_>) + Clone + 'static, )794 fn define_memchr_input2<'i>(
795 c: &mut Criterion,
796 group: &str,
797 input: Input,
798 bench: impl FnMut(Search2, &mut Bencher<'_>) + Clone + 'static,
799 ) {
800 macro_rules! def {
801 ($name:expr, $kind:ident) => {
802 if let Some(search) = input.$kind() {
803 let corp = input.corpus;
804 let name = format!("{}/{}", group, $name);
805 let mut bench = bench.clone();
806 define(c, &name, corp, Box::new(move |b| bench(search, b)));
807 }
808 };
809 }
810 def!("never", never2);
811 def!("rare", rare2);
812 def!("uncommon", uncommon2);
813 def!("common", common2);
814 def!("verycommon", verycommon2);
815 def!("supercommon", supercommon2);
816 }
817
define_memchr_input3<'i>( c: &mut Criterion, group: &str, input: Input, bench: impl FnMut(Search3, &mut Bencher<'_>) + Clone + 'static, )818 fn define_memchr_input3<'i>(
819 c: &mut Criterion,
820 group: &str,
821 input: Input,
822 bench: impl FnMut(Search3, &mut Bencher<'_>) + Clone + 'static,
823 ) {
824 macro_rules! def {
825 ($name:expr, $kind:ident) => {
826 if let Some(search) = input.$kind() {
827 let corp = input.corpus;
828 let name = format!("{}/{}", group, $name);
829 let mut bench = bench.clone();
830 define(c, &name, corp, Box::new(move |b| bench(search, b)));
831 }
832 };
833 }
834 def!("never", never3);
835 def!("rare", rare3);
836 def!("uncommon", uncommon3);
837 def!("common", common3);
838 def!("verycommon", verycommon3);
839 def!("supercommon", supercommon3);
840 }
841