Bloom Filters on Shai Asher

The Bloom Filter Optimization Saga: The "Benign" Read That Wasn't

Sat, 05 Sep 2026 14:46:43 +0000

A Go Concurrency And Memory Model Deep Dive

In software engineering, some of the most insidious bugs are the ones that hide behind correct-looking code. This is a war story about a data race that slipped into a highly optimized, “thread-safe” Go Bloom filter. It’s a practical lesson in humility and a reminder that when it comes to concurrency, the Go race detector is the ultimate arbiter of truth.

The Bloom Filter Optimization Saga: A Deep Dive into Go Assembly and AVX2

Mon, 10 Nov 2025 11:18:02 +0000

If you’ve ever wondered how high-performance Go programs achieve their incredible speeds, the answer often lies hidden just beneath the surface, in files exactly like avx2.s. This file is a fascinating example of targeted, low-level optimization.

So, let’s break down what this code does, why it exists, and how it works its magic.

The Bloom Filter Optimization Saga: Anatomy of a Go Concurrency Bug - Part 2

Thu, 06 Nov 2025 19:16:25 +0000

Final Optimization: Solving the 10x Performance Hit

This brings us to the performance report. We have successfully achieved a fully thread-safe implementation, but at a high cost. The performance results file shows a catastrophic 8-12x performance regression.

The Root Cause: The bottleneck is not the sync.Pool and not the atomic operations. It is the fix for Race #2: positions := make([]uint64, bf.hashCount)

The Bloom Filter Optimization Saga: Anatomy of a Go Concurrency Bug - Part 1

Sun, 02 Nov 2025 19:27:14 +0000

Github Project : https://github.com/shaia/BloomFilter

When ‘Read’ Operations Mutate State

I recently investigated a critical bug in theBloomFilter package that was causing panics under concurrent use. Thebloomfilter_concurrent_test.go file said it all: every test was skipped, citing a “nil pointer dereference in storage layer”.

The Bloom Filter Optimization Saga: From 3 Seconds to 66 Microseconds

Thu, 30 Oct 2025 19:13:00 +0000

Building high-performance libraries often involves more than just clever algorithms. It’s a journey of measurement, discovery, and sometimes, learning that your “obvious” fix made things worse. Go SIMD-Optimized Bloom Filter, which you can read all about here, is a project that started with a 4x SIMD speedup and ended with a 6,595x overall speedup after a deep dive into Go’s profiling tools.

SIMD-Optimized Bloom Filter in Go: An In-Depth Exploration

Mon, 22 Sep 2025 07:03:20 +0000

Project Repository: https://github.com/shaia/BloomFilter

From Go to Assembly

When we think of Go, we think of concurrency, simplicity, and “good enough” performance. But what happens when “good enough” isn’t good enough? What happens when you need to squeeze every last drop of performance out of the CPU for a critical, hot-path operation?