Merge pull request #413 from anforowicz/unfilter-benchmarks

Scaffolding for direct benchmarking of `crate::filter::unfilter`.

Cargo.toml

@@ -44,3 +44,9 @@ benchmarks = []
 path = "benches/decoder.rs"
 name = "decoder"
 harness = false
+
+[[bench]]
+path = "benches/unfilter.rs"
+name = "unfilter"
+harness = false
+required-features = ["benchmarks"]

benches/unfilter.rs

@@ -0,0 +1,56 @@
+//! Usage example:
+//!
+//! ```
+//! $ alias bench="rustup run nightly cargo bench"
+//! $ bench --bench=unfilter --features=benchmarks -- --save-baseline my_baseline
+//! ... tweak something, say the Sub filter ...
+//! $ bench --bench=unfilter --features=benchmarks -- filter=Sub --baseline my_baseline
+//! ```
+
+use criterion::{criterion_group, criterion_main, Criterion, Throughput};
+use png::benchable_apis::unfilter;
+use png::FilterType;
+use rand::Rng;
+
+fn unfilter_all(c: &mut Criterion) {
+ let bpps = [1, 2, 3, 4, 6, 8];
+ let filters = [
+ FilterType::Sub,
+ FilterType::Up,
+ FilterType::Avg,
+ FilterType::Paeth,
+ ];
+ for &filter in filters.iter() {
+ for &bpp in bpps.iter() {
+ bench_unfilter(c, filter, bpp);
+ }
+ }
+}
+
+criterion_group!(benches, unfilter_all);
+criterion_main!(benches);
+
+fn bench_unfilter(c: &mut Criterion, filter: FilterType, bpp: u8) {
+ let mut group = c.benchmark_group("unfilter");
+
+ fn get_random_bytes<R: Rng>(rng: &mut R, n: usize) -> Vec<u8> {
+ use rand::Fill;
+ let mut result = vec![0u8; n];
+ result.as_mut_slice().try_fill(rng).unwrap();
+ result
+ }
+ let mut rng = rand::thread_rng();
+ let row_size = 4096 * (bpp as usize);
+ let two_rows = get_random_bytes(&mut rng, row_size * 2);
+
+ group.throughput(Throughput::Bytes(row_size as u64));
+ group.bench_with_input(
+ format!("filter={filter:?}/bpp={bpp}"),
+ &two_rows,
+ |b, two_rows| {
+ let (prev_row, curr_row) = two_rows.split_at(row_size);
+ let mut curr_row = curr_row.to_vec();
+ b.iter(|| unfilter(filter, bpp, prev_row, curr_row.as_mut_slice()));
+ },
+ );
+}

src/benchable_apis.rs

@@ -0,0 +1,12 @@
+//! Development-time-only helper module for exporting private APIs so that they can be benchmarked.
+//! This module is gated behind the "benchmarks" feature.
+
+use crate::common::BytesPerPixel;
+use crate::filter::FilterType;
+
+/// Re-exporting `unfilter` to make it easier to benchmark, despite some items being only
+/// `pub(crate)`: `fn unfilter`, `enum BytesPerPixel`.
+pub fn unfilter(filter: FilterType, tbpp: u8, previous: &[u8], current: &mut [u8]) {
+ let tbpp = BytesPerPixel::from_usize(tbpp as usize);
+ crate::filter::unfilter(filter, tbpp, previous, current)
+}

src/common.rs

@@ -594,15 +594,7 @@ impl Info<'_> {
  /// has the consequence that the number of possible values is rather small. To make this fact
  /// more obvious in the type system and the optimizer we use an explicit enum here.
  pub(crate) fn bpp_in_prediction(&self) -> BytesPerPixel {
- match self.bytes_per_pixel() {
- 1 => BytesPerPixel::One,
- 2 => BytesPerPixel::Two,
- 3 => BytesPerPixel::Three,
- 4 => BytesPerPixel::Four,
- 6 => BytesPerPixel::Six, // Only rgb×16bit
- 8 => BytesPerPixel::Eight, // Only rgba×16bit
- _ => unreachable!("Not a possible byte rounded pixel width"),
- }
+ BytesPerPixel::from_usize(self.bytes_per_pixel())
  }
 
  /// Returns the number of bytes needed for one deinterlaced image.
@@ -695,6 +687,18 @@ impl Info<'_> {
 }
 
 impl BytesPerPixel {
+ pub(crate) fn from_usize(bpp: usize) -> Self {
+ match bpp {
+ 1 => BytesPerPixel::One,
+ 2 => BytesPerPixel::Two,
+ 3 => BytesPerPixel::Three,
+ 4 => BytesPerPixel::Four,
+ 6 => BytesPerPixel::Six, // Only rgb×16bit
+ 8 => BytesPerPixel::Eight, // Only rgba×16bit
+ _ => unreachable!("Not a possible byte rounded pixel width"),
+ }
+ }
+
  pub(crate) fn into_usize(self) -> usize {
  self as usize
  }

src/lib.rs

@@ -79,3 +79,6 @@ pub use crate::decoder::{
 };
 pub use crate::encoder::{Encoder, EncodingError, StreamWriter, Writer};
 pub use crate::filter::{AdaptiveFilterType, FilterType};
+
+#[cfg(feature = "benchmarks")]
+pub mod benchable_apis;