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>

.hgignore

@@ -22,6 +22,7 @@ _obj
 _test
 _testmain.go
 build.out
+snappy/testdata
 test.out
 y.tab.[ch]
 

snappy/snappy_test.go

@@ -6,13 +6,20 @@ package snappy
 
 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 TestSmallRegular(t *testing.T) {
 	}
 }
 
-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")
+	// Bandwidth is in amount of uncompressed data.
+	b.SetBytes(int64(len(src)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		Decode(src, encoded)
 	}
-	src := make([]byte, n)
-	for x := src; len(x) > 0; {
-		n := copy(x, words)
-		x = x[n:]
+}
+
+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)
 	}
+}
 
-	// If benchmarking decoding, encode the src.
-	if decode {
-		src, err = Encode(nil, src)
-		if err != nil {
-			panic(err)
-		}
+func readFile(b *testing.B, filename string) []byte {
+	src, err := ioutil.ReadFile(filename)
+	if err != nil {
+		b.Fatalf("failed reading %s: %s", filename, err)
 	}
-	b.SetBytes(int64(len(src)))
+	if len(src) == 0 {
+		b.Fatalf("%s has zero length", filename)
+	}
+	return src
+}
 
-	// Allocate a sufficiently large dst buffer.
-	var dst []byte
+// 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 {
-		dst = make([]byte, n)
+		benchDecode(b, data)
 	} else {
-		dst = make([]byte, MaxEncodedLen(n))
+		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
+}
 
-	// Run the loop.
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		if decode {
-			Decode(dst, src)
-		} else {
-			Encode(dst, src)
+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)
 	}
 }
 
-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) }
+// 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) }