1 use criterion::black_box;
2
3 use winnow::combinator::repeat;
4 use winnow::prelude::*;
5 use winnow::token::one_of;
6 use winnow::token::tag;
7
next_slice(c: &mut criterion::Criterion)8 fn next_slice(c: &mut criterion::Criterion) {
9 let mut group = c.benchmark_group("next_slice");
10
11 let name = "ascii";
12 let sample = "h".repeat(100);
13 let sample = sample.as_str();
14 group.bench_with_input(
15 criterion::BenchmarkId::new("char", name),
16 sample,
17 |b, sample| {
18 b.iter(|| black_box(parser_ascii_char.parse_peek(black_box(sample)).unwrap()));
19 },
20 );
21 group.bench_with_input(
22 criterion::BenchmarkId::new("str", name),
23 sample,
24 |b, sample| {
25 b.iter(|| black_box(parser_ascii_str.parse_peek(black_box(sample)).unwrap()));
26 },
27 );
28 group.bench_with_input(
29 criterion::BenchmarkId::new("one_of", name),
30 sample,
31 |b, sample| {
32 b.iter(|| black_box(parser_ascii_one_of.parse_peek(black_box(sample)).unwrap()));
33 },
34 );
35 group.bench_with_input(
36 criterion::BenchmarkId::new("tag_char", name),
37 sample,
38 |b, sample| {
39 b.iter(|| black_box(parser_ascii_tag_char.parse_peek(black_box(sample)).unwrap()));
40 },
41 );
42 group.bench_with_input(
43 criterion::BenchmarkId::new("tag_str", name),
44 sample,
45 |b, sample| {
46 b.iter(|| black_box(parser_ascii_tag_str.parse_peek(black_box(sample)).unwrap()));
47 },
48 );
49
50 let name = "utf8";
51 let sample = "��".repeat(100);
52 let sample = sample.as_str();
53 group.bench_with_input(
54 criterion::BenchmarkId::new("char", name),
55 sample,
56 |b, sample| {
57 b.iter(|| black_box(parser_utf8_char.parse_peek(black_box(sample)).unwrap()));
58 },
59 );
60 group.bench_with_input(
61 criterion::BenchmarkId::new("str", name),
62 sample,
63 |b, sample| {
64 b.iter(|| black_box(parser_utf8_str.parse_peek(black_box(sample)).unwrap()));
65 },
66 );
67 group.bench_with_input(
68 criterion::BenchmarkId::new("one_of", name),
69 sample,
70 |b, sample| {
71 b.iter(|| black_box(parser_utf8_one_of.parse_peek(black_box(sample)).unwrap()));
72 },
73 );
74 group.bench_with_input(
75 criterion::BenchmarkId::new("tag_char", name),
76 sample,
77 |b, sample| {
78 b.iter(|| black_box(parser_utf8_tag_char.parse_peek(black_box(sample)).unwrap()));
79 },
80 );
81 group.bench_with_input(
82 criterion::BenchmarkId::new("tag_str", name),
83 sample,
84 |b, sample| {
85 b.iter(|| black_box(parser_utf8_tag_str.parse_peek(black_box(sample)).unwrap()));
86 },
87 );
88
89 group.finish();
90 }
91
parser_ascii_char(input: &mut &str) -> PResult<usize>92 fn parser_ascii_char(input: &mut &str) -> PResult<usize> {
93 repeat(0.., 'h').parse_next(input)
94 }
95
parser_ascii_str(input: &mut &str) -> PResult<usize>96 fn parser_ascii_str(input: &mut &str) -> PResult<usize> {
97 repeat(0.., "h").parse_next(input)
98 }
99
parser_ascii_one_of(input: &mut &str) -> PResult<usize>100 fn parser_ascii_one_of(input: &mut &str) -> PResult<usize> {
101 repeat(0.., one_of('h')).parse_next(input)
102 }
103
parser_ascii_tag_char(input: &mut &str) -> PResult<usize>104 fn parser_ascii_tag_char(input: &mut &str) -> PResult<usize> {
105 repeat(0.., tag('h')).parse_next(input)
106 }
107
parser_ascii_tag_str(input: &mut &str) -> PResult<usize>108 fn parser_ascii_tag_str(input: &mut &str) -> PResult<usize> {
109 repeat(0.., tag("h")).parse_next(input)
110 }
111
parser_utf8_char(input: &mut &str) -> PResult<usize>112 fn parser_utf8_char(input: &mut &str) -> PResult<usize> {
113 repeat(0.., '��').parse_next(input)
114 }
115
parser_utf8_str(input: &mut &str) -> PResult<usize>116 fn parser_utf8_str(input: &mut &str) -> PResult<usize> {
117 repeat(0.., "��").parse_next(input)
118 }
119
parser_utf8_one_of(input: &mut &str) -> PResult<usize>120 fn parser_utf8_one_of(input: &mut &str) -> PResult<usize> {
121 repeat(0.., one_of('��')).parse_next(input)
122 }
123
parser_utf8_tag_char(input: &mut &str) -> PResult<usize>124 fn parser_utf8_tag_char(input: &mut &str) -> PResult<usize> {
125 repeat(0.., tag('��')).parse_next(input)
126 }
127
parser_utf8_tag_str(input: &mut &str) -> PResult<usize>128 fn parser_utf8_tag_str(input: &mut &str) -> PResult<usize> {
129 repeat(0.., tag("��")).parse_next(input)
130 }
131
132 criterion::criterion_group!(benches, next_slice);
133 criterion::criterion_main!(benches);
134