From e071e171ccca4f32b6c287db412a7a15255d1892 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 12 Jan 2019 14:38:17 +1100 Subject: [PATCH] Have bench-go-gif process multiple images --- script/bench-go-gif/main.go | 152 ++++++++++++++++++++++++++---------- 1 file changed, 110 insertions(+), 42 deletions(-) diff --git a/script/bench-go-gif/main.go b/script/bench-go-gif/main.go index 66efb5ba..d79cb764 100644 --- a/script/bench-go-gif/main.go +++ b/script/bench-go-gif/main.go @@ -20,34 +20,71 @@ package main // // Wuffs' C code doesn't depend on Go per se, but this program gives some // performance data for specific Go GIF implementations. The equivalent Wuffs -// benchmarks (on the same test image) are run via: +// benchmarks (on the same test images) are run via: // -// wuffs bench -mimic -focus=wuffs_gif_decode_1000k,mimic_gif_decode_1000k std/gif -// -// The "1000k" is because the test image (harvesters.gif) has approximately 1 -// million pixels. -// -// The Wuffs benchmark reports megabytes per second. This program reports -// megapixels per second. The two concepts should be equivalent, since GIF -// images' pixel data are always 1 byte per pixel indices into a color palette. +// wuffs bench std/gif import ( "bytes" "fmt" "image" + "image/draw" "image/gif" "io/ioutil" "os" + "runtime" + "strings" "time" ) -// These constants are hard-coded to the harvesters.gif test image. -const WIDTH = 1165 -const HEIGHT = 859 -const BYTES_PER_PIXEL = 1 // Palette index. -const NUM_BYTES = WIDTH * HEIGHT * BYTES_PER_PIXEL -const FIRST_PIXEL = 0 // Top left pixel's palette index is 0x00. -const LAST_PIXEL = 1 // Bottom right pixel's palette index is 0x01. +const ( + iterscale = 20 + reps = 5 +) + +type testCase = struct { + benchname string + filename string + itersUnscaled uint32 +} + +var testCases = []testCase{{ + benchname: "go_gif_decode_1k_bw", + filename: "test/data/pjw-thumbnail.gif", + itersUnscaled: 2000, +}, { + benchname: "go_gif_decode_1k_color", + filename: "test/data/hippopotamus.regular.gif", + itersUnscaled: 1000, +}, { + benchname: "go_gif_decode_10k_bgra", + filename: "test/data/hat.gif", + itersUnscaled: 100, +}, { + benchname: "go_gif_decode_10k_indexed", + filename: "test/data/hat.gif", + itersUnscaled: 100, +}, { + benchname: "go_gif_decode_20k", + filename: "test/data/bricks-gray.gif", + itersUnscaled: 50, +}, { + benchname: "go_gif_decode_100k_artificial", + filename: "test/data/hibiscus.primitive.gif", + itersUnscaled: 15, +}, { + benchname: "go_gif_decode_100k_realistic", + filename: "test/data/hibiscus.regular.gif", + itersUnscaled: 10, +}, { + benchname: "go_gif_decode_1000k", + filename: "test/data/harvesters.gif", + itersUnscaled: 1, +}, { + benchname: "go_gif_decode_anim_screencap", + filename: "test/data/gifplayer-muybridge.gif", + itersUnscaled: 1, +}} func main() { if err := main1(); err != nil { @@ -57,39 +94,70 @@ func main() { } func main1() error { - src, err := ioutil.ReadFile("../../test/data/harvesters.gif") - if err != nil { - return err + 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 { + src, err := ioutil.ReadFile("../../" + tc.filename) + if err != nil { + return err + } + + runtime.GC() + + start := time.Now() + + iters := uint64(tc.itersUnscaled) * iterscale + bgra := strings.HasSuffix(tc.benchname, "_bgra") + numBytes, err := decode(src, bgra) + if err != nil { + return err + } + for i := uint64(1); i < iters; i++ { + decode(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) + } } - start := time.Now() - - const REPS = 50 - for i := 0; i < REPS; i++ { - decode(src) - } - - elapsedNanos := time.Since(start) - - totalPixels := uint64(WIDTH * HEIGHT * REPS) - kpPerS := totalPixels * 1000000 / uint64(elapsedNanos) - - fmt.Printf("Go %3d.%03d megapixels/second\n", kpPerS/1000, kpPerS%1000) return nil } -func decode(src []byte) { - img, err := gif.Decode(bytes.NewReader(src)) +func decode(src []byte, bgra bool) (numBytes uint64, retErr error) { + g, err := gif.DecodeAll(bytes.NewReader(src)) if err != nil { - panic(err) - } - m := img.(*image.Paletted) - if len(m.Pix) != NUM_BYTES { - panic("wrong num_bytes") + return 0, err } - // A hard-coded sanity check that we decoded the pixel data correctly. - if (m.Pix[0] != FIRST_PIXEL) || (m.Pix[NUM_BYTES-1] != LAST_PIXEL) { - panic("wrong dst pixels") + for _, m := range g.Image { + 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) + n *= 4 + } + + numBytes += n } + + return numBytes, nil }