Writing Efficient C++ Code (2013)

This article, originally published in 2013, serves as a comprehensive guide to writing efficient C++ code by understanding the underlying hardware. It argues that while high-level languages are convenient, C++ offers a unique compromise for performance-critical applications like game programming, data centers, or embedded systems, provided the developer possesses deep knowledge of its mechanics and good practices. The core message is to design code that works with the hardware, not against it, to unlock maximum computational power.

Key takeaways from the article include:

• Data-Oriented Design (DOD): Advocating for a design philosophy that prioritizes data layout in memory to improve cache locality and enable easier parallelization, contrasting it with traditional object-oriented programming which can lead to fragmented memory access and performance bottlenecks. The difference between Array of Structures (AOS) and Structure of Arrays (SOA) is highlighted for optimizing data access patterns.
• Memory Hierarchy and Cache Awareness: Explaining the significant and ever-growing speed gap between CPUs and main RAM. The article details how processor caches (L1, L2) work by bringing data in "cache lines" and how to benefit from them by arranging frequently used data contiguously, packing data into smallest possible types, and avoiding pointer-heavy structures like linked lists or trees for performance-critical collections.
• Performance Pyramid: Categorizing common operations by their relative cost, from fastest (arithmetic, bitwise) to slowest (disk/network I/O), emphasizing the importance of minimizing slower operations and performing I/O asynchronously.
• C++ Language Features: Discussing how certain C++ features like RTTI and exceptions can introduce overhead and might be selectively disabled. It champions custom allocators for specific use cases and warns against the performance implications of certain STL containers (e.g., std::map, std::list due to dynamic allocations) versus std::vector. The example of EASTL is given as a performance-optimized STL alternative.
• Compiler Optimizations: Illustrating how compilers handle optimizations, including pointer aliasing (and the __restrict keyword) and the difference in performance between declaring std::string inside or outside a loop due to reallocation behavior. It also lists beneficial compiler flags.
• "Premature Optimization" Reconsidered: Recontextualizing Donald Knuth's famous quote to emphasize that optimization isn't just a post-development activity. Instead, it should be an integral part of the design process, understanding that poor architectural choices can be harder to fix than individual slow functions identified by a profiler.

In essence, the article provides a detailed blueprint for C++ developers to think like the machine, ensuring their code isn't just logically correct, but also physically efficient, laying the groundwork for robust and high-performing applications.