diff --git a/script/bench-go-png/main.go b/script/bench-go-png/main.go new file mode 100644 index 00000000..5c5c0369 --- /dev/null +++ b/script/bench-go-png/main.go @@ -0,0 +1,157 @@ +// Copyright 2021 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build ignore + +package main + +// This program exercises the Go standard library's PNG decoder. +// +// Wuffs' C code doesn't depend on Go per se, but this program gives some +// performance data for specific Go PNG implementations. The equivalent Wuffs +// benchmarks (on the same test images) are run via: +// +// wuffs bench std/png + +import ( + "bytes" + "fmt" + "image" + "image/draw" + "image/png" + "io/ioutil" + "os" + "runtime" + "strings" + "time" +) + +const ( + iterscale = 20 + reps = 5 +) + +type testCase = struct { + benchname string + src []byte + itersUnscaled uint32 +} + +var testCases = []testCase{{ + benchname: "go_png_decode_image_19k_8bpp", + src: mustLoad("test/data/bricks-gray.no-ancillary.png"), + itersUnscaled: 50, +}, { + benchname: "go_png_decode_image_40k_24bpp", + src: mustLoad("test/data/hat.png"), + itersUnscaled: 50, +}, { + benchname: "go_png_decode_image_77k_8bpp", + src: mustLoad("test/data/bricks-dither.png"), + itersUnscaled: 50, +}, { + benchname: "go_png_decode_image_552k_32bpp_verify_checksum", + src: mustLoad("test/data/hibiscus.primitive.png"), + itersUnscaled: 4, +}, { + benchname: "go_png_decode_image_4002k_24bpp", + src: mustLoad("test/data/harvesters.png"), + itersUnscaled: 1, +}} + +func mustLoad(filename string) []byte { + src, err := ioutil.ReadFile("../../" + filename) + if err != nil { + panic(err.Error()) + } + return src +} + +func main() { + if err := main1(); err != nil { + os.Stderr.WriteString(err.Error() + "\n") + os.Exit(1) + } +} + +func main1() error { + fmt.Printf("# Go %s\n", runtime.Version()) + fmt.Printf("#\n") + fmt.Printf("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n") + fmt.Printf("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n") + fmt.Printf("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n") + + for i := -1; i < reps; i++ { + for _, tc := range testCases { + runtime.GC() + + start := time.Now() + + iters := uint64(tc.itersUnscaled) * iterscale + bgra := strings.HasSuffix(tc.benchname, "_77k_8bpp") + numBytes, err := decode(tc.src, bgra) + if err != nil { + return err + } + for j := uint64(1); j < iters; j++ { + decode(tc.src, bgra) + } + + elapsedNanos := time.Since(start) + + kbPerS := numBytes * uint64(iters) * 1000000 / uint64(elapsedNanos) + + if i < 0 { + continue // Warm up rep. + } + + fmt.Printf("Benchmark%-30s %8d %12d ns/op %8d.%03d MB/s\n", + tc.benchname, iters, uint64(elapsedNanos)/iters, kbPerS/1000, kbPerS%1000) + } + } + + return nil +} + +func decode(src []byte, bgra bool) (numBytes uint64, retErr error) { + m, err := png.Decode(bytes.NewReader(src)) + if err != nil { + return 0, err + } + + 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 { + dst := image.NewRGBA(b) + draw.Draw(dst, b, m, b.Min, draw.Src) + m = dst + } + + switch m.(type) { + case *image.Gray: + n *= 1 + case *image.NRGBA: + n *= 4 + case *image.RGBA: + n *= 4 + default: + return 0, fmt.Errorf("unexpected image type %T", m) + } + + return n, nil +} diff --git a/script/bench-rust-png/Cargo.toml b/script/bench-rust-png/Cargo.toml new file mode 100644 index 00000000..3664f3ec --- /dev/null +++ b/script/bench-rust-png/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "bench_rust_png" +version = "0.0.1" +authors = ["Nigel Tao "] + +[dependencies] +png = "*" +rustc_version_runtime = "*" diff --git a/script/bench-rust-png/src/main.rs b/script/bench-rust-png/src/main.rs new file mode 100644 index 00000000..5bd7348e --- /dev/null +++ b/script/bench-rust-png/src/main.rs @@ -0,0 +1,152 @@ +// Copyright 2021 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// ---------------- + +// This program exercises the Rust PNG decoder at +// https://github.com/image-rs/image-png +// which is the top result for https://crates.io/search?q=png&sort=downloads +// +// Wuffs' C code doesn't depend on Rust per se, but this program gives some +// performance data for specific Rust PNG implementations. The equivalent Wuffs +// benchmarks (on the same test images) are run via: +// +// wuffs bench std/png +// +// To run this program, do "cargo run --release" from the parent directory (the +// directory containing the Cargo.toml file). + +extern crate png; +extern crate rustc_version_runtime; + +use std::time::Instant; + +const ITERSCALE: u64 = 50; +const REPS: u64 = 5; + +fn main() { + let version = rustc_version_runtime::version(); + print!( + "# Rust {}.{}.{}\n", + version.major, version.minor, version.patch, + ); + print!("#\n"); + print!("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n"); + 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]; + + // The various magic constants below are copied from test/c/std/png.c + for i in 0..(1 + REPS) { + bench( + "19k_8bpp", + &mut dst[..], + include_bytes!("../../../test/data/bricks-gray.no-ancillary.png"), + i == 0, // warm_up + 160 * 120 * 1, // want_num_bytes = 19_200 + 50, // iters_unscaled + ); + + bench( + "40k_24bpp", + &mut dst[..], + include_bytes!("../../../test/data/hat.png"), + i == 0, // warm_up + 90 * 112 * 4, // want_num_bytes = 40_320 + 30, // iters_unscaled + ); + + bench( + "77k_8bpp", + &mut dst[..], + include_bytes!("../../../test/data/bricks-dither.png"), + i == 0, // warm_up + 160 * 120 * 4, // want_num_bytes = 76_800 + 30, // iters_unscaled + ); + + bench( + "552k_32bpp_verify_checksum", + &mut dst[..], + include_bytes!("../../../test/data/hibiscus.primitive.png"), + i == 0, // warm_up + 312 * 442 * 4, // want_num_bytes = 551_616 + 4, // iters_unscaled + ); + + bench( + "4002k_24bpp", + &mut dst[..], + include_bytes!("../../../test/data/harvesters.png"), + i == 0, // warm_up + 1165 * 859 * 4, // want_num_bytes = 4_002_940 + 1, // iters_unscaled + ); + } +} + +fn bench( + name: &str, // Benchmark name. + dst: &mut [u8], // Destination buffer. + src: &[u8], // Source data. + warm_up: bool, // Whether this is a warm up rep. + want_num_bytes: u64, // Expected num_bytes per iteration. + iters_unscaled: u64, // Base number of iterations. +) { + let iters = iters_unscaled * ITERSCALE; + let mut total_num_bytes = 0u64; + + let start = Instant::now(); + for _ in 0..iters { + let n = decode(&mut dst[..], src); + if n != want_num_bytes { + panic!("num_bytes: got {}, want {}", n, want_num_bytes); + } + total_num_bytes += n; + } + let elapsed = start.elapsed(); + + let elapsed_nanos = (elapsed.as_secs() * 1_000_000_000) + (elapsed.subsec_nanos() as u64); + let kb_per_s: u64 = total_num_bytes * 1_000_000 / elapsed_nanos; + + if warm_up { + return; + } + + print!( + "Benchmarkrust_png_decode_image_{:16} {:8} {:12} ns/op {:3}.{:03} MB/s\n", + name, + iters, + elapsed_nanos / iters, + kb_per_s / 1_000, + kb_per_s % 1_000 + ); +} + +// decode returns the number of bytes processed. +fn decode(dst: &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. + return (num_bytes / 3) * 4; + } + num_bytes +} diff --git a/test/c/mimiclib/png.c b/test/c/mimiclib/png.c index 32acd633..2b3396b4 100644 --- a/test/c/mimiclib/png.c +++ b/test/c/mimiclib/png.c @@ -14,10 +14,18 @@ // ---------------- -// Uncomment this line to test and bench libspng instead of libpng. +// Uncomment one of these #define lines to test and bench alternative mimic +// libraries (libspng, lodepng or stb_image) instead of libpng. +// +// These are collectively referred to as +// WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_LIBPNG. +// // #define WUFFS_MIMICLIB_USE_LIBSPNG_INSTEAD_OF_LIBPNG 1 +// #define WUFFS_MIMICLIB_USE_LODEPNG_INSTEAD_OF_LIBPNG 1 +// #define WUFFS_MIMICLIB_USE_STB_IMAGE_INSTEAD_OF_LIBPNG 1 -#ifdef WUFFS_MIMICLIB_USE_LIBSPNG_INSTEAD_OF_LIBPNG +// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_LIBPNG +#if defined(WUFFS_MIMICLIB_USE_LIBSPNG_INSTEAD_OF_LIBPNG) // We #include a foo.c file, not a foo.h file, as libspng is a "single file C // library". @@ -26,6 +34,9 @@ // We deliberately do not define the // WUFFS_MIMICLIB_PNG_DOES_NOT_SUPPORT_QUIRK_IGNORE_CHECKSUM macro. +// We deliberately do not define the +// WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_CHECKSUM macro. + // libspng (version 0.6.2, released November 2020) calculates but does not // verify the CRC-32 checksum on the final IDAT chunk. It also does not verify // the Adler-32 checksum. After calling spng_decode_image, it ends in @@ -68,6 +79,7 @@ mimic_png_decode(uint64_t* n_bytes_out, } int fmt = 0; + bool swap_bgra_rgba = false; switch (pixfmt.repr) { case WUFFS_BASE__PIXEL_FORMAT__Y: fmt = SPNG_FMT_G8; @@ -76,6 +88,7 @@ mimic_png_decode(uint64_t* n_bytes_out, // libspng doesn't do BGRA8. RGBA8 is the closest approximation. We'll // fix it up later. fmt = SPNG_FMT_RGBA8; + swap_bgra_rgba = true; break; default: ret = "mimic_png_decode: unsupported pixfmt"; @@ -103,7 +116,7 @@ mimic_png_decode(uint64_t* n_bytes_out, } // Fix up BGRA8 vs RGBA8. - if (fmt == SPNG_FMT_RGBA8) { + if (swap_bgra_rgba) { for (; n >= 4; n -= 4) { uint8_t swap = dst_ptr[0]; dst_ptr[0] = dst_ptr[2]; @@ -117,11 +130,205 @@ cleanup0:; return ret; } -#else // WUFFS_MIMICLIB_USE_LIBSPNG_INSTEAD_OF_LIBPNG +// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_LIBPNG +#elif defined(WUFFS_MIMICLIB_USE_LODEPNG_INSTEAD_OF_LIBPNG) + +// We #include a foo.cpp file, not a foo.h file, as lodepng is a "single file +// C++ library". +#include "/path/to/your/copy/of/github.com/lvandeve/lodepng/lodepng.cpp" + +#define WUFFS_MIMICLIB_PNG_DOES_NOT_SUPPORT_QUIRK_IGNORE_CHECKSUM 1 + +// We deliberately do not define the +// WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_CHECKSUM macro. + +// We deliberately do not define the +// WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_FINAL_IDAT_CHECKSUMS macro. + +const char* // +mimic_png_decode(uint64_t* n_bytes_out, + wuffs_base__io_buffer* dst, + uint32_t wuffs_initialize_flags, + wuffs_base__pixel_format pixfmt, + uint32_t* quirks_ptr, + size_t quirks_len, + wuffs_base__io_buffer* src) { + wuffs_base__io_buffer dst_fallback = + wuffs_base__slice_u8__writer(g_mimiclib_scratch_slice_u8); + if (!dst) { + dst = &dst_fallback; + } + + uint64_t n = 0; + LodePNGColorType color_type = 0; + unsigned int bitdepth = 8; + bool swap_bgra_rgba = false; + switch (pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + n = 1; + color_type = LCT_GREY; + break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + n = 4; + // lodepng doesn't do BGRA8. RGBA8 is the closest approximation. We'll + // fix it up later. + color_type = LCT_RGBA; + swap_bgra_rgba = true; + break; + default: + return "mimic_png_decode: unsupported pixfmt"; + } + + unsigned char* output = 0; + unsigned int width = 0; + unsigned int height = 0; + unsigned int err = + lodepng_decode_memory(&output, &width, &height, // + wuffs_base__io_buffer__reader_pointer(src), // + wuffs_base__io_buffer__reader_length(src), // + color_type, bitdepth); + if (err) { + return lodepng_error_text(err); + } + + const char* ret = NULL; + + if ((width > 0xFFFF) || (height > 0xFFFF)) { + ret = "mimic_png_decode: image is too large"; + goto cleanup0; + } + n *= ((uint64_t)width) * ((uint64_t)height); + if (n > wuffs_base__io_buffer__writer_length(dst)) { + ret = "mimic_png_decode: image is too large"; + goto cleanup0; + } + + // Copy from the mimic library's output buffer to Wuffs' dst buffer. + uint8_t* dst_ptr = wuffs_base__io_buffer__writer_pointer(dst); + memcpy(dst_ptr, output, n); + dst->meta.wi += n; + if (n_bytes_out) { + *n_bytes_out += n; + } + + // Fix up BGRA8 vs RGBA8. + if (swap_bgra_rgba) { + for (; n >= 4; n -= 4) { + uint8_t swap = dst_ptr[0]; + dst_ptr[0] = dst_ptr[2]; + dst_ptr[2] = swap; + dst_ptr += 4; + } + } + +cleanup0:; + free(output); + return ret; +} + +// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_LIBPNG +#elif defined(WUFFS_MIMICLIB_USE_STB_IMAGE_INSTEAD_OF_LIBPNG) + +// We #include a foo.cpp file, not a foo.h file, as stb_image is a "single file +// C library". +#define STB_IMAGE_IMPLEMENTATION +#include "/path/to/your/copy/of/github.com/nothings/stb/stb_image.h" + +// We deliberately do not define the +// WUFFS_MIMICLIB_PNG_DOES_NOT_SUPPORT_QUIRK_IGNORE_CHECKSUM macro. The +// stb_image library always ignores checksums. + +#define WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_CHECKSUM 1 + +// We deliberately do not define the +// WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_FINAL_IDAT_CHECKSUMS macro. + +const char* // +mimic_png_decode(uint64_t* n_bytes_out, + wuffs_base__io_buffer* dst, + uint32_t wuffs_initialize_flags, + wuffs_base__pixel_format pixfmt, + uint32_t* quirks_ptr, + size_t quirks_len, + wuffs_base__io_buffer* src) { + wuffs_base__io_buffer dst_fallback = + wuffs_base__slice_u8__writer(g_mimiclib_scratch_slice_u8); + if (!dst) { + dst = &dst_fallback; + } + + uint64_t n = 0; + bool swap_bgra_rgba = false; + switch (pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + n = 1; + break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + n = 4; + // stb_image doesn't do BGRA8. RGBA8 is the closest approximation. We'll + // fix it up later. + swap_bgra_rgba = true; + break; + default: + return "mimic_png_decode: unsupported pixfmt"; + } + + int width = 0; + int height = 0; + int channels_in_file = 0; + unsigned char* output = + stbi_load_from_memory(wuffs_base__io_buffer__reader_pointer(src), // + wuffs_base__io_buffer__reader_length(src), // + &width, &height, &channels_in_file, n); + if (!output) { + return "mimic_png_decode: could not load image"; + } + + const char* ret = NULL; + + if ((width > 0xFFFF) || (height > 0xFFFF)) { + ret = "mimic_png_decode: image is too large"; + goto cleanup0; + } + n *= ((uint64_t)width) * ((uint64_t)height); + if (n > wuffs_base__io_buffer__writer_length(dst)) { + ret = "mimic_png_decode: image is too large"; + goto cleanup0; + } + + // Copy from the mimic library's output buffer to Wuffs' dst buffer. + uint8_t* dst_ptr = wuffs_base__io_buffer__writer_pointer(dst); + memcpy(dst_ptr, output, n); + dst->meta.wi += n; + if (n_bytes_out) { + *n_bytes_out += n; + } + + // Fix up BGRA8 vs RGBA8. + if (swap_bgra_rgba) { + for (; n >= 4; n -= 4) { + uint8_t swap = dst_ptr[0]; + dst_ptr[0] = dst_ptr[2]; + dst_ptr[2] = swap; + dst_ptr += 4; + } + } + +cleanup0:; + stbi_image_free(output); + return ret; +} + +// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_LIBPNG +#else + #include "png.h" #define WUFFS_MIMICLIB_PNG_DOES_NOT_SUPPORT_QUIRK_IGNORE_CHECKSUM 1 +// We deliberately do not define the +// WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_CHECKSUM macro. + // We deliberately do not define the // WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_FINAL_IDAT_CHECKSUMS macro. @@ -201,4 +408,6 @@ cleanup0:; png_image_free(&pi); return ret; } -#endif // WUFFS_MIMICLIB_USE_LIBSPNG_INSTEAD_OF_LIBPNG + +#endif +// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_LIBPNG diff --git a/test/c/std/png.c b/test/c/std/png.c index 6adda6da..b4e94a94 100644 --- a/test/c/std/png.c +++ b/test/c/std/png.c @@ -815,7 +815,9 @@ proc g_tests[] = { #ifdef WUFFS_MIMIC test_mimic_png_decode_bad_crc32_checksum_ancillary, +#ifndef WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_CHECKSUM test_mimic_png_decode_bad_crc32_checksum_critical, +#endif test_mimic_png_decode_image_19k_8bpp, test_mimic_png_decode_image_40k_24bpp, test_mimic_png_decode_image_77k_8bpp, @@ -852,7 +854,9 @@ proc g_benches[] = { #ifndef WUFFS_MIMICLIB_PNG_DOES_NOT_SUPPORT_QUIRK_IGNORE_CHECKSUM bench_mimic_png_decode_image_552k_32bpp_ignore_checksum, #endif +#ifndef WUFFS_MIMICLIB_PNG_DOES_NOT_VERIFY_CHECKSUM bench_mimic_png_decode_image_552k_32bpp_verify_checksum, +#endif bench_mimic_png_decode_image_4002k_24bpp, #endif // WUFFS_MIMIC