Debian Codegraph @

.cargo/vendor/adler2/benches/bench.rs

raw
1 extern crate adler2;
2 extern crate criterion;
3
4 use adler2::{adler32_slice, Adler32};
5 use criterion::{criterion_group, criterion_main, Criterion, Throughput};
6
7 fn simple(c: &mut Criterion) {
8 {
9 const SIZE: usize = 100;
10
11 let mut group = c.benchmark_group("simple-100b");
12 group.throughput(Throughput::Bytes(SIZE as u64));
13 group.bench_function("zeroes-100", |bencher| {
14 bencher.iter(|| {
15 adler32_slice(&[0; SIZE]);
16 });
17 });
18 group.bench_function("ones-100", |bencher| {
19 bencher.iter(|| {
20 adler32_slice(&[0xff; SIZE]);
21 });
22 });
23 }
24
25 {
26 const SIZE: usize = 1024;
27
28 let mut group = c.benchmark_group("simple-1k");
29 group.throughput(Throughput::Bytes(SIZE as u64));
30
31 group.bench_function("zeroes-1k", |bencher| {
32 bencher.iter(|| {
33 adler32_slice(&[0; SIZE]);
34 });
35 });
36
37 group.bench_function("ones-1k", |bencher| {
38 bencher.iter(|| {
39 adler32_slice(&[0xff; SIZE]);
40 });
41 });
42 }
43
44 {
45 const SIZE: usize = 1024 * 1024;
46
47 let mut group = c.benchmark_group("simple-1m");
48 group.throughput(Throughput::Bytes(SIZE as u64));
49 group.bench_function("zeroes-1m", |bencher| {
50 bencher.iter(|| {
51 adler32_slice(&[0; SIZE]);
52 });
53 });
54
55 group.bench_function("ones-1m", |bencher| {
56 bencher.iter(|| {
57 adler32_slice(&[0xff; SIZE]);
58 });
59 });
60 }
61 }
62
63 fn chunked(c: &mut Criterion) {
64 const SIZE: usize = 16 * 1024 * 1024;
65
66 let data = vec![0xAB; SIZE];
67
68 let mut group = c.benchmark_group("chunked-16m");
69 group.throughput(Throughput::Bytes(SIZE as u64));
70 group.bench_function("5552", |bencher| {
71 bencher.iter(|| {
72 let mut h = Adler32::new();
73 for chunk in data.chunks(5552) {
74 h.write_slice(chunk);
75 }
76 h.checksum()
77 });
78 });
79 group.bench_function("8k", |bencher| {
80 bencher.iter(|| {
81 let mut h = Adler32::new();
82 for chunk in data.chunks(8 * 1024) {
83 h.write_slice(chunk);
84 }
85 h.checksum()
86 });
87 });
88 group.bench_function("64k", |bencher| {
89 bencher.iter(|| {
90 let mut h = Adler32::new();
91 for chunk in data.chunks(64 * 1024) {
92 h.write_slice(chunk);
93 }
94 h.checksum()
95 });
96 });
97 group.bench_function("1m", |bencher| {
98 bencher.iter(|| {
99 let mut h = Adler32::new();
100 for chunk in data.chunks(1024 * 1024) {
101 h.write_slice(chunk);
102 }
103 h.checksum()
104 });
105 });
106 }
107
108 criterion_group!(benches, simple, chunked);
109 criterion_main!(benches);