Performance and Efficiency in C++ for Experts, Future Experts, and Everyone Else is a two-day onsite training course with programming exercises, taught by Fedor Pikus.  It is offered at the Gaylord Rockies from 09:00 to 17:00 Aurora time (MDT) on Saturday and Sunday, September 12th and 13th, 2026 (immediately prior to the conference). Lunch is included.

◈ Register Here ◈ See Other Offerings ◈

Course Description

Your compiler is smart, but it is not a magician. It cannot fix a design that fights the hardware, nor can it optimize code that hides its intent. To achieve the peak performance C++ is capable of, you must master the deep interplay between the language, the compiler, and the physical machine. Most C++ developers know how to write code that is correct. Fewer know the actual cost of the abstractions they use. And only a small fraction understand how the compiler translates those abstractions into physical execution.

This class reveals the “secret life” of your application. We move beyond standard optimization advice to explore the mechanical sympathy required to squeeze every cycle out of modern systems. We will examine code from three perspectives: the hardware that executes it, the compiler that generates it, and the language rules that constrain it. We will demonstrate that performance is not an afterthought but a fundamental part of the design specification. You will learn how to validate that specification early—running “estimation benchmarks” on mock-ups to predict performance before writing a single line of production code.

We will unlock the specific behaviors that dictate speed across three critical layers:

• The Hardware Reality: Moving beyond “cache friendly” to understand the physics of the memory hierarchy, pipeline hazards, and why data layout often matters more than instruction count.
• The Compiler Partnership: How to read assembly to verify optimizations, how to structure code so the compiler can vectorize it, and understanding the critical (and often misunderstood) role of Undefined Behavior in generating efficient code.
• Design for Performance: How to integrate performance constraints into your architecture from day one, using estimation techniques to distinguish feasible designs from dead ends.

Crucially, we will challenge the myth that efficient code must be unreadable. We will point out concrete examples of how modern design practices and clean coding styles often align perfectly with hardware requirements, allowing you to write software that is maintainable, robust, and ruthlessly efficient.

This class is about performance and efficiency, spanning the entire range from the fundamentals of the hardware to the peculiarities of compiler optimizations. You will learn, on practical examples extracted from real-life programs, how to measure, analyze, and improve the performance of your programs. But most importantly, you will learn how to understand why your programs, compilers, and hardware behave the way they do. Some of the material will be basic and fundamental, some cutting-edge and esoteric, and the rest somewhere in between. All explanations will be reinforced with hands-on exercises, which you get to do in the classroom and can explore later in detail if you want to learn more.

Prerequisites

Desire to learn above all. C++ competence at the intermediate level, some familiarity with concurrent programming are needed.

Course Topics

1. Why performance matters
   1. Why performance requires the programmer’s attention
   2. General types of factors affecting performance
   3. Different types of performance
   4. How to evaluate the performance
2. Performance measurements
   1. Why performance must be measured
   2. Performance metrics
   3. Performance measurement tools (benchmarks, timers)
   4. Profiling and profiler tools
3. CPU architecture, resources, and performance implications
   1. The architecture of modern CPUs
   2. Using internal concurrency of the CPUs for optimum performance
   3. CPU pipelines and conditional execution
   4. Branch optimization and branchless computing
   5. Speculative execution
4. Memory Architecture and Performance Impact
   1. Overview of the memory subsystem
   2. Performance of memory accesses
   3. Access Patterns and Impact on Algorithms and Data Structure Design
   4. Memory bandwidth and latency
5. High-performance C++
   1. Efficiency and overhead of the C++ language
   2. Avoiding inefficient C++ code
6. Compiler optimizations in C++
   1. How do compilers see your code
   2. How to get the best optimizations from the compiler
7. Undefined behavior and performance
   1. What is undefined behavior
   2. How is UB related to performance
   3. How to use UB for performance gain

Course Instructor

Fedor G. Pikus is a Technical Fellow and the Director of the Advanced Projects Team in Siemens Digital Industries Software. His responsibilities include planning the long-term technical direction of Calibre products, directing and training the engineering teams, overseeing the design and architecture of the software, and researching new design and software technologies.

His earlier positions included a Chief Scientist at Mentor Graphics (acquired by Siemens Software), Senior Software Engineer at Google, and a Chief Software Architect for Calibre PERC, LVS, and DFM. He joined Mentor Graphics in 1998 when he made a switch from academic research in computational physics to the software industry.

Fedor is a recognized expert in high-performance computing and C++. He is an O’Reilly author and has written three books on C++ and software design. He is a regular instructor at the CppCon Academy, leading two of the best-attended classes, and has presented his work at CppNow, CppCon, CppNorth, SD West, DesignCon, and in various software development journals. Fedor holds over 30 patents and has authored over 100 papers and conference presentations on physics, EDA, software design, and the C++ language.

◈ Register Here ◈ See Other Offerings ◈