Ruminations of a Programmer

How Miri found a data race in a lock-free ring buffer that the compiler had no way to see The Reference That Was Too Wide There is the usual story Rust programmers tell about data races: the borrow checker prevents them.

Safety as Performance: Moves, the Borrow Checker, debug_assert!

Backoff & Memory Provisioning: Adaptive Spinning, Custom Allocators, NUMA & Huge Pages Part 6 of Low-Level Systems Design in Rust - a series on writing high-throughput, low-latency systems code, using a single-producer / single-consumer (SPSC) ring buffer…

Compile-Time Leverage: Specialization, Branch & Arithmetic Hygiene, and Inlining Part 5 of Low-Level Systems Design in Rust - a series on writing high-throughput, low-latency systems code, using a single-producer / single-consumer (SPSC) ring buffer as the

Zero-Copy on the Hot Path: Reserve/Commit and Fast-Path/Slow-Path Splitting Part 4 of Low-Level Systems Design in Rust - a series on writing high-throughput, low-latency systems code, using a single-producer / single-consumer (SPSC) ring buffer as the run…

Amortizing Cross-Core Coordination: Cursor Caching and Batch Processing Part 3 of Low-Level Systems Design in Rust - a series on writing high-throughput, low-latency systems code, using a single-producer / single-consumer (SPSC) ring buffer as the running…

The Cross-Core Contract: Memory Ordering and Single-Writer State in Lock-Free Rust Part 2 of Low-Level Systems Design in Rust - a series on writing high-throughput, low-latency systems code, using a single-producer / single-consumer (SPSC) ring buffer as…

Cache-Conscious Data Layout: Field Zoning, False Sharing, and the 128-Byte Rule Part 1 of Low-Level Systems Design in Rust - a series on writing high-throughput, low-latency systems code, using a single-producer / single-consumer (SPSC) ring buffer as the…

Architectural Decomposition: Remove Contention by Design Across the Rust projects I've worked on, the ones that demanded high throughput and low latency were almost always built around a few architectural principles that remained invariant across all of t…

Scalar Replacement of Aggregates: How "Copy to Locals" Unlocks the Compiler Some performance fixes look almost suspiciously small in the diff.

Why x86 Zeroes a Register With xor eax, eax If you have ever disassembled a program - even a trivial one - you have almost certainly seen this line: xor eax, eax It looks like a riddle.

Set-Associative Caches: Trading Global Optimality for Predictable Speed Caches are everywhere in modern systems: CPU L1/L2 caches, database buffer caches, storage-engine object caches, and application-level LRU maps.

Building a custom Bitset - A study in access-pattern-driven data structure choice I was porting porcupine-rust to Zig - the core of the implementation is a Bitset data structure, which is used in the implementation of a cache (see below for the details of…

Zig Allocation Patterns A reference for the allocation and ownership patterns used in porcupine-zig, plus the broader landscape of Zig allocator idioms.

Why Zig’s Io Feels Like an Effect System (Without Being One) Context: What does "effect" even mean?

Evaluating PBT Frameworks: How Proptest and Hegel Differ in Algebraic Expressivity Context I have recently been working on porcupine-rust is a Rust port of Porcupine, a linearizability checker for concurrent and distributed systems, with APIs over timesta…

The RAII Drop-Guard Pattern in Rust Context In Rust, any value that owns a resource and frees it in its Drop implementation acts as a guard: the resource lives for exactly as long as the value is in scope.

Pin<Box<dyn Future + Send>> in Traits - Why the Manual Desugar?