Modern C++ Multithreading & Lock-Free Programming(C++20/23)

Introduction to locking mechanisms

Concept of invarient

Mutexes

Things to remember when using mutexes

Thread safe stack implementation : introduction to stack

Thread safe stack implementation : implementation

Thread safe stack implementation : race condition inherit from the interface

Dead locks

Unique locks

Mutex and locks

Introduction to condition variables

Details about condition variables

Thread safe queue implementation : introduction to queue data structure

Introduction to futures and async tasks

Thread safe queue implementation : implementation

Async tasks detailed discussion

Parallel accumulate algorithm implementation with async task

Introduction to package_task

Communication between threads using std::promises

Retrieving exception using std::futures

Std::shared_futures

Introduction to lock based thread safe data structures and algorithms

Queue data structure implementation using linked list data structure

Thread safe queue implementation

Parallel STL introduction

Parallel quick sort algorithm implementation

Parallel for each implementation

Parallel find algorithm implementation with package task

Parallel find algorithm implementation with async

Partial sum algorithm introduction

Partial sum algorithm parallel implementation

Introduction to Matrix

Parallel Matrix multiplication

Parallel matrix transpose

Factors affecting the performance of concurrent code

Jthread : Introduction

Jthread : Our own version implementation

C++ coroutines : Introduction

C++ coroutines : resume functions

C++ coroutines : Generators

C++ Barriers

C++20 stop_tokens and stop_source

C++20 stop_callback

C++20 Counting Semaphore

C++20 Binary Semaphore

C++23 More Generators

Cancellable Pipeline

Introduction to atomic operations

Functionality of std::atomic_flag

Functionality of std::atomic_bool

Explanation of compare_exchange functions

Atomic pointers

General discussion on atomic types

Important relationships related to atomic operations between threads

Introduction to memory ordering options

Discussion on memory_order_seq_cst

Introduction to instruction reordering

Discussion on memory_order_relaxed

Discussion on memory_order_acquire and memory_order_release

Important aspects of memory_order_acquire and memory_order_release

Concept of transitive synchronization

Discussion on memory_order_consume

Concept of release sequence

Implementation of spin lock mutex

Atomic wait and Notify

Atomic ref

Atomic shared pointer

Lock-Free MPSC Queue

Introduction and some terminology

Stack recap

Simple lock free thread safe stack

Stack memory reclaim mechanism using thread counting

Stack memory reclaim mechanism using hazard pointers

Stack memory reclaim mechanism using reference counting

Simple thread pool

Thread pool which allowed to wait on submitted tasks

Thread pool with waiting tasks

Minimizing contention on work queue

Thread pool with work stealing

Setting up the environment for CUDA

Elements of CUDA program

Organization of threads in CUDA program 1

Organization of threads in CUDA program 2

Unique index calculation for threads in a grid

Unique index calculation for threads in a 2D grid

Unique index calculation for threads in a 2D grid 2

Timing a CUDA program

CUDA memory transfer

Sum array example

Error handling in a CUDA program

CUDA device properties