1 use criterion::black_box;
2 use criterion::criterion_group;
3 use criterion::criterion_main;
4 use criterion::Bencher;
5 use criterion::Criterion;
6 use criterion::Fun;
7
8 use tinystr::{TinyStr16, TinyStr4, TinyStr8, TinyStrAuto};
9
10 static STRINGS_4: &[&str] = &[
11 "US", "GB", "AR", "Hans", "CN", "AT", "PL", "FR", "AT", "Cyrl", "SR", "NO", "FR", "MK", "UK",
12 ];
13
14 static STRINGS_8: &[&str] = &[
15 "Latn", "windows", "AR", "Hans", "macos", "AT", "pl", "FR", "en", "Cyrl", "SR", "NO", "419",
16 "und", "UK",
17 ];
18
19 static STRINGS_16: &[&str] = &[
20 "Latn",
21 "windows",
22 "AR",
23 "Hans",
24 "macos",
25 "AT",
26 "infiniband",
27 "FR",
28 "en",
29 "Cyrl",
30 "FromIntegral",
31 "NO",
32 "419",
33 "MacintoshOSX2019",
34 "UK",
35 ];
36
37 macro_rules! bench_block {
38 ($c:expr, $name:expr, $action:ident) => {
39 let funcs = vec![
40 Fun::new("String", $action!(String)),
41 Fun::new("TinyStr4", $action!(TinyStr4)),
42 Fun::new("TinyStr8", $action!(TinyStr8)),
43 Fun::new("TinyStr16", $action!(TinyStr16)),
44 Fun::new("TinyStrAuto", $action!(TinyStrAuto)),
45 ];
46
47 $c.bench_functions(&format!("{}/4", $name), funcs, STRINGS_4);
48
49 let funcs = vec![
50 Fun::new("String", $action!(String)),
51 Fun::new("TinyStr8", $action!(TinyStr8)),
52 Fun::new("TinyStr16", $action!(TinyStr16)),
53 Fun::new("TinyStrAuto", $action!(TinyStrAuto)),
54 ];
55
56 $c.bench_functions(&format!("{}/8", $name), funcs, STRINGS_8);
57
58 let funcs = vec![
59 Fun::new("String", $action!(String)),
60 Fun::new("TinyStr16", $action!(TinyStr16)),
61 Fun::new("TinyStrAuto", $action!(TinyStrAuto)),
62 ];
63
64 $c.bench_functions(&format!("{}/16", $name), funcs, STRINGS_16);
65 };
66 }
67
construct_from_str(c: &mut Criterion)68 fn construct_from_str(c: &mut Criterion) {
69 macro_rules! cfs {
70 ($r:ty) => {
71 |b: &mut Bencher, strings: &&[&str]| {
72 b.iter(|| {
73 for s in *strings {
74 let _: $r = black_box(s.parse().unwrap());
75 }
76 })
77 }
78 };
79 };
80
81 bench_block!(c, "construct_from_str", cfs);
82 }
83
construct_from_bytes(c: &mut Criterion)84 fn construct_from_bytes(c: &mut Criterion) {
85 macro_rules! cfu {
86 ($r:ty) => {
87 |b, inputs: &&[&str]| {
88 let raw: Vec<&[u8]> = inputs.iter().map(|s| s.as_bytes()).collect();
89 b.iter(move || {
90 for u in &raw {
91 let _ = black_box(<$r>::from_bytes(*u).unwrap());
92 }
93 })
94 }
95 };
96 };
97
98 let funcs = vec![
99 Fun::new("TinyStr4", cfu!(TinyStr4)),
100 Fun::new("TinyStr8", cfu!(TinyStr8)),
101 Fun::new("TinyStr16", cfu!(TinyStr16)),
102 ];
103
104 c.bench_functions("construct_from_bytes/4", funcs, STRINGS_4);
105
106 let funcs = vec![
107 Fun::new("TinyStr8", cfu!(TinyStr8)),
108 Fun::new("TinyStr16", cfu!(TinyStr16)),
109 ];
110
111 c.bench_functions("construct_from_bytes/8", funcs, STRINGS_8);
112
113 let funcs = vec![Fun::new("TinyStr16", cfu!(TinyStr16))];
114
115 c.bench_functions("construct_from_bytes/16", funcs, STRINGS_16);
116 }
117
construct_unchecked(c: &mut Criterion)118 fn construct_unchecked(c: &mut Criterion) {
119 macro_rules! cu {
120 ($tty:ty, $rty:ty) => {
121 |b, inputs: &&[&str]| {
122 let raw: Vec<$rty> = inputs
123 .iter()
124 .map(|s| s.parse::<$tty>().unwrap().into())
125 .collect();
126 b.iter(move || {
127 for num in &raw {
128 let _ = unsafe { <$tty>::new_unchecked(black_box(*num)) };
129 }
130 })
131 }
132 };
133 };
134
135 let funcs = vec![Fun::new("TinyStr4", cu!(TinyStr4, u32))];
136
137 c.bench_functions("construct_unchecked/4", funcs, STRINGS_4);
138
139 let funcs = vec![Fun::new("TinyStr8", cu!(TinyStr8, u64))];
140
141 c.bench_functions("construct_unchecked/8", funcs, STRINGS_8);
142
143 let funcs = vec![Fun::new("TinyStr16", cu!(TinyStr16, u128))];
144
145 c.bench_functions("construct_unchecked/16", funcs, STRINGS_16);
146 }
147
148 criterion_group!(
149 benches,
150 construct_from_str,
151 construct_from_bytes,
152 construct_unchecked,
153 );
154 criterion_main!(benches);
155