concurrency_and_parallelism.md

Concurrency and parallelism

Table of contents

• Introduction and overview
• GPU computing
• Multithreading
  • Concurrency and the standard library
    • std::atomic_shared_ptr
    • std::condition_variable
    • std::promise
  • Data races and race conditions
  • Lock-based
    • Spin locks
  • Lock-free
    • Hazard pointers
    • Read-copy-update (RCU)
  • Memory model
  • POSIX threads

---

Introduction and overview

🔗

• B.Barney. Introduction to parallel computing – Lawrence Livermore National Laboratory

---

GPU computing

🎥

• P.Steinbach. C++ on GPUs done right? – Meeting C++ (2015)

Multithreading

🎥

• F.Petriconi. An adventure in race conditions – ACCU (2019)
• A.Sermersheim. Multithreading is the answer. What is the question? Part I, Part II – CppCon (2017)
• R.Grimm. C++11 multithreading done right? – Meeting C++ (2014)
• A.Williams. The continuing future of C++ concurrency – CppCon (2016)

📖

• P.E.McKenney. Is parallel programming hard, and, if so, what can you do about it? (2018)
• A.Williams. C++ concurrency in action: Practical multithreading (2019)
• Ch. 9: Parallelism and concurrency – J.Galowicz. C++17 STL cookbook: Discover the latest enhancements to functional programming and lambda expressions (2017)
• Ch. 18: Concurrency – N.M.Josuttis. The C++ standard library: A tutorial and reference (2012)

📄

• P.E.McKenney. Memory barriers: A hardware view for software hackers (2010)

Concurrency and the standard library

🔗

• C++11 standard library extensions: Concurrency – Standard C++ Foundation

std::atomic_shared_ptr

🔗

• A.Williams. Why do we need atomic_shared_ptr? (2015)
• What is the difference between std::shared_ptr and std::experimental::atomic_shared_ptr? – Stack Overflow

std::condition_variable

The std::condition_variable is a synchronization primitive that can be used to block a thread, or multiple threads at the same time, until another thread both modifies a shared variable (the condition), and notifies the std::condition_variable.

📝

• Even if the shared variable is atomic, it must be modified under the mutex in order to correctly publish the modification to the waiting thread.

🔗

• std::condition_variable – C++ reference

std::promise

The std::promise provides a facility to store a value or an exception that is later acquired asynchronously via a std::future object created by the std::promise object.

🔗

• std::promise – C++ reference
• What is std::promise? – Stack Overflow

Data races and race conditions

🔗

• Are “data races” and “race condition” actually the same thing in context of concurrent programming – Stack Overflow

Lock-based

Spin locks

📝

• Spin locks are typically slower if the number of threads is larger than the number of cores.

🔗

• When should one use a spinlock instead of mutex? – Stack Overflow
• Spinlock versus semaphore – Stack Overflow

Lock-free

Lock-free programming is a set of techniques for writing concurrent programs without using explicit locks.

🎥

• F.Pikus. C++ atomics, from basic to advanced: What do they really do? – CppCon (2017)
• F.Pikus. Live lock-free or deadlock (practical lock-free programming). Part I, Part II – CppCon (2015)
• H.Sutter. atomic<> weapons: Part I, Part II – C++ and Beyond (2012)

Hazard pointers

🔗

• Hazard pointer – Wikipedia
• A.Alexandrescu, M.Michael. Lock-free data structures with hazard pointers – Dr.Dobb’s Journal (2004)

Read-copy-update (RCU)

🔗

• Read-copy-update – Wikipedia
• P.E.McKenney. Introduction to RCU

🎥

• F.Pikus. Read, copy, update, then what? RCU for non-kernel programmers – CppCon (2017)
• P.E.McKenney. A lock-free concurrency toolkit for deferred reclamation and optimistic speculation – CppCon (2016)

⚓

• Proposed RCU C++ API (2017) – WG21/P0461R1
• Read-copy update (RCU) for C++ (2016) – WG21/P0279R1

Memory model

🔗

• C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming? – Stack Overflow

⚓

• Memory model – C++ reference

POSIX threads

🔗

• B.Barney. POSIX threads programming