Bloom Filter
This bloom filter implementation is a Go port of https://github.com/jasondavies/bloomfilter.js
The ability to build a bloom filter on a server in Go and evaluate that filter on a client in
Javascript can have immense value for comparing application state in distributed single page
applications with offline read/write capabilities and large data sets.
There are a lot of open source bloom filter implementations available on the internet. These
implementations are mostly incompatible. Every repo adds its own special sauce to its hashing
algorithms and hash derivation methods. After scouring the internet for a multi-language bloom
filter implemenation, none appeared that fit the requirements.
So, the most popular actively maintained javascript bloom filter on Github was selected and ported
to Go.
The reference implementation uses a non-standard fnv1a hashing algorithm. It is also less than 120
lines of javascript. This project proves that the reference implementation can be ported by a
skilled developer to another language in a day.
Go Example
bloomfilter is thread safe with 95% test coverage
package main
import (
"encoding/base64"
"fmt"
"github.com/httpimp/bloomfilter"
)
func main() {
m, k := bloomfilter.EstimateParameters(10, 1e-6)
bf := bloomfilter.New(m, k)
bf.Add([]byte("foo"))
bf.Add([]byte("bar"))
encoded := base64.StdEncoding.EncodeToString(bf.ToBytes())
fmt.Println(m)
fmt.Println(k)
fmt.Println(string(encoded))
}
288
20
iCCACAiAACAACIgAAAIIAqCAAIgogCAIAIgACAIAigiAAIqA
Javascript Example
Now we can take that same base64 encoded byte array and evaluate it with bloomfilter.js in the
browser
var bits = sjcl.codec.base64.toBits("iCCACAiAACAACIgAAAIIAqCAAIgogCAIAIgACAIAigiAAIqA");
var bloom = new BloomFilter(bits, 20);
console.log(bloom.test("foo"));
console.log(bloom.test("bar"));
console.log(bloom.test("baz"));
bloom.add("baz");
console.log(sjcl.codec.base64.fromBits(bloom.buckets));
true
true
false
iCCACAiAACAACIgAQAIIAqSIEKgowKEKAowIGBIgyomAAIqI
Go Example Again
After deserializing the filter in javascript and altering it, we can send it back to the server
again to confirm that it now includes the additional element.
package main
import (
"encoding/base64"
"log"
"github.com/httpimp/bloomfilter"
)
func main() {
decoded, err := base64.StdEncoding.DecodeString("iCCACAiAACAACIgAQAIIAqSIEKgowKEKAowIGBIgyomAAIqI")
if err != nil {
panic(err)
}
bf := bloomfilter.NewFromBytes(decoded, 21)
log.Println(bf.Test([]byte("foo")))
log.Println(bf.Test([]byte("bar")))
log.Println(bf.Test([]byte("baz")))
log.Println(bf.Test([]byte("bork")))
}
true
true
true
false
This is not the most efficient bloom filter available for Go. There are plenty of good options if
you don't need portability.
That said, it still does perform reasonably well.
> go test -bench .
goos: linux
goarch: amd64
pkg: github.com/httpimp/bloomfilter
BenchmarkSeparateTestAndAdd-2 1000000 1224 ns/op
BenchmarkSeparateAdd-2 2000000 702 ns/op
PASS
ok github.com/httpimp/bloomfilter 3.320s
Will Fitzgerald's bloom
is an excellent bloom filter written in Go
https://github.com/willf/bloom
> go test -bench .
goos: linux
goarch: amd64
pkg: github.com/willf/bloom
BenchmarkEstimated-2 2000000000 0.10 ns/op
BenchmarkSeparateTestAndAdd-2 2000000 761 ns/op
BenchmarkCombinedTestAndAdd-2 3000000 757 ns/op
BenchmarkAdd-2 3000000 599 ns/op
PASS
ok github.com/willf/bloom 9.580s
This project is about 15% slower for Add and 40% slower for Test and Add compared with bloom.
This performance penalty may be an acceptable trade-off in exchange for the portability this
project is designed to provide. Weigh your application's efficiency requirements for bloom filter
use and creation against the benefit of sharing filters with javascript applications before
integrating this package.
Standing on the shoulders of giants
Thanks to @jasondavies for creating the reference implementation, a functioning bloom filter
in < 120 lines of code. This port took about 6 hours.
Thanks to @willf for estimation.