Benchmark BloomFilters (Created by AI)

bloom_test.go

package main

import (
	"fmt"
	"testing"

	bloom "github.com/bits-and-blooms/bloom/v3"
)

func BenchmarkBloomFilterCheck(b *testing.B) {
	tests := []struct {
		name     string
		elements int
		fpRate   float64
	}{
		{"elements1000_fp001", 1000, 0.01},
		{"elements10000_fp001", 10000, 0.01},
		{"elements100000_fp001", 100000, 0.01},
		{"elements1000_fp0001", 1000, 0.001},
		{"elements10000_fp0001", 10000, 0.001},
		{"elements100000_fp0001", 100000, 0.001},
	}

	for _, tc := range tests {
		b.Run(tc.name, func(b *testing.B) {
			filter := bloom.NewWithEstimates(uint(tc.elements), tc.fpRate)
			
			// Add elements to filter
			for i := 0; i < tc.elements; i++ {
				filter.Add([]byte(fmt.Sprintf("element%d", i)))
			}

			// Reset timer after setup
			b.ResetTimer()

			// Benchmark checking values
			for i := 0; i < b.N; i++ {
				key := []byte(fmt.Sprintf("element%d", i%tc.elements))
				_ = filter.Test(key)
			}
		})
	}
}

func BenchmarkBloomFilterCheckMisses(b *testing.B) {
	tests := []struct {
		name     string
		elements int
		fpRate   float64
	}{
		{"elements1000_fp001", 1000, 0.01},
		{"elements10000_fp001", 10000, 0.01},
		{"elements100000_fp001", 100000, 0.01},
		{"elements1000_fp0001", 1000, 0.001},
		{"elements10000_fp0001", 10000, 0.001},
		{"elements100000_fp0001", 100000, 0.001},
	}

	for _, tc := range tests {
		b.Run(tc.name, func(b *testing.B) {
			filter := bloom.NewWithEstimates(uint(tc.elements), tc.fpRate)
			
			// Add elements to filter
			for i := 0; i < tc.elements; i++ {
				filter.Add([]byte(fmt.Sprintf("element%d", i)))
			}

			// Reset timer after setup
			b.ResetTimer()

			// Benchmark checking values that don't exist
			for i := 0; i < b.N; i++ {
				key := []byte(fmt.Sprintf("missing%d", i))
				_ = filter.Test(key)
			}
		})
	}
}

func BenchmarkBloomFilterSerialize(b *testing.B) {
	tests := []struct {
		name     string
		elements int
		fpRate   float64
	}{
		{"elements1000_fp001", 1000, 0.01},
		{"elements10000_fp001", 10000, 0.01},
		{"elements100000_fp001", 100000, 0.01},
		{"elements1000_fp0001", 1000, 0.001},
		{"elements10000_fp0001", 10000, 0.001},
		{"elements100000_fp0001", 100000, 0.001},
	}

	for _, tc := range tests {
		b.Run(tc.name, func(b *testing.B) {
			filter := bloom.NewWithEstimates(uint(tc.elements), tc.fpRate)
			
			// Add elements to filter
			for i := 0; i < tc.elements; i++ {
				filter.Add([]byte(fmt.Sprintf("element%d", i)))
			}

			// Reset timer after setup
			b.ResetTimer()

			// Benchmark serialization
			for i := 0; i < b.N; i++ {
				_, _ = filter.GobEncode()
			}
		})
	}
}

func BenchmarkBloomFilterDeserialize(b *testing.B) {
	tests := []struct {
		name     string
		elements int
		fpRate   float64
	}{
		{"elements1000_fp001", 1000, 0.01},
		{"elements10000_fp001", 10000, 0.01},
		{"elements100000_fp001", 100000, 0.01},
		{"elements1000_fp0001", 1000, 0.001},
		{"elements10000_fp0001", 10000, 0.001},
		{"elements100000_fp0001", 100000, 0.001},
	}

	for _, tc := range tests {
		b.Run(tc.name, func(b *testing.B) {
			filter := bloom.NewWithEstimates(uint(tc.elements), tc.fpRate)
			
			// Add elements to filter
			for i := 0; i < tc.elements; i++ {
				filter.Add([]byte(fmt.Sprintf("element%d", i)))
			}

			// Serialize once
			data, _ := filter.GobEncode()

			// Reset timer after setup
			b.ResetTimer()

			// Benchmark deserialization
			for i := 0; i < b.N; i++ {
				newFilter := &bloom.BloomFilter{}
				_ = newFilter.GobDecode(data)
			}
		})
	}
}

func BenchmarkBloomFilterMarshalBinary(b *testing.B) {
	tests := []struct {
		name     string
		elements int
		fpRate   float64
	}{
		{"elements1000_fp001", 1000, 0.01},
		{"elements10000_fp001", 10000, 0.01},
		{"elements100000_fp001", 100000, 0.01},
		{"elements1000_fp0001", 1000, 0.001},
		{"elements10000_fp0001", 10000, 0.001},
		{"elements100000_fp0001", 100000, 0.001},
	}

	for _, tc := range tests {
		b.Run(tc.name, func(b *testing.B) {
			filter := bloom.NewWithEstimates(uint(tc.elements), tc.fpRate)
			
			// Add elements to filter
			for i := 0; i < tc.elements; i++ {
				filter.Add([]byte(fmt.Sprintf("element%d", i)))
			}

			// Reset timer after setup
			b.ResetTimer()

			// Benchmark MarshalBinary
			for i := 0; i < b.N; i++ {
				_, _ = filter.MarshalBinary()
			}
		})
	}
}

