Everyone says -fno-rtti disables dynamic_cast and typeid. That is about a third of what it does. The vtable does not get smaller, the typeinfo slot stays and goes null, exceptions keep emitting typeinfo anyway, and the flag buys exactly zero compile time. Here is what it costs, what OpenJDK uses instead, and the mixing failure mode the manual never mentions.

I replaced a mutex with a textbook Treiber stack and it silently lost 83 percent of the items pushed through it. Here is the ABA bug, a reproducer that measures which thread mixes trigger it on three machines, the tagged-pointer fix, and why deleting the mutex helped on ARM and hurt on x86. Then a bounded ring that beats all of it.

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.