From 7a73708a5678a8ee5b237448ea765479b3c54f02 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 25 Mar 2021 12:14:27 +1100 Subject: [PATCH] Have script/bench-*-png convert to BGRA MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit On a mid-range x86_64 laptop: Compared to the previous commit: go_decode_19k_8bpp 39.3MB/s ± 1% 39.4MB/s ± 1% ~ (p=0.548 n=5+5) go_decode_40k_24bpp 46.5MB/s ± 1% 46.7MB/s ± 1% ~ (p=0.095 n=5+5) go_decode_77k_8bpp 78.3MB/s ± 0% 78.3MB/s ± 0% ~ (p=0.286 n=4+5) go_decode_552k_32bpp_verify_checksum 120MB/s ± 1% 118MB/s ± 0% ~ (p=0.056 n=5+5) go_decode_4002k_24bpp 50.7MB/s ± 0% 50.5MB/s ± 0% -0.58% (p=0.016 n=5+4) rust_decode_19k_8bpp 88.3MB/s ± 0% 89.8MB/s ± 0% +1.76% (p=0.008 n=5+5) rust_decode_40k_24bpp 133MB/s ± 0% 122MB/s ± 0% -8.58% (p=0.008 n=5+5) rust_decode_77k_8bpp 180MB/s ± 0% 158MB/s ± 0% -12.04% (p=0.008 n=5+5) rust_decode_552k_32bpp_verify_checksum 146MB/s ± 0% 136MB/s ± 0% -6.59% (p=0.016 n=4+5) rust_decode_4002k_24bpp 134MB/s ± 0% 122MB/s ± 0% -9.02% (p=0.008 n=5+5) Compared to libpng (the C library): libpng_decode_19k_8bpp 58.0MB/s ± 0% 1.00x libpng_decode_40k_24bpp 73.1MB/s ± 0% 1.00x libpng_decode_77k_8bpp 177MB/s ± 0% 1.00x libpng_decode_552k_32bpp_verify_checksum 146MB/s ± 0% 1.00x libpng_decode_4002k_24bpp 104MB/s ± 0% 1.00x go_decode_19k_8bpp/go1.16 39.4MB/s ± 1% 0.68x go_decode_40k_24bpp/go1.16 46.7MB/s ± 1% 0.64x go_decode_77k_8bpp/go1.16 78.3MB/s ± 0% 0.44x go_decode_552k_32bpp_verify_checksum/go1.16 118MB/s ± 0% 0.81x go_decode_4002k_24bpp/go1.16 50.5MB/s ± 0% 0.49x rust_decode_19k_8bpp/rust1.48 89.8MB/s ± 0% 1.55x rust_decode_40k_24bpp/rust1.48 122MB/s ± 0% 1.67x rust_decode_77k_8bpp/rust1.48 158MB/s ± 0% 0.89x rust_decode_552k_32bpp_verify_checksum/rust1.48 136MB/s ± 0% 0.93x rust_decode_4002k_24bpp/rust1.48 122MB/s ± 0% 1.17x --- script/bench-go-png/main.go | 25 ++++++++------ script/bench-rust-png/src/main.rs | 54 ++++++++++++++++++++++--------- 2 files changed, 54 insertions(+), 25 deletions(-) diff --git a/script/bench-go-png/main.go b/script/bench-go-png/main.go index 5c5c0369..930a9458 100644 --- a/script/bench-go-png/main.go +++ b/script/bench-go-png/main.go @@ -99,13 +99,13 @@ func main1() error { start := time.Now() iters := uint64(tc.itersUnscaled) * iterscale - bgra := strings.HasSuffix(tc.benchname, "_77k_8bpp") - numBytes, err := decode(tc.src, bgra) + expandPalette := strings.HasSuffix(tc.benchname, "_77k_8bpp") + numBytes, err := decode(tc.src, expandPalette) if err != nil { return err } for j := uint64(1); j < iters; j++ { - decode(tc.src, bgra) + decode(tc.src, expandPalette) } elapsedNanos := time.Since(start) @@ -124,7 +124,7 @@ func main1() error { return nil } -func decode(src []byte, bgra bool) (numBytes uint64, retErr error) { +func decode(src []byte, expandPalette bool) (numBytes uint64, retErr error) { m, err := png.Decode(bytes.NewReader(src)) if err != nil { return 0, err @@ -133,25 +133,32 @@ func decode(src []byte, bgra bool) (numBytes uint64, retErr error) { b := m.Bounds() n := uint64(b.Dx()) * uint64(b.Dy()) - // Go converts to RGBA (as that's what Go's image/draw standard library is - // optimized for); Wuffs converts to BGRA. The difference isn't important, - // as we just want measure how long it takes. - if bgra { + if expandPalette { dst := image.NewRGBA(b) draw.Draw(dst, b, m, b.Min, draw.Src) m = dst } - switch m.(type) { + pix := []byte(nil) + switch m := m.(type) { case *image.Gray: n *= 1 case *image.NRGBA: n *= 4 + pix = m.Pix case *image.RGBA: n *= 4 + pix = m.Pix default: return 0, fmt.Errorf("unexpected image type %T", m) } + // Convert RGBA => BGRA. + if pix != nil { + for i, iEnd := 0, len(pix)/4; i < iEnd; i += 4 { + pix[(4*i)+0], pix[(4*i)+2] = pix[(4*i)+2], pix[(4*i)+0] + } + } + return n, nil } diff --git a/script/bench-rust-png/src/main.rs b/script/bench-rust-png/src/main.rs index 5bd7348e..fe8ed7d0 100644 --- a/script/bench-rust-png/src/main.rs +++ b/script/bench-rust-png/src/main.rs @@ -46,13 +46,15 @@ fn main() { print!("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n"); print!("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n"); - let mut dst = vec![0u8; 64 * 1024 * 1024]; + let mut dst0 = vec![0u8; 64 * 1024 * 1024]; + let mut dst1 = vec![0u8; 64 * 1024 * 1024]; // The various magic constants below are copied from test/c/std/png.c for i in 0..(1 + REPS) { bench( "19k_8bpp", - &mut dst[..], + &mut dst0[..], + &mut dst1[..], include_bytes!("../../../test/data/bricks-gray.no-ancillary.png"), i == 0, // warm_up 160 * 120 * 1, // want_num_bytes = 19_200 @@ -61,7 +63,8 @@ fn main() { bench( "40k_24bpp", - &mut dst[..], + &mut dst0[..], + &mut dst1[..], include_bytes!("../../../test/data/hat.png"), i == 0, // warm_up 90 * 112 * 4, // want_num_bytes = 40_320 @@ -70,7 +73,8 @@ fn main() { bench( "77k_8bpp", - &mut dst[..], + &mut dst0[..], + &mut dst1[..], include_bytes!("../../../test/data/bricks-dither.png"), i == 0, // warm_up 160 * 120 * 4, // want_num_bytes = 76_800 @@ -79,7 +83,8 @@ fn main() { bench( "552k_32bpp_verify_checksum", - &mut dst[..], + &mut dst0[..], + &mut dst1[..], include_bytes!("../../../test/data/hibiscus.primitive.png"), i == 0, // warm_up 312 * 442 * 4, // want_num_bytes = 551_616 @@ -88,7 +93,8 @@ fn main() { bench( "4002k_24bpp", - &mut dst[..], + &mut dst0[..], + &mut dst1[..], include_bytes!("../../../test/data/harvesters.png"), i == 0, // warm_up 1165 * 859 * 4, // want_num_bytes = 4_002_940 @@ -99,7 +105,8 @@ fn main() { fn bench( name: &str, // Benchmark name. - dst: &mut [u8], // Destination buffer. + dst0: &mut [u8], // Destination buffer #0. + dst1: &mut [u8], // Destination buffer #1. src: &[u8], // Source data. warm_up: bool, // Whether this is a warm up rep. want_num_bytes: u64, // Expected num_bytes per iteration. @@ -110,7 +117,7 @@ fn bench( let start = Instant::now(); for _ in 0..iters { - let n = decode(&mut dst[..], src); + let n = decode(&mut dst0[..], &mut dst1[..], src); if n != want_num_bytes { panic!("num_bytes: got {}, want {}", n, want_num_bytes); } @@ -136,17 +143,32 @@ fn bench( } // decode returns the number of bytes processed. -fn decode(dst: &mut [u8], src: &[u8]) -> u64 { +fn decode(dst0: &mut [u8], dst1: &mut [u8], src: &[u8]) -> u64 { let decoder = png::Decoder::new(src); let (info, mut reader) = decoder.read_info().unwrap(); let num_bytes = info.buffer_size() as u64; - reader.next_frame(dst).unwrap(); - if info.color_type == png::ColorType::RGB { - // If the PNG image is RGB (not RGBA) then Rust's png crate will decode - // to 3 bytes per pixel. Wuffs' std/png benchmarks decode to 4 bytes - // per pixel (and in BGRA order, not RGB or RGBA). We'll hand-wave the - // difference away and say that we decoded 33% more pixels than we did. + reader.next_frame(dst0).unwrap(); + if info.color_type == png::ColorType::Grayscale { + // No conversion necessary. + return num_bytes; + } else if info.color_type == png::ColorType::RGB { + // Convert RGB => BGRA. + for i in 0..((num_bytes / 3) as usize) { + dst1[(4 * i) + 0] = dst0[(3 * i) + 2]; + dst1[(4 * i) + 1] = dst0[(3 * i) + 1]; + dst1[(4 * i) + 2] = dst0[(3 * i) + 0]; + dst1[(4 * i) + 3] = 0xFF; + } return (num_bytes / 3) * 4; + } else if info.color_type == png::ColorType::RGBA { + // Convert RGBA => BGRA. + for i in 0..((num_bytes / 4) as usize) { + let d = dst0[(4 * i) + 0]; + dst0[(4 * i) + 0] = dst0[(4 * i) + 2]; + dst0[(4 * i) + 2] = d; + } + return num_bytes; } - num_bytes + // Returning 0 should lead to a panic (when want_num_bytes != 0). + 0 }