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(clippy::needless_pass_by_value)]
16
17#[path = "../tests/fst/mod.rs"]
18mod fst;
19#[path = "../tests/roaring/mod.rs"]
20mod roaring;
21#[path = "../tests/trie/mod.rs"]
22mod trie;
23
24use criterion::{black_box, criterion_group, criterion_main, Criterion};
25use rand::distributions::{Bernoulli, Distribution, Uniform};
26use rand::rngs::SmallRng;
27use rand::SeedableRng;
28use std::time::Duration;
29
30fn gen_string(p_nonascii: u32) -> String {
31 let mut rng = SmallRng::from_seed([b'!'; 32]);
32 let pick_nonascii = Bernoulli::from_ratio(p_nonascii, 100).unwrap();
33 let ascii = Uniform::new_inclusive('\0', '\x7f');
34 let nonascii = Uniform::new_inclusive(0x80 as char, char::MAX);
35
36 let mut string = String::new();
37 for _ in 0..500_000 {
38 let distribution = if pick_nonascii.sample(&mut rng) {
39 nonascii
40 } else {
41 ascii
42 };
43 string.push(distribution.sample(&mut rng));
44 }
45
46 string
47}
48
49fn bench(c: &mut Criterion, group_name: &str, string: String) {
50 let mut group = c.benchmark_group(group_name);
51 group.measurement_time(Duration::from_secs(10));
52 group.bench_function("baseline", |b| {
53 b.iter(|| {
54 for ch in string.chars() {
55 black_box(ch);
56 }
57 });
58 });
59 group.bench_function("unicode-ident", |b| {
60 b.iter(|| {
61 for ch in string.chars() {
62 black_box(unicode_ident::is_xid_start(ch));
63 black_box(unicode_ident::is_xid_continue(ch));
64 }
65 });
66 });
67 group.bench_function("unicode-xid", |b| {
68 b.iter(|| {
69 for ch in string.chars() {
70 black_box(unicode_xid::UnicodeXID::is_xid_start(ch));
71 black_box(unicode_xid::UnicodeXID::is_xid_continue(ch));
72 }
73 });
74 });
75 group.bench_function("ucd-trie", |b| {
76 b.iter(|| {
77 for ch in string.chars() {
78 black_box(trie::XID_START.contains_char(ch));
79 black_box(trie::XID_CONTINUE.contains_char(ch));
80 }
81 });
82 });
83 group.bench_function("fst", |b| {
84 let xid_start_fst = fst::xid_start_fst();
85 let xid_continue_fst = fst::xid_continue_fst();
86 b.iter(|| {
87 for ch in string.chars() {
88 let ch_bytes = (ch as u32).to_be_bytes();
89 black_box(xid_start_fst.contains(ch_bytes));
90 black_box(xid_continue_fst.contains(ch_bytes));
91 }
92 });
93 });
94 group.bench_function("roaring", |b| {
95 let xid_start_bitmap = roaring::xid_start_bitmap();
96 let xid_continue_bitmap = roaring::xid_continue_bitmap();
97 b.iter(|| {
98 for ch in string.chars() {
99 black_box(xid_start_bitmap.contains(ch as u32));
100 black_box(xid_continue_bitmap.contains(ch as u32));
101 }
102 });
103 });
104 group.finish();
105}
106
107fn bench0(c: &mut Criterion) {
108 bench(c, "0%-nonascii", gen_string(0));
109}
110
111fn bench1(c: &mut Criterion) {
112 bench(c, "1%-nonascii", gen_string(1));
113}
114
115fn bench10(c: &mut Criterion) {
116 bench(c, "10%-nonascii", gen_string(10));
117}
118
119fn bench100(c: &mut Criterion) {
120 bench(c, "100%-nonascii", gen_string(100));
121}
122
123criterion_group!(benches, bench0, bench1, bench10, bench100);
124criterion_main!(benches);
125