diff --git a/script/bench-go-jpeg/main.go b/script/bench-go-jpeg/main.go new file mode 100644 index 00000000..2e0ba0ff --- /dev/null +++ b/script/bench-go-jpeg/main.go @@ -0,0 +1,164 @@ +// Copyright 2023 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. + +//go:build ignore +// +build ignore + +package main + +// This program exercises the Go standard library's JPEG decoder. +// +// Wuffs' C code doesn't depend on Go per se, but this program gives some +// performance data for specific Go JPEG implementations. The equivalent Wuffs +// benchmarks (on the same test images) are run via: +// +// wuffs bench std/jpeg + +import ( + "bytes" + "fmt" + "image" + "image/draw" + "image/jpeg" + "os" + "runtime" + "time" +) + +const ( + iterscale = 20 + reps = 5 +) + +type testCase = struct { + benchname string + src []byte + itersUnscaled uint32 +} + +var testCases = []testCase{{ + benchname: "go_jpeg_decode_19k_8bpp", + src: mustLoad("test/data/bricks-gray.jpeg"), + itersUnscaled: 100, +}, { + benchname: "go_jpeg_decode_30k_24bpp_progressive", + src: mustLoad("test/data/peacock.progressive.jpeg"), + itersUnscaled: 50, +}, { + benchname: "go_jpeg_decode_30k_24bpp_sequential", + src: mustLoad("test/data/peacock.default.jpeg"), + itersUnscaled: 50, +}, { + benchname: "go_jpeg_decode_77k_24bpp", + src: mustLoad("test/data/bricks-color.jpeg"), + itersUnscaled: 30, +}, { + benchname: "go_jpeg_decode_552k_24bpp", + src: mustLoad("test/data/hibiscus.regular.jpeg"), + itersUnscaled: 5, +}, { + benchname: "go_jpeg_decode_4002k_24bpp", + src: mustLoad("test/data/harvesters.jpeg"), + itersUnscaled: 1, +}} + +func mustLoad(filename string) []byte { + src, err := os.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 install 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 + numBytes, err := decode(tc.src) + if err != nil { + return err + } + for j := uint64(1); j < iters; j++ { + decode(tc.src) + } + + 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) (numBytes uint64, retErr error) { + m, err := jpeg.Decode(bytes.NewReader(src)) + if err != nil { + return 0, err + } + + b := m.Bounds() + n := uint64(b.Dx()) * uint64(b.Dy()) + + // Convert YCbCr to RGBA. + if _, ok := m.(*image.YCbCr); ok { + dst := image.NewRGBA(b) + draw.Draw(dst, b, m, b.Min, draw.Src) + m = dst + } + + pix := []byte(nil) + switch m := m.(type) { + case *image.Gray: + n *= 1 + 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 +}