Influxdata
/
influxdb
mirror of https://github.com/influxdata/influxdb.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add benchmarks for bloom filter

pull/8857/head
Edd Robinson 2017-08-30 23:16:51 +01:00
parent 1e345aa7a1
commit fe960b0f3a
1 changed files with 138 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
pkg/bloom/bloom_test.go
View File

@ -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)
}
})
}
}