Six MPMC queue variants measured across producer/consumer mixes on x86 and ARM. Splitting one lock into two is 6.8x faster for fan-out and slower for fan-in. A deque beats a linked list 5x uncontended. And the object pool we added to skip malloc made things worse. Real numbers, real hardware.

Four concurrent counter implementations (mutex, atomic, and LongAdder-style striped) measured across thread counts on x86 and ARM. False sharing costs 31x. relaxed vs seq_cst costs nothing for RMW, and the disassembly explains why. Real numbers, real hardware.

Part 6 found a step function: 2.392 ns below some offset threshold, 2.870 ns above it. This post builds a controlled single-function experiment to find the exact threshold, instruments it with Skylake PMU counters, and traces the 0.478 ns cliff to a 38-byte function body crossing a 32-byte DSB window boundary.

Virtual dispatch measured 2.87 ns on GCC 11 and 2.39 ns on GCC 13. Same source, same flags, same hardware. The investigation that traced a phantom 20% swing to code alignment artifacts, and what it means for every C++ microbenchmark you've trusted.

The benchmarks in Parts 1-4 always dispatched to a single plugin type. Here's what happens when you mix multiple plugins in the same hot loop, and which dispatch mechanism degrades most gracefully.

std::variant went from 28% slower than virtual dispatch on GCC 11 to 50% faster on GCC 12. Nothing changed but the compiler.

std::variant is stack-allocated with no vtable, so why is std::visit 28% slower than virtual dispatch? We crack open the assembly and the stdlib source to find out.

Self-patching function pointers for zero-cost C++ dispatch after first call. Assembly analysis, 38ns/100M-call benchmarks, thread safety, and how OpenJDK uses this pattern for GC barrier resolution.

Virtual vs CRTP vs std::variant vs function pointer: which C++ dispatch mechanism is fastest? Benchmarks, generated assembly, compile times, and a decision framework for the strategy pattern in performance-critical code.