Debian Codegraph @

.cargo/vendor/exr/benches/read.rs

raw
1 #[macro_use]
2 extern crate bencher;
3
4 extern crate exr;
5 use exr::prelude::*;
6
7 use bencher::Bencher;
8 use std::fs;
9 use std::io::Cursor;
10 use exr::image::pixel_vec::PixelVec;
11
12 /// Read uncompressed (always single core)
13 fn read_single_image_uncompressed_non_parallel_rgba(bench: &mut Bencher) {
14 let mut file = fs::read("tests/images/valid/custom/crowskull/crow_uncompressed.exr").unwrap();
15 bench.iter(||{
16 bencher::black_box(&mut file);
17
18 let image = exr::prelude::read()
19 .no_deep_data().largest_resolution_level()
20 .rgba_channels(PixelVec::<(f32,f32,f32,f32)>::constructor, PixelVec::set_pixel)
21 .all_layers().all_attributes()
22 .non_parallel()
23 .from_buffered(Cursor::new(file.as_slice())).unwrap();
24
25 bencher::black_box(image);
26 })
27 }
28
29 /// Read from in-memory in parallel
30 fn read_single_image_uncompressed_rgba(bench: &mut Bencher) {
31 let mut file = fs::read("tests/images/valid/custom/crowskull/crow_uncompressed.exr").unwrap();
32
33 bench.iter(||{
34 bencher::black_box(&mut file);
35
36 let image = exr::prelude::read()
37 .no_deep_data().largest_resolution_level()
38 .rgba_channels(PixelVec::<(f32,f32,f32,f32)>::constructor, PixelVec::set_pixel)
39 .all_layers().all_attributes()
40 .from_buffered(Cursor::new(file.as_slice())).unwrap();
41
42 bencher::black_box(image);
43 })
44 }
45
46 /// Read with multi-core RLE decompression
47 fn read_single_image_rle_all_channels(bench: &mut Bencher) {
48 let mut file = fs::read("tests/images/valid/custom/crowskull/crow_rle.exr").unwrap();
49
50 bench.iter(||{
51 bencher::black_box(&mut file);
52
53 let image = exr::prelude::read()
54 .no_deep_data()
55 .largest_resolution_level()
56 .all_channels()
57 .all_layers()
58 .all_attributes()
59 .from_buffered(Cursor::new(file.as_slice())).unwrap();
60
61 bencher::black_box(image);
62 })
63 }
64
65 /// Read without multi-core RLE decompression
66 fn read_single_image_rle_non_parallel_all_channels(bench: &mut Bencher) {
67 let mut file = fs::read("tests/images/valid/custom/crowskull/crow_rle.exr").unwrap();
68
69 bench.iter(||{
70 bencher::black_box(&mut file);
71
72 // copied from `read_all_flat_layers_from_file` and added `.non_parallel()`
73 let image = exr::prelude::read()
74 .no_deep_data()
75 .largest_resolution_level()
76 .all_channels()
77 .all_layers()
78 .all_attributes()
79 .non_parallel()
80 .from_buffered(Cursor::new(file.as_slice())).unwrap();
81
82 bencher::black_box(image);
83 })
84 }
85
86 /// Read with multi-core RLE decompression
87 fn read_single_image_rle_rgba(bench: &mut Bencher) {
88 let mut file = fs::read("tests/images/valid/custom/crowskull/crow_rle.exr").unwrap();
89
90 bench.iter(||{
91 bencher::black_box(&mut file);
92
93 let image = exr::prelude::read()
94 .no_deep_data()
95 .largest_resolution_level()
96 .rgba_channels(PixelVec::<(f32,f32,f32,f32)>::constructor, PixelVec::set_pixel)
97 .all_layers()
98 .all_attributes()
99 .from_buffered(Cursor::new(file.as_slice())).unwrap();
100
101 bencher::black_box(image);
102 })
103 }
104
105 /// Read without multi-core RLE decompression
106 fn read_single_image_rle_non_parallel_rgba(bench: &mut Bencher) {
107 let mut file = fs::read("tests/images/valid/custom/crowskull/crow_rle.exr").unwrap();
108
109 bench.iter(||{
110 bencher::black_box(&mut file);
111
112 // copied from `read_all_flat_layers_from_file` and added `.non_parallel()`
113 let image = exr::prelude::read()
114 .no_deep_data()
115 .largest_resolution_level()
116 .rgba_channels(PixelVec::<(f32,f32,f32,f32)>::constructor, PixelVec::set_pixel)
117 .all_layers()
118 .all_attributes()
119 .non_parallel()
120 .from_buffered(Cursor::new(file.as_slice())).unwrap();
121
122 bencher::black_box(image);
123 })
124 }
125
126 /// Read with multi-core zip decompression
127 fn read_single_image_zips_rgba(bench: &mut Bencher) {
128 let mut file = fs::read("tests/images/valid/custom/crowskull/crow_zips.exr").unwrap();
129
130 bench.iter(||{
131 bencher::black_box(&mut file);
132
133 let image = exr::prelude::read()
134 .no_deep_data().largest_resolution_level()
135 .rgba_channels(PixelVec::<(f32,f32,f32,f32)>::constructor, PixelVec::set_pixel)
136 .all_layers().all_attributes()
137 .from_buffered(Cursor::new(file.as_slice())).unwrap();
138
139 bencher::black_box(image);
140 })
141 }
142
143 /// Read without multi-core ZIP decompression
144 fn read_single_image_zips_non_parallel_rgba(bench: &mut Bencher) {
145 let mut file = fs::read("tests/images/valid/custom/crowskull/crow_zips.exr").unwrap();
146
147 bench.iter(||{
148 bencher::black_box(&mut file);
149
150 let image = exr::prelude::read()
151 .no_deep_data().largest_resolution_level()
152 .rgba_channels(PixelVec::<(f32,f32,f32,f32)>::constructor, PixelVec::set_pixel)
153 .all_layers().all_attributes()
154 .non_parallel()
155 .from_buffered(Cursor::new(file.as_slice())).unwrap();
156
157 bencher::black_box(image);
158 })
159 }
160
161 benchmark_group!(read,
162 read_single_image_uncompressed_rgba,
163 read_single_image_uncompressed_non_parallel_rgba,
164 read_single_image_rle_rgba,
165 read_single_image_rle_non_parallel_rgba,
166 read_single_image_rle_all_channels,
167 read_single_image_rle_non_parallel_all_channels,
168 read_single_image_zips_rgba,
169 read_single_image_zips_non_parallel_rgba,
170 );
171
172 benchmark_main!(read);