Debian Codegraph @

.cargo/vendor/base64/benches/benchmarks.rs

raw
1 #[macro_use]
2 extern crate criterion;
3
4 use base64::{
5 display,
6 engine::{general_purpose::STANDARD, Engine},
7 write,
8 };
9 use criterion::{black_box, Bencher, BenchmarkId, Criterion, Throughput};
10 use rand::{Rng, SeedableRng};
11 use std::io::{self, Read, Write};
12
13 fn do_decode_bench(b: &mut Bencher, &size: &usize) {
14 let mut v: Vec<u8> = Vec::with_capacity(size * 3 / 4);
15 fill(&mut v);
16 let encoded = STANDARD.encode(&v);
17
18 b.iter(|| {
19 let orig = STANDARD.decode(&encoded);
20 black_box(&orig);
21 });
22 }
23
24 fn do_decode_bench_reuse_buf(b: &mut Bencher, &size: &usize) {
25 let mut v: Vec<u8> = Vec::with_capacity(size * 3 / 4);
26 fill(&mut v);
27 let encoded = STANDARD.encode(&v);
28
29 let mut buf = Vec::new();
30 b.iter(|| {
31 STANDARD.decode_vec(&encoded, &mut buf).unwrap();
32 black_box(&buf);
33 buf.clear();
34 });
35 }
36
37 fn do_decode_bench_slice(b: &mut Bencher, &size: &usize) {
38 let mut v: Vec<u8> = Vec::with_capacity(size * 3 / 4);
39 fill(&mut v);
40 let encoded = STANDARD.encode(&v);
41
42 let mut buf = vec![0; size];
43 b.iter(|| {
44 STANDARD.decode_slice(&encoded, &mut buf).unwrap();
45 black_box(&buf);
46 });
47 }
48
49 fn do_decode_bench_stream(b: &mut Bencher, &size: &usize) {
50 let mut v: Vec<u8> = Vec::with_capacity(size * 3 / 4);
51 fill(&mut v);
52 let encoded = STANDARD.encode(&v);
53
54 let mut buf = vec![0; size];
55 buf.truncate(0);
56
57 b.iter(|| {
58 let mut cursor = io::Cursor::new(&encoded[..]);
59 let mut decoder = base64::read::DecoderReader::new(&mut cursor, &STANDARD);
60 decoder.read_to_end(&mut buf).unwrap();
61 buf.clear();
62 black_box(&buf);
63 });
64 }
65
66 fn do_encode_bench(b: &mut Bencher, &size: &usize) {
67 let mut v: Vec<u8> = Vec::with_capacity(size);
68 fill(&mut v);
69 b.iter(|| {
70 let e = STANDARD.encode(&v);
71 black_box(&e);
72 });
73 }
74
75 fn do_encode_bench_display(b: &mut Bencher, &size: &usize) {
76 let mut v: Vec<u8> = Vec::with_capacity(size);
77 fill(&mut v);
78 b.iter(|| {
79 let e = format!("{}", display::Base64Display::new(&v, &STANDARD));
80 black_box(&e);
81 });
82 }
83
84 fn do_encode_bench_reuse_buf(b: &mut Bencher, &size: &usize) {
85 let mut v: Vec<u8> = Vec::with_capacity(size);
86 fill(&mut v);
87 let mut buf = String::new();
88 b.iter(|| {
89 STANDARD.encode_string(&v, &mut buf);
90 buf.clear();
91 });
92 }
93
94 fn do_encode_bench_slice(b: &mut Bencher, &size: &usize) {
95 let mut v: Vec<u8> = Vec::with_capacity(size);
96 fill(&mut v);
97 // conservative estimate of encoded size
98 let mut buf = vec![0; v.len() * 2];
99 b.iter(|| STANDARD.encode_slice(&v, &mut buf).unwrap());
100 }
101
102 fn do_encode_bench_stream(b: &mut Bencher, &size: &usize) {
103 let mut v: Vec<u8> = Vec::with_capacity(size);
104 fill(&mut v);
105 let mut buf = Vec::new();
106
107 buf.reserve(size * 2);
108 b.iter(|| {
109 buf.clear();
110 let mut stream_enc = write::EncoderWriter::new(&mut buf, &STANDARD);
111 stream_enc.write_all(&v).unwrap();
112 stream_enc.flush().unwrap();
113 });
114 }
115
116 fn do_encode_bench_string_stream(b: &mut Bencher, &size: &usize) {
117 let mut v: Vec<u8> = Vec::with_capacity(size);
118 fill(&mut v);
119
120 b.iter(|| {
121 let mut stream_enc = write::EncoderStringWriter::new(&STANDARD);
122 stream_enc.write_all(&v).unwrap();
123 stream_enc.flush().unwrap();
124 let _ = stream_enc.into_inner();
125 });
126 }
127
128 fn do_encode_bench_string_reuse_buf_stream(b: &mut Bencher, &size: &usize) {
129 let mut v: Vec<u8> = Vec::with_capacity(size);
130 fill(&mut v);
131
132 let mut buf = String::new();
133 b.iter(|| {
134 buf.clear();
135 let mut stream_enc = write::EncoderStringWriter::from_consumer(&mut buf, &STANDARD);
136 stream_enc.write_all(&v).unwrap();
137 stream_enc.flush().unwrap();
138 let _ = stream_enc.into_inner();
139 });
140 }
141
142 fn fill(v: &mut Vec<u8>) {
143 let cap = v.capacity();
144 // weak randomness is plenty; we just want to not be completely friendly to the branch predictor
145 let mut r = rand::rngs::SmallRng::from_entropy();
146 while v.len() < cap {
147 v.push(r.gen::<u8>());
148 }
149 }
150
151 const BYTE_SIZES: [usize; 5] = [3, 50, 100, 500, 3 * 1024];
152
153 // Benchmarks over these byte sizes take longer so we will run fewer samples to
154 // keep the benchmark runtime reasonable.
155 const LARGE_BYTE_SIZES: [usize; 3] = [3 * 1024 * 1024, 10 * 1024 * 1024, 30 * 1024 * 1024];
156
157 fn encode_benchmarks(c: &mut Criterion, label: &str, byte_sizes: &[usize]) {
158 let mut group = c.benchmark_group(label);
159 group
160 .warm_up_time(std::time::Duration::from_millis(500))
161 .measurement_time(std::time::Duration::from_secs(3));
162
163 for size in byte_sizes {
164 group
165 .throughput(Throughput::Bytes(*size as u64))
166 .bench_with_input(BenchmarkId::new("encode", size), size, do_encode_bench)
167 .bench_with_input(
168 BenchmarkId::new("encode_display", size),
169 size,
170 do_encode_bench_display,
171 )
172 .bench_with_input(
173 BenchmarkId::new("encode_reuse_buf", size),
174 size,
175 do_encode_bench_reuse_buf,
176 )
177 .bench_with_input(
178 BenchmarkId::new("encode_slice", size),
179 size,
180 do_encode_bench_slice,
181 )
182 .bench_with_input(
183 BenchmarkId::new("encode_reuse_buf_stream", size),
184 size,
185 do_encode_bench_stream,
186 )
187 .bench_with_input(
188 BenchmarkId::new("encode_string_stream", size),
189 size,
190 do_encode_bench_string_stream,
191 )
192 .bench_with_input(
193 BenchmarkId::new("encode_string_reuse_buf_stream", size),
194 size,
195 do_encode_bench_string_reuse_buf_stream,
196 );
197 }
198
199 group.finish();
200 }
201
202 fn decode_benchmarks(c: &mut Criterion, label: &str, byte_sizes: &[usize]) {
203 let mut group = c.benchmark_group(label);
204
205 for size in byte_sizes {
206 group
207 .warm_up_time(std::time::Duration::from_millis(500))
208 .measurement_time(std::time::Duration::from_secs(3))
209 .throughput(Throughput::Bytes(*size as u64))
210 .bench_with_input(BenchmarkId::new("decode", size), size, do_decode_bench)
211 .bench_with_input(
212 BenchmarkId::new("decode_reuse_buf", size),
213 size,
214 do_decode_bench_reuse_buf,
215 )
216 .bench_with_input(
217 BenchmarkId::new("decode_slice", size),
218 size,
219 do_decode_bench_slice,
220 )
221 .bench_with_input(
222 BenchmarkId::new("decode_stream", size),
223 size,
224 do_decode_bench_stream,
225 );
226 }
227
228 group.finish();
229 }
230
231 fn bench(c: &mut Criterion) {
232 encode_benchmarks(c, "encode_small_input", &BYTE_SIZES[..]);
233 encode_benchmarks(c, "encode_large_input", &LARGE_BYTE_SIZES[..]);
234 decode_benchmarks(c, "decode_small_input", &BYTE_SIZES[..]);
235 decode_benchmarks(c, "decode_large_input", &LARGE_BYTE_SIZES[..]);
236 }
237
238 criterion_group!(benches, bench);
239 criterion_main!(benches);