A recap of CppCon 2026 at the Gaylord Rockies: my talk on OpenJDK's Access API and the sessions on hardware performance and AI-assisted code quality that stuck past the flight home.

What -fno-rtti actually does to a binary (the vtable keeps its typeinfo slot and it goes null), why Chromium, Firefox, LLVM, Android and OpenJDK all turn it off, what it saves in size, load time and build time, how dynamic_cast's cost moved across GCC 9 to 15, Clang 22 and libc++, what Clang and C++26 add next, and how HotSpot lives without it.

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.