Thread management guide
- Setting up the environment for the course
- Introduction to parallel computing
- Quiz : Parallel programming in general
- How to launch a thread
- Programming exercise 1 : Launching the threads
- Joinability of threads
- Join and detach functions
- How to handle join, in exception scenarios
- Programming exercise 2 : Trivial sale a ship model
- How to pass parameters to a thread
- Problematic situations may arise when passing parameters to a thread
- Transferring ownership of a thread
- Some useful operations on thread
- Programming excersice 3 : Sail a ship with work queues
- Parallel accumulate - algorithm explanation
- Parallel accumulate algorithm implementation
- Thread local storage
- Debugging a application in Visual studio
- Thread management
Thread safe access to shared data and locking mechanisms
- 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
Communication between thread using condition variables and futures
- introduction to condition variables
- Details about condition variables
- Thread safe queue implementation : introduction to queue data structure
- Thread safe queue implementation : implementation
- introduction to futures and async tasks
- 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
Lock based thread safe data structures and algorithm implementation
- 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
C++20 Concurrency features
- Jthread : Introduction
- Jthread : Our own version implementation
- C++ coroutines : Introduction
- C++ coroutines : resume functions
- C++ coroutines : Generators
- C++ Barriers
C++ memory model and atomic operations
- 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
Lock free data structures and algorithms
- 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
Thread pools
- 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
Bonus section : Parallel programming in massively parallel devices with CUDA
- Setting up the environment for CUDA
- Elements of CUDA program
- Organization of threads in CUDA program 1
