go-libwebp

main.go (11767B)

---

 // Command bench compares libwebp backends — native shared object (SIMD and
 // scalar), WebAssembly under wazero, and the ccgo transpilation — across a
 // corpus of synthetic images chosen to exercise different codec paths.
 package main
 
 import (
 	"bytes"
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"flag"
 	"fmt"
 	"image"
 	"image/png"
 	"math"
 	"os"
 	"path/filepath"
 	"sort"
 	"strings"
 	"time"
 
 	"git.sr.ht/~jackmordaunt/go-libwebp/v2/lib/common"
 	transpiled "git.sr.ht/~jackmordaunt/go-libwebp/v2/lib/transpiled/webp"
 	wasmwebp "git.sr.ht/~jackmordaunt/go-libwebp/v2/lib/wasm/webp"
 	"github.com/ebitengine/purego"
 )
 
 // Backend is one way of reaching libwebp.
 type Backend struct {
 	Name   string
 	Encode func(m *image.NRGBA, q float32) ([]byte, error)
 	Decode func(data []byte) (image.Image, error)
 }
 
 var (
 	budget   = flag.Duration("budget", 750*time.Millisecond, "time budget per measurement")
 	minIter  = flag.Int("min-iter", 3, "minimum iterations per measurement")
 	outDir   = flag.String("out", "bench/testdata", "where to write corpus PNGs")
 	soDir    = flag.String("so", "", "directory holding libwebp_simd.so and libwebp_scalar.so")
 	wasmMods = flag.String("wasm", "", "comma-separated name=path.wasm modules to compare")
 	only     = flag.String("only", "", "comma-separated corpus entry names to restrict the run to")
 	noPNG    = flag.Bool("no-png", false, "skip writing corpus PNGs")
 )
 
 func main() {
 	flag.Parse()
 	if *soDir == "" {
 		fmt.Fprintln(os.Stderr, "-so is required")
 		os.Exit(1)
 	}
 
 	corpus := BuildCorpus()
 	if *only != "" {
 		want := map[string]bool{}
 		for _, n := range strings.Split(*only, ",") {
 			want[n] = true
 		}
 		var filtered []Entry
 		for _, e := range corpus {
 			if want[e.Name] {
 				filtered = append(filtered, e)
 			}
 		}
 		if len(filtered) == 0 {
 			fmt.Fprintf(os.Stderr, "-only matched no corpus entries\n")
 			os.Exit(1)
 		}
 		corpus = filtered
 	}
 	if err := dumpPNGs(corpus, *outDir); err != nil {
 		fmt.Fprintf(os.Stderr, "writing corpus: %v\n", err)
 		os.Exit(1)
 	}
 
 	backends, cleanup, err := setupBackends(*soDir)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "setup: %v\n", err)
 		os.Exit(1)
 	}
 	defer cleanup()
 
 	verify(backends, corpus)
 	run(backends, corpus)
 	reportInstantiation(corpus)
 }
 
 func setupBackends(soDir string) ([]Backend, func(), error) {
 	var backends []Backend
 
 	for _, cfg := range []struct{ name, file string }{
 		{"native-simd", "libwebp_simd.so"},
 		{"native-scalar", "libwebp_scalar.so"},
 	} {
 		b, err := loadNative(cfg.name, filepath.Join(soDir, cfg.file))
 		if err != nil {
 			return nil, nil, err
 		}
 		backends = append(backends, b)
 	}
 
 	ctx := context.Background()
 	var closers []func()
 
 	// Each -wasm entry is a separately built module; comparing them isolates
 	// toolchain and SIMD effects from the cost of the sandbox itself.
 	for _, spec := range strings.Split(*wasmMods, ",") {
 		if spec == "" {
 			continue
 		}
 		name, path, ok := strings.Cut(spec, "=")
 		if !ok {
 			return nil, nil, fmt.Errorf("-wasm entry %q is not name=path", spec)
 		}
 		raw, err := os.ReadFile(path)
 		if err != nil {
 			return nil, nil, err
 		}
 		compiled, err := wasmwebp.CompileBytes(ctx, raw)
 		if err != nil {
 			return nil, nil, fmt.Errorf("%s: %w", name, err)
 		}
 		inst, err := compiled.NewInstance(ctx)
 		if err != nil {
 			return nil, nil, fmt.Errorf("%s: %w", name, err)
 		}
 		closers = append(closers, func() { inst.Close(ctx) })
 		backends = append(backends, Backend{
 			Name:   name,
 			Encode: func(m *image.NRGBA, q float32) ([]byte, error) { return inst.Encode(ctx, m, q) },
 			Decode: func(d []byte) (image.Image, error) { return inst.Decode(ctx, d) },
 		})
 	}
 
 	backends = append(backends,
 		Backend{
 			Name: "transpiled",
 			Encode: func(m *image.NRGBA, q float32) ([]byte, error) {
 				var buf bytes.Buffer
 				err := transpiled.EncodeImpl(&buf, m, q)
 				return buf.Bytes(), err
 			},
 			Decode: transpiled.DecodeImpl,
 		},
 	)
 
 	return backends, func() {
 		for _, c := range closers {
 			c()
 		}
 	}, nil
 }
 
 // loadNative binds the four entry points out of a shared object with purego,
 // the same mechanism lib/dynamic uses, but against an explicit path so the
 // SIMD and scalar builds can be compared side by side.
 func loadNative(name, path string) (Backend, error) {
 	h, err := purego.Dlopen(path, purego.RTLD_NOW|purego.RTLD_LOCAL)
 	if err != nil {
 		return Backend{}, fmt.Errorf("dlopen %s: %w", path, err)
 	}
 	var (
 		encodeRGBA     func(in uintptr, w, h, bps int32, q float32, out uintptr) uint64
 		encodeLossless func(in uintptr, w, h, bps int32, out uintptr) uint64
 		decodeRGBA     func(data uintptr, size uint64, w, h uintptr) uintptr
 		webpFree       func(uintptr)
 	)
 	purego.RegisterLibFunc(&encodeRGBA, h, "WebPEncodeRGBA")
 	purego.RegisterLibFunc(&encodeLossless, h, "WebPEncodeLosslessRGBA")
 	purego.RegisterLibFunc(&decodeRGBA, h, "WebPDecodeRGBA")
 	purego.RegisterLibFunc(&webpFree, h, "WebPFree")
 
 	enc := func(in uintptr, w, h, bps int32, q float32, out uintptr) uint64 {
 		if q >= 100 {
 			return encodeLossless(in, w, h, bps, out)
 		}
 		return encodeRGBA(in, w, h, bps, q, out)
 	}
 	return Backend{
 		Name: name,
 		Encode: func(m *image.NRGBA, q float32) ([]byte, error) {
 			var buf bytes.Buffer
 			err := common.Encode(&buf, m, q*100, enc, webpFree)
 			return buf.Bytes(), err
 		},
 		Decode: func(d []byte) (image.Image, error) {
 			return common.Decode(d, decodeRGBA, webpFree)
 		},
 	}, nil
 }
 
 // verify checks that every backend produces byte-identical output for the
 // same input, which is the property the whole per-target build story exists
 // to protect.
 func verify(backends []Backend, corpus []Entry) {
 	fmt.Println("== output equivalence (sha256 of encoded bytes) ==")
 	fmt.Printf("%-18s %-10s %s\n", "image", "mode", "agreement")
 	mismatch := 0
 	for _, e := range corpus {
 		for _, mode := range []struct {
 			name string
 			q    float32
 		}{{"lossless", 1.0}, {"lossy-75", 0.75}} {
 			sums := map[string][]string{}
 			for _, b := range backends {
 				out, err := b.Encode(e.Img, mode.q)
 				if err != nil {
 					fmt.Printf("%-18s %-10s ERROR %s: %v\n", e.Name, mode.name, b.Name, err)
 					mismatch++
 					continue
 				}
 				sum := sha256.Sum256(out)
 				s := hex.EncodeToString(sum[:])
 				sums[s] = append(sums[s], b.Name)
 			}
 			switch len(sums) {
 			case 1:
 				fmt.Printf("%-18s %-10s all identical\n", e.Name, mode.name)
 			default:
 				mismatch++
 				fmt.Printf("%-18s %-10s DIVERGENT:\n", e.Name, mode.name)
 				for s, names := range sums {
 					fmt.Printf("%-18s %-10s   %s  %v\n", "", "", s[:12], names)
 				}
 			}
 		}
 	}
 	if mismatch == 0 {
 		fmt.Println("all backends agree byte-for-byte on every corpus entry")
 	}
 	fmt.Println()
 }
 
 type result struct {
 	image, mode, backend string
 	pixels               int
 	perOp                time.Duration
 	bytes                int
 }
 
 func run(backends []Backend, corpus []Entry) {
 	var results []result
 
 	for _, e := range corpus {
 		px := e.Img.Bounds().Dx() * e.Img.Bounds().Dy()
 
 		for _, mode := range []struct {
 			name string
 			q    float32
 		}{{"encode-lossless", 1.0}, {"encode-lossy75", 0.75}} {
 			for _, b := range backends {
 				var size int
 				d := measure(func() {
 					out, err := b.Encode(e.Img, mode.q)
 					if err != nil {
 						panic(fmt.Sprintf("%s %s %s: %v", e.Name, mode.name, b.Name, err))
 					}
 					size = len(out)
 				})
 				results = append(results, result{e.Name, mode.name, b.Name, px, d, size})
 			}
 		}
 
 		// Decode the lossy encoding; it is the representative case and every
 		// backend produces the same bytes.
 		encoded, err := backends[0].Encode(e.Img, 0.75)
 		if err != nil {
 			panic(err)
 		}
 		for _, b := range backends {
 			d := measure(func() {
 				if _, err := b.Decode(encoded); err != nil {
 					panic(fmt.Sprintf("%s decode %s: %v", e.Name, b.Name, err))
 				}
 			})
 			results = append(results, result{e.Name, "decode", b.Name, px, d, len(encoded)})
 		}
 	}
 
 	report(backends, corpus, results)
 }
 
 func measure(fn func()) time.Duration {
 	fn() // warm up: first call pays lazy dsp-table init
 	start := time.Now()
 	n := 0
 	for (n < *minIter && time.Since(start) < 4*(*budget)) || time.Since(start) < *budget {
 		fn()
 		n++
 		if n >= 5000 {
 			break
 		}
 	}
 	return time.Since(start) / time.Duration(n)
 }
 
 func report(backends []Backend, corpus []Entry, results []result) {
 	index := map[string]result{}
 	for _, r := range results {
 		index[r.image+"|"+r.mode+"|"+r.backend] = r
 	}
 
 	for _, mode := range []string{"encode-lossless", "encode-lossy75", "decode"} {
 		fmt.Printf("== %s ==\n", mode)
 		fmt.Printf("%-18s %10s", "image", "out KiB")
 		for _, b := range backends {
 			fmt.Printf(" %14s", b.Name)
 		}
 		fmt.Printf("   (MP/s; x = vs native-simd)\n")
 
 		for _, e := range corpus {
 			base := index[e.Name+"|"+mode+"|native-simd"]
 			fmt.Printf("%-18s %10.1f", e.Name, float64(base.bytes)/1024)
 			for _, b := range backends {
 				r := index[e.Name+"|"+mode+"|"+b.Name]
 				mps := float64(r.pixels) / 1e6 / r.perOp.Seconds()
 				fmt.Printf(" %8.2f/%4.1fx", mps, float64(r.perOp)/float64(base.perOp))
 			}
 			fmt.Println()
 		}
 
 		// Geometric-mean slowdown against native-simd, so one large image
 		// does not dominate the headline number.
 		fmt.Printf("%-18s %10s", "GEOMEAN", "")
 		for _, b := range backends {
 			prod := 1.0
 			for _, e := range corpus {
 				base := index[e.Name+"|"+mode+"|native-simd"]
 				r := index[e.Name+"|"+mode+"|"+b.Name]
 				prod *= float64(r.perOp) / float64(base.perOp)
 			}
 			fmt.Printf(" %8s/%4.1fx", "", math.Pow(prod, 1/float64(len(corpus))))
 		}
 		fmt.Printf("\n\n")
 	}
 }
 
 func reportInstantiation(corpus []Entry) {
 	ctx := context.Background()
 	const n = 200
 	start := time.Now()
 	for i := 0; i < n; i++ {
 		inst, err := wasmwebp.NewInstance(ctx)
 		if err != nil {
 			panic(err)
 		}
 		inst.Close(ctx)
 	}
 	fmt.Printf("== wasm instantiation ==\nfresh instance: %v per instantiate+close\n",
 		time.Since(start)/n)
 
 	// Show how far linear memory grows and stays grown.
 	inst, err := wasmwebp.NewInstance(ctx)
 	if err != nil {
 		panic(err)
 	}
 	defer inst.Close(ctx)
 	fmt.Printf("linear memory at start:       %6.1f MiB\n", mib(inst.MemorySize()))
 
 	// Worst case first: the largest entry sets the high-water mark that a
 	// pooled instance would then hold onto forever.
 	largest := corpus[0]
 	for _, e := range corpus {
 		if area(e.Img) > area(largest.Img) {
 			largest = e
 		}
 	}
 	if _, err := inst.Encode(ctx, largest.Img, 1.0); err != nil {
 		panic(err)
 	}
 	b := largest.Img.Bounds()
 	fmt.Printf("after lossless %dx%-4d:    %6.1f MiB\n", b.Dx(), b.Dy(), mib(inst.MemorySize()))
 
 	for _, e := range corpus {
 		if e.Name == "flat-128" {
 			if _, err := inst.Encode(ctx, e.Img, 1.0); err != nil {
 				panic(err)
 			}
 			fmt.Printf("after a subsequent 128x128:   %6.1f MiB (never shrinks)\n", mib(inst.MemorySize()))
 		}
 	}
 }
 
 func area(m *image.NRGBA) int { return m.Bounds().Dx() * m.Bounds().Dy() }
 
 func mib(b uint32) float64 { return float64(b) / (1 << 20) }
 
 func dumpPNGs(corpus []Entry, dir string) error {
 	fmt.Println("== corpus ==")
 	if *noPNG {
 		for _, e := range corpus {
 			b := e.Img.Bounds()
 			fmt.Printf("%-18s %5dx%-5d %s\n", e.Name, b.Dx(), b.Dy(), e.Desc)
 		}
 		fmt.Println()
 		return nil
 	}
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
 	names := make([]string, 0, len(corpus))
 	for _, e := range corpus {
 		p := filepath.Join(dir, e.Name+".png")
 		f, err := os.Create(p)
 		if err != nil {
 			return err
 		}
 		if err := png.Encode(f, e.Img); err != nil {
 			f.Close()
 			return err
 		}
 		st, _ := f.Stat()
 		f.Close()
 		b := e.Img.Bounds()
 		fmt.Printf("%-18s %5dx%-5d %7.1f KiB png  %s\n",
 			e.Name, b.Dx(), b.Dy(), float64(st.Size())/1024, e.Desc)
 		names = append(names, e.Name)
 	}
 	sort.Strings(names)
 	fmt.Printf("written to %s/\n\n", dir)
 	return nil
 }