1 // To run:
2 //
3 // cargo criterion --features criterion/real_blackbox
4 //
5 // This benchmarks each of the different libraries at several ratios of ASCII to
6 // non-ASCII content. There is one additional benchmark labeled "baseline" which
7 // just iterates over characters in a string, converting UTF-8 to 32-bit chars.
8 //
9 // Criterion will show a time in milliseconds. The non-baseline bench functions
10 // each make one million function calls (2 calls per character, 500K characters
11 // in the strings created by gen_string). The "time per call" listed in our
12 // readme is computed by subtracting this baseline from the other bench
13 // functions' time, then dividing by one million (ms -> ns).
14
15 #![allow(
16 clippy::incompatible_msrv, // https://github.com/rust-lang/rust-clippy/issues/12257
17 clippy::needless_pass_by_value,
18 )]
19
20 #[path = "../tests/fst/mod.rs"]
21 mod fst;
22 #[path = "../tests/roaring/mod.rs"]
23 mod roaring;
24 #[path = "../tests/trie/mod.rs"]
25 mod trie;
26
27 use criterion::{black_box, criterion_group, criterion_main, Criterion};
28 use rand::distributions::{Bernoulli, Distribution, Uniform};
29 use rand::rngs::SmallRng;
30 use rand::SeedableRng;
31 use std::time::Duration;
32
gen_string(p_nonascii: u32) -> String33 fn gen_string(p_nonascii: u32) -> String {
34 let mut rng = SmallRng::from_seed([b'!'; 32]);
35 let pick_nonascii = Bernoulli::from_ratio(p_nonascii, 100).unwrap();
36 let ascii = Uniform::new_inclusive('\0', '\x7f');
37 let nonascii = Uniform::new_inclusive(0x80 as char, char::MAX);
38
39 let mut string = String::new();
40 for _ in 0..500_000 {
41 let distribution = if pick_nonascii.sample(&mut rng) {
42 nonascii
43 } else {
44 ascii
45 };
46 string.push(distribution.sample(&mut rng));
47 }
48
49 string
50 }
51
bench(c: &mut Criterion, group_name: &str, string: String)52 fn bench(c: &mut Criterion, group_name: &str, string: String) {
53 let mut group = c.benchmark_group(group_name);
54 group.measurement_time(Duration::from_secs(10));
55 group.bench_function("baseline", |b| {
56 b.iter(|| {
57 for ch in string.chars() {
58 black_box(ch);
59 }
60 });
61 });
62 group.bench_function("unicode-ident", |b| {
63 b.iter(|| {
64 for ch in string.chars() {
65 black_box(unicode_ident::is_xid_start(ch));
66 black_box(unicode_ident::is_xid_continue(ch));
67 }
68 });
69 });
70 group.bench_function("unicode-xid", |b| {
71 b.iter(|| {
72 for ch in string.chars() {
73 black_box(unicode_xid::UnicodeXID::is_xid_start(ch));
74 black_box(unicode_xid::UnicodeXID::is_xid_continue(ch));
75 }
76 });
77 });
78 group.bench_function("ucd-trie", |b| {
79 b.iter(|| {
80 for ch in string.chars() {
81 black_box(trie::XID_START.contains_char(ch));
82 black_box(trie::XID_CONTINUE.contains_char(ch));
83 }
84 });
85 });
86 group.bench_function("fst", |b| {
87 let xid_start_fst = fst::xid_start_fst();
88 let xid_continue_fst = fst::xid_continue_fst();
89 b.iter(|| {
90 for ch in string.chars() {
91 let ch_bytes = (ch as u32).to_be_bytes();
92 black_box(xid_start_fst.contains(ch_bytes));
93 black_box(xid_continue_fst.contains(ch_bytes));
94 }
95 });
96 });
97 group.bench_function("roaring", |b| {
98 let xid_start_bitmap = roaring::xid_start_bitmap();
99 let xid_continue_bitmap = roaring::xid_continue_bitmap();
100 b.iter(|| {
101 for ch in string.chars() {
102 black_box(xid_start_bitmap.contains(ch as u32));
103 black_box(xid_continue_bitmap.contains(ch as u32));
104 }
105 });
106 });
107 group.finish();
108 }
109
bench0(c: &mut Criterion)110 fn bench0(c: &mut Criterion) {
111 bench(c, "0%-nonascii", gen_string(0));
112 }
113
bench1(c: &mut Criterion)114 fn bench1(c: &mut Criterion) {
115 bench(c, "1%-nonascii", gen_string(1));
116 }
117
bench10(c: &mut Criterion)118 fn bench10(c: &mut Criterion) {
119 bench(c, "10%-nonascii", gen_string(10));
120 }
121
bench100(c: &mut Criterion)122 fn bench100(c: &mut Criterion) {
123 bench(c, "100%-nonascii", gen_string(100));
124 }
125
126 criterion_group!(benches, bench0, bench1, bench10, bench100);
127 criterion_main!(benches);
128