Modern C++ Concurrency in Depth ( C++17/20)

Course Curriculum

Chapter 1: Thread management guide

Lecture 1: Setting up the environment for the course

Lecture 2: Introduction to parallel computing

Lecture 3: Quiz : Parallel programming in general

Lecture 4: How to launch a thread

Lecture 5: Programming exercise 1 : Launching the threads

Lecture 6: Joinability of threads

Lecture 7: Join and detach functions

Lecture 8: How to handle join, in exception scenarios

Lecture 9: Programming exercise 2 : Trivial sale a ship model

Lecture 10: How to pass parameters to a thread

Lecture 11: Problematic situations may arise when passing parameters to a thread

Lecture 12: Transferring ownership of a thread

Lecture 13: Some useful operations on thread

Lecture 14: Programming excersice 3 : Sail a ship with work queues

Lecture 15: Parallel accumulate – algorithm explanation

Lecture 16: Parallel accumulate algorithm implementation

Lecture 17: Thread local storage

Lecture 18: Debugging a application in Visual studio

Chapter 2: Thread safe access to shared data and locking mechanisms

Lecture 1: Introduction to locking mechanisms

Lecture 2: Concept of invarient

Lecture 3: mutexes

Lecture 4: Things to remember when using mutexes

Lecture 5: Thread safe stack implementation : introduction to stack

Lecture 6: Thread safe stack implementation : implementation

Lecture 7: Thread safe stack implementation : race condition inherit from the interface

Lecture 8: Dead locks

Lecture 9: unique locks

Chapter 3: Communication between thread using condition variables and futures

Lecture 1: introduction to condition variables

Lecture 2: Details about condition variables

Lecture 3: Thread safe queue implementation : introduction to queue data structure

Lecture 4: Thread safe queue implementation : implementation

Lecture 5: introduction to futures and async tasks

Lecture 6: async tasks detailed discussion

Lecture 7: Parallel accumulate algorithm implementation with async task

Lecture 8: Introduction to package_task

Lecture 9: Communication between threads using std::promises

Lecture 10: Retrieving exception using std::futures

Lecture 11: std::shared_futures

Chapter 4: Lock based thread safe data structures and algorithm implementation

Lecture 1: introduction to lock based thread safe data structures and algorithms

Lecture 2: queue data structure implementation using linked list data structure

Lecture 3: thread safe queue implementation

Lecture 4: Parallel STL introduction

Lecture 5: parallel quick sort algorithm implementation

Lecture 6: parallel for each implementation

Lecture 7: parallel find algorithm implementation with package task

Lecture 8: parallel find algorithm implementation with async

Lecture 9: Partial sum algorithm introduction

Lecture 10: Partial sum algorithm parallel implementation

Lecture 11: Introduction to Matrix

Lecture 12: Parallel Matrix multiplication

Lecture 13: Parallel matrix transpose

Lecture 14: Factors affecting the performance of concurrent code

Chapter 5: C++20 Concurrency features

Lecture 1: Jthread : Introduction

Lecture 2: Jthread : Our own version implementation

Lecture 3: C++ coroutines : Introduction

Lecture 4: C++ coroutines : resume functions

Lecture 5: C++ coroutines : Generators

Lecture 6: C++ Barriers

Chapter 6: C++ memory model and atomic operations

Lecture 1: Introduction to atomic operations

Lecture 2: Functionality of std::atomic_flag

Lecture 3: Functionality of std::atomic_bool

Lecture 4: Explanation of compare_exchange functions

Lecture 5: atomic pointers

Lecture 6: General discussion on atomic types

Lecture 7: Important relationships related to atomic operations between threads

Lecture 8: Introduction to memory ordering options

Lecture 9: Discussion on memory_order_seq_cst

Lecture 10: Introduction to instruction reordering

Lecture 11: Discussion on memory_order_relaxed

Lecture 12: Discussion on memory_order_acquire and memory_order_release

Lecture 13: Important aspects of memory_order_acquire and memory_order_release

Lecture 14: Concept of transitive synchronization

Lecture 15: Discussion on memory_order_consume

Lecture 16: Concept of release sequence

Lecture 17: Implementation of spin lock mutex

Chapter 7: Lock free data structures and algorithms

Lecture 1: Introduction and some terminology

Lecture 2: Stack recap

Lecture 3: Simple lock free thread safe stack

Lecture 4: Stack memory reclaim mechanism using thread counting

Lecture 5: Stack memory reclaim mechanism using hazard pointers

Lecture 6: Stack memory reclaim mechanism using reference counting

Chapter 8: Thread pools

Lecture 1: Simple thread pool

Lecture 2: Thread pool which allowed to wait on submitted tasks

Lecture 3: Thread pool with waiting tasks

Lecture 4: Minimizing contention on work queue

Lecture 5: Thread pool with work stealing

Chapter 9: Bonus section : Parallel programming in massively parallel devices with CUDA

Lecture 1: Setting up the environment for CUDA

Lecture 2: Elements of CUDA program