func BenchmarkBloomFilterUnmarshalBinary(b *testing.B) {
	tests := []struct {
		name     string
		elements int
		fpRate   float64
	}{
		{"elements1000_fp001", 1000, 0.01},
		{"elements10000_fp001", 10000, 0.01},
		{"elements100000_fp001", 100000, 0.01},
		{"elements1000_fp0001", 1000, 0.001},
		{"elements10000_fp0001", 10000, 0.001},
		{"elements100000_fp0001", 100000, 0.001},
	}

	for _, tc := range tests {
		b.Run(tc.name, func(b *testing.B) {
			filter := bloom.NewWithEstimates(uint(tc.elements), tc.fpRate)
			
			// Add elements to filter
			for i := 0; i < tc.elements; i++ {
				filter.Add([]byte(fmt.Sprintf("element%d", i)))
			}

			// Marshal once
			data, _ := filter.MarshalBinary()

			// Reset timer after setup
			b.ResetTimer()

			// Benchmark UnmarshalBinary
			for i := 0; i < b.N; i++ {
				newFilter := &bloom.BloomFilter{}
				_ = newFilter.UnmarshalBinary(data)
			}
		})
	}
}

goos: darwin
goarch: arm64
pkg: github.com/thrawn01/filter-perf
cpu: Apple M1 Max
BenchmarkBloomFilterCheck/elements1000_fp001-10                 13996387                86.32 ns/op
BenchmarkBloomFilterCheck/elements10000_fp001-10                13387129                88.51 ns/op
BenchmarkBloomFilterCheck/elements100000_fp001-10               13230727                90.44 ns/op
BenchmarkBloomFilterCheck/elements1000_fp0001-10                13115637                91.31 ns/op
BenchmarkBloomFilterCheck/elements10000_fp0001-10               12589074                94.05 ns/op
BenchmarkBloomFilterCheck/elements100000_fp0001-10              12411310                96.24 ns/op
BenchmarkBloomFilterCheckMisses/elements1000_fp001-10           11402178               105.6 ns/op
BenchmarkBloomFilterCheckMisses/elements10000_fp001-10          11275660               105.3 ns/op
BenchmarkBloomFilterCheckMisses/elements100000_fp001-10         11340288               106.7 ns/op
BenchmarkBloomFilterCheckMisses/elements1000_fp0001-10          11431692               104.0 ns/op
BenchmarkBloomFilterCheckMisses/elements10000_fp0001-10         11391282               104.9 ns/op
BenchmarkBloomFilterCheckMisses/elements100000_fp0001-10                11350262               107.1 ns/op
BenchmarkBloomFilterSerialize/elements1000_fp001-10                      1363171               884.4 ns/op
BenchmarkBloomFilterSerialize/elements10000_fp001-10                      178766              6549 ns/op
BenchmarkBloomFilterSerialize/elements100000_fp001-10                      20696             57480 ns/op
BenchmarkBloomFilterSerialize/elements1000_fp0001-10                     1000000              1077 ns/op
BenchmarkBloomFilterSerialize/elements10000_fp0001-10                     138856              8459 ns/op
BenchmarkBloomFilterSerialize/elements100000_fp0001-10                     12970             90893 ns/op
BenchmarkBloomFilterDeserialize/elements1000_fp001-10                    1764403               673.8 ns/op
BenchmarkBloomFilterDeserialize/elements10000_fp001-10                    259570              4590 ns/op
BenchmarkBloomFilterDeserialize/elements100000_fp001-10                    28195             42767 ns/op
BenchmarkBloomFilterDeserialize/elements1000_fp0001-10                   1319935               916.3 ns/op
BenchmarkBloomFilterDeserialize/elements10000_fp0001-10                   176049              6649 ns/op
BenchmarkBloomFilterDeserialize/elements100000_fp0001-10                   18582             64190 ns/op
BenchmarkBloomFilterMarshalBinary/elements1000_fp001-10                  1342916               886.7 ns/op
BenchmarkBloomFilterMarshalBinary/elements10000_fp001-10                  182689              6553 ns/op
BenchmarkBloomFilterMarshalBinary/elements100000_fp001-10                  20894             57562 ns/op
BenchmarkBloomFilterMarshalBinary/elements1000_fp0001-10                 1000000              1068 ns/op
BenchmarkBloomFilterMarshalBinary/elements10000_fp0001-10                 139152              8508 ns/op
BenchmarkBloomFilterMarshalBinary/elements100000_fp0001-10                 12956             91582 ns/op
BenchmarkBloomFilterUnmarshalBinary/elements1000_fp001-10                1771699               679.7 ns/op
BenchmarkBloomFilterUnmarshalBinary/elements10000_fp001-10                251736              4569 ns/op
BenchmarkBloomFilterUnmarshalBinary/elements100000_fp001-10                28054             42810 ns/op
BenchmarkBloomFilterUnmarshalBinary/elements1000_fp0001-10               1308505               909.5 ns/op
BenchmarkBloomFilterUnmarshalBinary/elements10000_fp0001-10               177421              6678 ns/op
BenchmarkBloomFilterUnmarshalBinary/elements100000_fp0001-10               18744             64534 ns/op
PASS
ok      github.com/thrawn01/filter-perf 56.493s