44Further Reading and Tools

There is an enormous amount written about C++ and about performance, and most of it is either out of date or repeats what you already know. This is the filtered list: what each item is, and the specific reason it earns your hours. Nothing here is on the list because it is famous.

Two markers throughout. [start] means you can read it now, with no prerequisites beyond the earlier parts of this series. [deep] means it assumes the material in Parts III to VI and will be frustrating before that.

Books#

Talks#

Conference talks are the fastest way into a topic because the speaker has already discarded the boring nine tenths. All of these are on YouTube; titles are approximate.

Tools#

$ perf stat -e cycles,instructions,branches,branch-misses,cache-misses ./trader
$ perf record -g --call-graph=fp ./trader && perf report --stdio
$ perf c2c record ./trader && perf c2c report            # false sharing, lesson 21
$ lstopo --output-format txt                             # the machine's real shape
$ strace -c -f ./trader                                  # syscalls you did not know about

$ g++ -std=c++23 -O3 -march=native -S -masm=intel -o - book.cpp | llvm-mca -mcpu=native

Source worth reading#

Reading a good implementation is worth more than reading about one. These are all small enough or well-commented enough to repay an afternoon.

• rigtorp/SPSCQueue and rigtorp/MPMCQueue [start] after lesson 33. A few hundred lines each. The clearest real code that shows cache line padding, index caching and acquire/release used correctly. Read SPSCQueue immediately after building your own.
• abseil [start]. flat_hash_map is the swiss-table design that everyone else copied, and the comments explain the probing scheme properly. InlinedVector is the small-buffer pattern from lesson 24.
• folly [deep]. Facebook's library, and the comments are the value: ProducerConsumerQueue, MPMCQueue, Function, small_vector, hazptr. Written by people who measured.
• boost.lockfree [deep]. spsc_queue, queue and stack, conservative and unusually well documented for lock-free code.
• Google Highway and xsimd [deep]. Portable SIMD without intrinsics soup. Highway's documentation is the best available taxonomy of vector operations. Lesson 25.
• fmt [start]. Fast, compile-time-checked formatting, and the direct ancestor of std::format. Worth reading for the compile-time parsing alone.
• Seastar [deep]. Shared-nothing, one thread per core, no locks anywhere, explicit message passing between shards. Read the architecture documents even if you never use it; the argument is the point. Lesson 35.
• DPDK [deep]. Kernel bypass in production form. Read the ring buffer and the memory pool, which are the ideas from lessons 24 and 33 at industrial scale. Lesson 38.

Reference sites#

Links#

Everything above that lives at a stable address. Conference talks are not listed individually because their URLs change; search the CppCon channel for the speaker and title given in the talks table.

How to keep learning#

Three habits, in decreasing order of return.

Read assembly regularly. Ten minutes a week on Compiler Explorer, looking at something you wrote that day, is enough to build the instinct for what a line of C++ costs. The point is not to memorise instructions; it is to stop being surprised. When you eventually find a function that did not inline or a loop that did not vectorise, you will notice it because the shape looks wrong.

Follow the standards process, selectively. You do not need to track every paper. Skim the trip reports after each WG21 meeting, and when a feature you use changes, read the paper that changed it. Papers are written to persuade a committee, so they state the problem and the alternatives, which is exactly the context missing from documentation.

Measure everything, and keep the numbers. The habit that separates people who improve systems from people who have opinions about them is writing the number down: which host, which flags, which percentile, which date. A directory of past measurements is how you notice a slow regression, how you settle an argument in one minute, and how you avoid re-running an experiment someone already did. Lesson 26 is about the measurement; this is about the filing.

Takeaways#

• Computer Systems: A Programmer's Perspective and Godbolt's compiler talk are the highest-return starting points; almost everything else builds on them.
• Vendor manuals and instruction tables are reference material for a specific question, not reading material.
• Reading a small, good implementation such as rigtorp's SPSCQueue teaches more than any article about lock-free programming.
• perf, Compiler Explorer, lstopo and HdrHistogram answer most questions you will have; the heavier tools are for the questions those leave open.
• Build the habit of reading assembly weekly, and of recording every measurement with its host, flags and date.