snappy-go: Add snappy C++ implementation benchmarks.
The benchmark test data files are automatically downloaded from the
snappy subversion server and used for benchmark with the command:
go test -bench=Benchmark_.* -download
UValidate benchmarks are not supported since snappy-go doesn't support
validating a packet without decompressing it.
R=nigeltao, minux.ma
CC=golang-dev
https://codereview.appspot.com/7271049
Committer: Nigel Tao <nigeltao@golang.org>
diff --git a/.hgignore b/.hgignore
index 055f43c..d804706 100644
--- a/.hgignore
+++ b/.hgignore
@@ -22,6 +22,7 @@
_test
_testmain.go
build.out
+snappy/testdata
test.out
y.tab.[ch]
diff --git a/snappy/snappy_test.go b/snappy/snappy_test.go
index aa74bd9..7ba8392 100644
--- a/snappy/snappy_test.go
+++ b/snappy/snappy_test.go
@@ -6,13 +6,20 @@
import (
"bytes"
+ "flag"
"fmt"
+ "io"
"io/ioutil"
"math/rand"
+ "net/http"
+ "os"
+ "path/filepath"
"strings"
"testing"
)
+var download = flag.Bool("download", false, "If true, download any missing files before running benchmarks")
+
func roundtrip(b, ebuf, dbuf []byte) error {
e, err := Encode(ebuf, b)
if err != nil {
@@ -72,56 +79,183 @@
}
}
-func benchWords(b *testing.B, n int, decode bool) {
- b.StopTimer()
-
- // Make src, a []byte of length n containing copies of the words file.
- words, err := ioutil.ReadFile("/usr/share/dict/words")
+func benchDecode(b *testing.B, src []byte) {
+ encoded, err := Encode(nil, src)
if err != nil {
- panic(err)
+ b.Fatal(err)
}
- if len(words) == 0 {
- panic("/usr/share/dict/words has zero length")
- }
- src := make([]byte, n)
- for x := src; len(x) > 0; {
- n := copy(x, words)
- x = x[n:]
- }
-
- // If benchmarking decoding, encode the src.
- if decode {
- src, err = Encode(nil, src)
- if err != nil {
- panic(err)
- }
- }
+ // Bandwidth is in amount of uncompressed data.
b.SetBytes(int64(len(src)))
-
- // Allocate a sufficiently large dst buffer.
- var dst []byte
- if decode {
- dst = make([]byte, n)
- } else {
- dst = make([]byte, MaxEncodedLen(n))
- }
-
- // Run the loop.
- b.StartTimer()
+ b.ResetTimer()
for i := 0; i < b.N; i++ {
- if decode {
- Decode(dst, src)
- } else {
- Encode(dst, src)
- }
+ Decode(src, encoded)
}
}
-func BenchmarkDecodeWords1e3(b *testing.B) { benchWords(b, 1e3, true) }
-func BenchmarkDecodeWords1e4(b *testing.B) { benchWords(b, 1e4, true) }
-func BenchmarkDecodeWords1e5(b *testing.B) { benchWords(b, 1e5, true) }
-func BenchmarkDecodeWords1e6(b *testing.B) { benchWords(b, 1e6, true) }
-func BenchmarkEncodeWords1e3(b *testing.B) { benchWords(b, 1e3, false) }
-func BenchmarkEncodeWords1e4(b *testing.B) { benchWords(b, 1e4, false) }
-func BenchmarkEncodeWords1e5(b *testing.B) { benchWords(b, 1e5, false) }
-func BenchmarkEncodeWords1e6(b *testing.B) { benchWords(b, 1e6, false) }
+func benchEncode(b *testing.B, src []byte) {
+ // Bandwidth is in amount of uncompressed data.
+ b.SetBytes(int64(len(src)))
+ dst := make([]byte, MaxEncodedLen(len(src)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ Encode(dst, src)
+ }
+}
+
+func readFile(b *testing.B, filename string) []byte {
+ src, err := ioutil.ReadFile(filename)
+ if err != nil {
+ b.Fatalf("failed reading %s: %s", filename, err)
+ }
+ if len(src) == 0 {
+ b.Fatalf("%s has zero length", filename)
+ }
+ return src
+}
+
+// expand returns a slice of length n containing repeated copies of src.
+func expand(src []byte, n int) []byte {
+ dst := make([]byte, n)
+ for x := dst; len(x) > 0; {
+ i := copy(x, src)
+ x = x[i:]
+ }
+ return dst
+}
+
+func benchWords(b *testing.B, n int, decode bool) {
+ // Note: the file is OS-language dependent so the resulting values are not
+ // directly comparable for non-US-English OS installations.
+ data := expand(readFile(b, "/usr/share/dict/words"), n)
+ if decode {
+ benchDecode(b, data)
+ } else {
+ benchEncode(b, data)
+ }
+}
+
+func BenchmarkWordsDecode1e3(b *testing.B) { benchWords(b, 1e3, true) }
+func BenchmarkWordsDecode1e4(b *testing.B) { benchWords(b, 1e4, true) }
+func BenchmarkWordsDecode1e5(b *testing.B) { benchWords(b, 1e5, true) }
+func BenchmarkWordsDecode1e6(b *testing.B) { benchWords(b, 1e6, true) }
+func BenchmarkWordsEncode1e3(b *testing.B) { benchWords(b, 1e3, false) }
+func BenchmarkWordsEncode1e4(b *testing.B) { benchWords(b, 1e4, false) }
+func BenchmarkWordsEncode1e5(b *testing.B) { benchWords(b, 1e5, false) }
+func BenchmarkWordsEncode1e6(b *testing.B) { benchWords(b, 1e6, false) }
+
+// testFiles' values are copied directly from
+// https://code.google.com/p/snappy/source/browse/trunk/snappy_unittest.cc.
+// The label field is unused in snappy-go.
+var testFiles = []struct {
+ label string
+ filename string
+}{
+ {"html", "html"},
+ {"urls", "urls.10K"},
+ {"jpg", "house.jpg"},
+ {"pdf", "mapreduce-osdi-1.pdf"},
+ {"html4", "html_x_4"},
+ {"cp", "cp.html"},
+ {"c", "fields.c"},
+ {"lsp", "grammar.lsp"},
+ {"xls", "kennedy.xls"},
+ {"txt1", "alice29.txt"},
+ {"txt2", "asyoulik.txt"},
+ {"txt3", "lcet10.txt"},
+ {"txt4", "plrabn12.txt"},
+ {"bin", "ptt5"},
+ {"sum", "sum"},
+ {"man", "xargs.1"},
+ {"pb", "geo.protodata"},
+ {"gaviota", "kppkn.gtb"},
+}
+
+// The test data files are present at this canonical URL.
+const baseURL = "https://snappy.googlecode.com/svn/trunk/testdata/"
+
+func downloadTestdata(basename string) (errRet error) {
+ filename := filepath.Join("testdata", basename)
+ f, err := os.Create(filename)
+ if err != nil {
+ return fmt.Errorf("failed to create %s: %s", filename, err)
+ }
+ defer f.Close()
+ defer func() {
+ if errRet != nil {
+ os.Remove(filename)
+ }
+ }()
+ resp, err := http.Get(baseURL + basename)
+ if err != nil {
+ return fmt.Errorf("failed to download %s: %s", baseURL+basename, err)
+ }
+ defer resp.Body.Close()
+ _, err = io.Copy(f, resp.Body)
+ if err != nil {
+ return fmt.Errorf("failed to write %s: %s", filename, err)
+ }
+ return nil
+}
+
+func benchFile(b *testing.B, n int, decode bool) {
+ filename := filepath.Join("testdata", testFiles[n].filename)
+ if stat, err := os.Stat(filename); err != nil || stat.Size() == 0 {
+ if !*download {
+ b.Fatal("test data not found; skipping benchmark without the -download flag")
+ }
+ // Download the official snappy C++ implementation reference test data
+ // files for benchmarking.
+ if err := os.Mkdir("testdata", 0777); err != nil && !os.IsExist(err) {
+ b.Fatalf("failed to create testdata: %s", err)
+ }
+ for _, tf := range testFiles {
+ if err := downloadTestdata(tf.filename); err != nil {
+ b.Fatalf("failed to download testdata: %s", err)
+ }
+ }
+ }
+ data := readFile(b, filename)
+ if decode {
+ benchDecode(b, data)
+ } else {
+ benchEncode(b, data)
+ }
+}
+
+// Naming convention is kept similar to what snappy's C++ implementation uses.
+func Benchmark_UFlat0(b *testing.B) { benchFile(b, 0, true) }
+func Benchmark_UFlat1(b *testing.B) { benchFile(b, 1, true) }
+func Benchmark_UFlat2(b *testing.B) { benchFile(b, 2, true) }
+func Benchmark_UFlat3(b *testing.B) { benchFile(b, 3, true) }
+func Benchmark_UFlat4(b *testing.B) { benchFile(b, 4, true) }
+func Benchmark_UFlat5(b *testing.B) { benchFile(b, 5, true) }
+func Benchmark_UFlat6(b *testing.B) { benchFile(b, 6, true) }
+func Benchmark_UFlat7(b *testing.B) { benchFile(b, 7, true) }
+func Benchmark_UFlat8(b *testing.B) { benchFile(b, 8, true) }
+func Benchmark_UFlat9(b *testing.B) { benchFile(b, 9, true) }
+func Benchmark_UFlat10(b *testing.B) { benchFile(b, 10, true) }
+func Benchmark_UFlat11(b *testing.B) { benchFile(b, 11, true) }
+func Benchmark_UFlat12(b *testing.B) { benchFile(b, 12, true) }
+func Benchmark_UFlat13(b *testing.B) { benchFile(b, 13, true) }
+func Benchmark_UFlat14(b *testing.B) { benchFile(b, 14, true) }
+func Benchmark_UFlat15(b *testing.B) { benchFile(b, 15, true) }
+func Benchmark_UFlat16(b *testing.B) { benchFile(b, 16, true) }
+func Benchmark_UFlat17(b *testing.B) { benchFile(b, 17, true) }
+func Benchmark_ZFlat0(b *testing.B) { benchFile(b, 0, false) }
+func Benchmark_ZFlat1(b *testing.B) { benchFile(b, 1, false) }
+func Benchmark_ZFlat2(b *testing.B) { benchFile(b, 2, false) }
+func Benchmark_ZFlat3(b *testing.B) { benchFile(b, 3, false) }
+func Benchmark_ZFlat4(b *testing.B) { benchFile(b, 4, false) }
+func Benchmark_ZFlat5(b *testing.B) { benchFile(b, 5, false) }
+func Benchmark_ZFlat6(b *testing.B) { benchFile(b, 6, false) }
+func Benchmark_ZFlat7(b *testing.B) { benchFile(b, 7, false) }
+func Benchmark_ZFlat8(b *testing.B) { benchFile(b, 8, false) }
+func Benchmark_ZFlat9(b *testing.B) { benchFile(b, 9, false) }
+func Benchmark_ZFlat10(b *testing.B) { benchFile(b, 10, false) }
+func Benchmark_ZFlat11(b *testing.B) { benchFile(b, 11, false) }
+func Benchmark_ZFlat12(b *testing.B) { benchFile(b, 12, false) }
+func Benchmark_ZFlat13(b *testing.B) { benchFile(b, 13, false) }
+func Benchmark_ZFlat14(b *testing.B) { benchFile(b, 14, false) }
+func Benchmark_ZFlat15(b *testing.B) { benchFile(b, 15, false) }
+func Benchmark_ZFlat16(b *testing.B) { benchFile(b, 16, false) }
+func Benchmark_ZFlat17(b *testing.B) { benchFile(b, 17, false) }
