From fe960b0f3a7839bbad5891bb20addf92a145392f Mon Sep 17 00:00:00 2001
From: Edd Robinson <me@edd.io>
Date: Wed, 30 Aug 2017 23:16:51 +0100
Subject: [PATCH] Add benchmarks for bloom filter

---
 pkg/bloom/bloom_test.go | 138 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 138 insertions(+)

diff --git a/pkg/bloom/bloom_test.go b/pkg/bloom/bloom_test.go
index 33182da6b2..bcfdef3558 100644
--- a/pkg/bloom/bloom_test.go
+++ b/pkg/bloom/bloom_test.go
@@ -1,6 +1,7 @@
 package bloom_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/influxdata/influxdb/pkg/bloom"
@@ -27,3 +28,140 @@ func TestFilter_InsertContains(t *testing.T) {
 		t.Fatal("expected false")
 	}
 }
+
+func BenchmarkFilter_Insert(b *testing.B) {
+	cases := []struct {
+		m, k uint64
+		n    int
+	}{
+		{m: 100, k: 4, n: 1000},
+		{m: 1000, k: 4, n: 1000},
+		{m: 10000, k: 4, n: 1000},
+		{m: 100000, k: 4, n: 1000},
+		{m: 100, k: 8, n: 1000},
+		{m: 1000, k: 8, n: 1000},
+		{m: 10000, k: 8, n: 1000},
+		{m: 100000, k: 8, n: 1000},
+		{m: 100, k: 20, n: 1000},
+		{m: 1000, k: 20, n: 1000},
+		{m: 10000, k: 20, n: 1000},
+		{m: 100000, k: 20, n: 1000},
+	}
+
+	for _, c := range cases {
+		data := make([][]byte, 0, c.n)
+		for i := 0; i < c.n; i++ {
+			data = append(data, []byte(fmt.Sprintf("%d", i)))
+		}
+
+		filter := bloom.NewFilter(c.m, c.k)
+		b.Run(fmt.Sprintf("m=%d_k=%d_n=%d", c.m, c.k, c.n), func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				for _, v := range data {
+					filter.Insert(v)
+				}
+			}
+		})
+	}
+}
+
+var okResult bool
+
+func BenchmarkFilter_Contains(b *testing.B) {
+	cases := []struct {
+		m, k uint64
+		n    int
+	}{
+		{m: 100, k: 4, n: 1000},
+		{m: 1000, k: 4, n: 1000},
+		{m: 10000, k: 4, n: 1000},
+		{m: 100000, k: 4, n: 1000},
+		{m: 100, k: 8, n: 1000},
+		{m: 1000, k: 8, n: 1000},
+		{m: 10000, k: 8, n: 1000},
+		{m: 100000, k: 8, n: 1000},
+		{m: 100, k: 20, n: 1000},
+		{m: 1000, k: 20, n: 1000},
+		{m: 10000, k: 20, n: 1000},
+		{m: 100000, k: 20, n: 1000},
+	}
+
+	for _, c := range cases {
+		data := make([][]byte, 0, c.n)
+		notData := make([][]byte, 0, c.n)
+		for i := 0; i < c.n; i++ {
+			data = append(data, []byte(fmt.Sprintf("%d", i)))
+			notData = append(notData, []byte(fmt.Sprintf("%d", c.n+i)))
+		}
+
+		filter := bloom.NewFilter(c.m, c.k)
+		for _, v := range data {
+			filter.Insert(v)
+		}
+
+		b.Run(fmt.Sprintf("m=%d_k=%d_n=%d", c.m, c.k, c.n), func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				for _, v := range data {
+					okResult = filter.Contains(v)
+					if !okResult {
+						b.Fatalf("Filter returned negative for value %q in set", v)
+					}
+				}
+
+				// And now a bunch of values that don't exist.
+				for _, v := range notData {
+					okResult = filter.Contains(v)
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkFilter_Merge(b *testing.B) {
+	cases := []struct {
+		m, k uint64
+		n    int
+	}{
+		{m: 100, k: 4, n: 1000},
+		{m: 1000, k: 4, n: 1000},
+		{m: 10000, k: 4, n: 1000},
+		{m: 100000, k: 4, n: 1000},
+		{m: 100, k: 8, n: 1000},
+		{m: 1000, k: 8, n: 1000},
+		{m: 10000, k: 8, n: 1000},
+		{m: 100000, k: 8, n: 1000},
+		{m: 100, k: 20, n: 1000},
+		{m: 1000, k: 20, n: 1000},
+		{m: 10000, k: 20, n: 1000},
+		{m: 100000, k: 20, n: 1000},
+	}
+
+	for _, c := range cases {
+		data1 := make([][]byte, 0, c.n)
+		data2 := make([][]byte, 0, c.n)
+		for i := 0; i < c.n; i++ {
+			data1 = append(data1, []byte(fmt.Sprintf("%d", i)))
+			data2 = append(data2, []byte(fmt.Sprintf("%d", c.n+i)))
+		}
+
+		filter1 := bloom.NewFilter(c.m, c.k)
+		filter2 := bloom.NewFilter(c.m, c.k)
+		for i := 0; i < c.n; i++ {
+			filter1.Insert(data1[i])
+			filter2.Insert(data2[i])
+		}
+
+		b.Run(fmt.Sprintf("m=%d_k=%d_n=%d", c.m, c.k, c.n), func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				other, err := bloom.NewFilterBuffer(filter1.Bytes(), filter1.K())
+				if err != nil {
+					b.Fatal(err)
+				}
+				other.Merge(filter2)
+			}
+		})
+	}
+}