We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
C++ Concurrency TS 2 Use Cases and Future Direction - Michael Wong, Maged Michael, Paul McKenney
Learn about the benefits and limitations of C++ Concurrency TS 2, a low-overhead reader-writer synchronization pattern, and explore its use cases and future direction with experts Michael Wong, Maged Michael, and Paul McKenney.
- Concurrency TS 2 is a pattern used in the Linux kernel for low-overhead reader-writer synchronization.
- It’s a way to release resources without blocking other readers or writers.
- Reader-writer blocks are a good solution when data is mostly read-only.
- Hazard pointers are used to ensure that readers don’t get stuck on removed data.
- RCU (Read-Copy-Update) is a low-overhead algorithm for synchronization.
- It’s not suitable for scenarios with high contention.
- TS will never be used for high-performance critical sections.
- TS has low overhead and is suitable for many use cases.
- TS is not widely used, but has been shown to be effective.
- The goal of Concurrency TS is to make low-latency and high-throughput concurrent programming available to all C++ developers.
- Reference counting is a type of synchronization that is is used for memory management.
- RCU is more complex than hazard pointers, but is necessary for certain use cases.
- Locked modes are typically used for low-level synchronization.
- The cost of using locked modes is relatively high.
- TS provides support for all these features in a framework.
- The current state of the standard library is confusing and inconsistent.
- Concurrency TS provides clarity and consistency.
- It provides a good balance between performance and correctness.
- It is possible to achieve high-performance concurrent programming with TS.