Modern C++20: Multithreading Deep Dive & Concurrency Design

Course Curriculum

Chapter 1: Introduction

Lecture 1: Course Structure – Most lectures have code walkthroughs or tool demos

Lecture 2: [BEGINNER] Introduction to simplified hardware model used through the course.

Chapter 2: Modern C++ Memory Model : Available since C++11

Lecture 1: Memory Model guarantees

Lecture 2: External factors affecting the program execution workflow of a C++ program

Lecture 3: Sequential consistency definition in multithreaded applications

Lecture 4: Race condition in concurrency with regard to sequential consistency

Lecture 5: SC-DRF : Sequential Consistency (Data Race Free)

Lecture 6: Role of Modern C++ memory model in guarantee of SC-DRF

Chapter 3: Code Optimizations: Behind the scenes [C++ Memory Model]

Lecture 1: Simple optimization example

Lecture 2: Code walkthrough of issue with the concurrent execution of multithreaded code

Lecture 3: Optimization example with single threaded code

Lecture 4: Summary and general tips around optimization of concurrent code in modern C++

Chapter 4: Concurrency and barriers [C++ Memory Model]

Lecture 1: Thinking in Transactions

Lecture 2: The concept of critical section in concurrent and multithreaded applications

Lecture 3: Concurrency considerations while moving code out of critical sections

Lecture 4: Concurrency considerations while moving code inside of critical sections

Lecture 5: Concept of acquire and release barriers in concurrency memory models

Lecture 6: Considerations while choosing memory barriers while desiging for multithreading

Lecture 7: A closer look at barriers and their relation to sequential consistency

Lecture 8: Summary of memory barriers in concurrent applications

Lecture 9: Impact of external optimizations on concurreny in modern C++ applications

Chapter 5: Performance analysis of atomics data types in modern C++ [C++ Memory Model]

Lecture 1: Considerations while making performace measurements

Lecture 2: Code experiment recommended to be performed by students.

Lecture 3: Code demonstartion of behavior of atomic variables in practice

Lecture 4: Do atomic variables wait for each other?

Lecture 5: False sharing in concurrency and multithreading

Chapter 6: Compare and Swap in Modern C++ [C++ Memory Model]

Lecture 1: Introduction to compare and swap

Lecture 2: Example of compare and swap

Lecture 3: Pseudo code implementation of compare and exchange strong

Lecture 4: Pseudo code implementation of compare exchange strong – faster

Lecture 5: Compare and exchange weak – reason for spurios failures

Chapter 7: Memory ordering in multithreading with Modern C++ memory model

Lecture 1: Memory ordering basics in concurrency

Lecture 2: Memory ordering nuances

Lecture 3: Memory ordering and memory barriers in modern C++ language

Lecture 4: Acquire Barrier in Modern C++

Lecture 5: Release Barrier in Modern C++

Lecture 6: Using acquire and release barriers for synchronization in multithreading

Lecture 7: Using memory barriers as locks for efficient concurreny with modern C++

Lecture 8: Bidirectional barriers in Modern C++ memory model

Lecture 9: Why does compare and exchange in C++ have two parameters for memory ordering?

Chapter 8: Memory order : Software Design and performance considerations [C++ Memory Model]

Lecture 1: Purpose of memory order in modern C++ concurrency memory model

Lecture 2: Memory order as a tool to convey the C++ programmer's intent

Lecture 3: Memory order as programmer's intent : Example – 1

Lecture 4: Memory order as programmer's intent : Example – 2

Lecture 5: Memory order as programmer's intent : Example – 3

Lecture 6: Memory barriers and performance implications

Lecture 7: Sequential consistency and performance implications

Lecture 8: Design and implementation guidelines for using std::atomics

Lecture 9: When to use the atomics provided by the modern C++?

Chapter 9: Lock Free C++ Concurrent Design Fundamentals [Data Strcuture Design]

Lecture 1: Concepts of Wait free programming in modern C++

Lecture 2: Understanding Lock-Free Algorithms: Balancing Progress and Throughput

Lecture 3: Mastering Obstruction-Free Programming: A Guide to Lock-Free Algorithms

Lecture 4: Unlocking ACID Principles in Lock-Free Programming

Lecture 5: Essentials of Atomic Operations in C++11: A Practical Overview

Lecture 6: Advanced Atomic Operations in C++: Mastering Concurrency and Locking

Chapter 10: Double Check Locking Deep Dive to understand the Modern C++ & Concurrent Design

Lecture 1: Implementing Double-Check Locking in C++: From Single to Multi-threaded Program

Lecture 2: Code walkthrough of concurrent implementation using mutex and atomics of C++11

Lecture 3: Efficient Lazy Initialization in C++11: Leveraging Unique Pointers and Once Flag

Lecture 4: The surpirisngly cleanest concurrent initlaization solution!

Lecture 5: Optimizing Concurrent Data Structures in C++: Beyond Syntax to Effective Design

Chapter 11: Concurrent Singly Linked List analysis using Modern C++ Concurrency primitives

Lecture 1: Crafting Lock-Free Singly Linked Lists in C++: A Guide to Concurrent Data Struct

Lecture 2: Code walkthrough of the implementation using Modern C++ Concurrency features

Lecture 3: Code Walkthrough of Constructor, Destructor and Find function implementation

Lecture 4: Analysis of the push_front function of the concurrent singly linked list

Lecture 5: Analysis of the pop_front function design for a concurrent singly linked list

Chapter 12: ABA problem, RCU, Hazard pointers. Concurrent Design Solutions using Modern C++

Lecture 1: ABA problem in concurrent systems explained

Lecture 2: Solutions for ABA problems in multithreading environments

Lecture 3: Challenges and solutions for deletion in Concurrent data structures

Lecture 4: Concurrent Singly Linked List implemented using Reference Class & Modern C++

Lecture 5: Implementation details for using the Reference Class of concurrent linked list

Lecture 6: Concurreny analysis of mulithreading events in the refernce class