High-performance Concurrency in C++ 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 19th and 20th, 2026 (immediately following the conference). Lunch is included.
◈ Register Here ◈ See Other Offerings ◈
Course Description
This course is designed to empower participants with the knowledge and skills required to unlock the full potential of high-performance concurrency in C++. By delving into fundamental principles and advanced techniques, attendees will gain a profound understanding of how to design, implement, and optimize concurrent programs effectively.
The class begins by addressing the essentials of performance and guiding participants on how to evaluate and measure the efficiency of concurrent programs. Emphasis is placed on the significance of performance measurement, providing insights into practical methodologies for assessing program efficiency. The exploration of threads and memory management goes beyond the basics, offering a nuanced understanding of threads in C++, multi-threaded memory access, and the critical aspects of avoiding data races.
Participants will learn effective strategies for synchronizing memory accesses and gain insights into memory models, equipping them to navigate complex memory-related challenges in concurrent programming. The attendees will learn the tools offered by the C++ language, including C++20 and coroutines. We will learn about thread schedulers, thread pools, and pipelines, as well as thread-safe data structures. This class equips participants with a comprehensive skill set to harness the full potential of C++ for high-performance concurrency, covering everything from fundamental principles to advanced tools and techniques.
Unlock the power of high-performance concurrency in C++ with this comprehensive, hands-on two-day course. Designed for developers looking to push their C++ applications to the next level, this class covers everything from fundamental principles to the latest, production-ready concurrency tools in C++20 and C++23cutting-edge concurrency tools introduced in C++20, with a strong focus on practical implementation and real-world challenges.
We begin by addressing the core question of performance: What makes a concurrent program efficient, and how can we measure it? Participants will explore key performance metrics and learn profiling and benchmarking techniques to ensure their code runs optimally in multi-threaded environments.
The class delves into the complexities of multi-threaded programming in modern C++, offering a deep dive into thread management, memory synchronization, and avoiding data races. Attendees will learn how to navigate C++’s memory model and apply best practices for thread-safe programming, ensuring robustness and correctness even in highly concurrent systems.
We will explore practical solutions for real-world concurrency problems using modern C++ features, including thread pools, pipelines, and coroutines, and dive into thread-safe data structures and lock-free algorithms. Through hands-on exercises, participants will build and optimize scalable systems that can handle high workloads efficiently.
By the end of this course, attendees will walk away with a comprehensive toolkit to write high-performance, concurrent C++ applications that are both fast and safe. Whether you’re building server-side systems, real-time applications, or tackling parallel processing challenges, this class will give you the skills to harness modern C++ concurrency like a pro.
Prerequisites
Attendees should have an interest in learning above all, understanding of concurrency concepts, and intermediate-level C++ knowledge.
Course Topics
- Basics of performance
- How to evaluate the performance
- Why performance must be measured
- How to measure the performance of concurrent programs
- Threads and Memory
- Overview of threads
- Threads in C++
- Multi-threaded and multi-core memory access
- Avoiding data races and its cost
- Synchronization of Memory Accesses
- Memory Models
- Overview of C++ tools for concurrency
- C++11/14 – Threads, mutexes, conditions
- C++17 – Parallel STL
- C++20 – advanced synchronization primitives
- C++20/23 – coroutines
- Efficient Concurrency
- Locks and the cost of lock-based synchronization
- Advanced locks
- Thread-Safe Data Structures
- Introduction to Lock-Free Programming
- Examples of lock-free data structures
- Thread scheduling and executors
- What is executor
- Thread pools
- Pipelines
- Concurrency and Hardware
- Memory access in concurrent programs
- Concurrent programs on large systems
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.