Debian Codegraph @

.cargo/vendor/png/benches/decoder.rs

raw
1 use std::{fs, io::Cursor};
2
3 use criterion::{
4 criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, Throughput,
5 };
6 use png::{Decoder, Reader, Transformations};
7
8 #[path = "../src/test_utils.rs"]
9 mod test_utils;
10
11 fn load_all(c: &mut Criterion) {
12 let mut g = c.benchmark_group("decode");
13 for entry in fs::read_dir("tests/benches/").unwrap().flatten() {
14 match entry.path().extension() {
15 Some(st) if st == "png" => {}
16 _ => continue,
17 }
18
19 let data = fs::read(entry.path()).unwrap();
20 bench_file(&mut g, data, entry.file_name().into_string().unwrap());
21 }
22 g.finish();
23
24 // Small IDATS
25 let mut g = c.benchmark_group("generated-noncompressed-4k-idat");
26 bench_noncompressed_png(&mut g, 8, 4096); // 256 B
27 bench_noncompressed_png(&mut g, 128, 4096); // 64 KB
28 bench_noncompressed_png(&mut g, 2048, 4096); // 16 MB
29 bench_noncompressed_png(&mut g, 12288, 4096); // 576 MB
30 g.finish();
31
32 // Normal IDATS
33 let mut g = c.benchmark_group("generated-noncompressed-64k-idat");
34 bench_noncompressed_png(&mut g, 128, 65536); // 64 KB
35 bench_noncompressed_png(&mut g, 2048, 65536); // 16 MB
36 bench_noncompressed_png(&mut g, 12288, 65536); // 576 MB
37 g.finish();
38
39 // Large IDATS
40 let mut g = c.benchmark_group("generated-noncompressed-2g-idat");
41 bench_noncompressed_png(&mut g, 2048, 0x7fffffff); // 16 MB
42 bench_noncompressed_png(&mut g, 12288, 0x7fffffff); // 576 MB
43 g.finish();
44
45 // Incremental decoding via `read_row`
46 let mut g = c.benchmark_group("row-by-row");
47 let mut data = Vec::new();
48 test_utils::write_noncompressed_png(&mut data, 128, 4096);
49 bench_read_row(&mut g, data, "128x128-4k-idat");
50 g.finish();
51 }
52
53 criterion_group! {benches, load_all}
54 criterion_main!(benches);
55
56 fn bench_noncompressed_png(g: &mut BenchmarkGroup<WallTime>, size: u32, idat_bytes: usize) {
57 let mut data = Vec::new();
58 test_utils::write_noncompressed_png(&mut data, size, idat_bytes);
59 bench_file(g, data, format!("{size}x{size}.png"));
60 }
61
62 /// This benchmarks decoding via a call to `Reader::next_frame`.
63 fn bench_file(g: &mut BenchmarkGroup<WallTime>, data: Vec<u8>, name: String) {
64 if data.len() > 1_000_000 {
65 g.sample_size(10);
66 }
67
68 let mut reader = create_reader(data.as_slice());
69 let mut image = vec![0; reader.output_buffer_size().unwrap()];
70 let info = reader.next_frame(&mut image).unwrap();
71
72 g.throughput(Throughput::Bytes(info.buffer_size() as u64));
73 g.bench_with_input(name, &data, |b, data| {
74 b.iter(|| {
75 let mut reader = create_reader(data.as_slice());
76 reader.next_frame(&mut image).unwrap();
77 })
78 });
79 }
80
81 /// This benchmarks decoding via a sequence of `Reader::read_row` calls.
82 fn bench_read_row(g: &mut BenchmarkGroup<WallTime>, data: Vec<u8>, name: &str) {
83 let reader = create_reader(data.as_slice());
84 let mut image = vec![0; reader.output_buffer_size().unwrap()];
85 let bytes_per_row = reader.output_line_size(reader.info().width).unwrap();
86 g.throughput(Throughput::Bytes(image.len() as u64));
87 g.bench_with_input(name, &data, |b, data| {
88 b.iter(|| {
89 let mut reader = create_reader(data.as_slice());
90
91 for output_row in image.chunks_exact_mut(bytes_per_row) {
92 reader.read_row(output_row).unwrap().unwrap();
93 }
94 })
95 });
96 }
97
98 fn create_reader(data: &[u8]) -> Reader<Cursor<&[u8]>> {
99 let mut decoder = Decoder::new(Cursor::new(data));
100
101 // Cover default transformations used by the `image` crate when constructing
102 // `image::codecs::png::PngDecoder`.
103 decoder.set_transformations(Transformations::EXPAND);
104
105 decoder.read_info().unwrap()
106 }