CppCon 2018

Plans are underway to introduce a new chapter in the C++ standard on concurrency, both literally (in the Specification Chapters) and conceptually. One of the topic in this new chapter is Safe Reclamation, which includes sections on:
- Atomic specialization for shared_ptr
- RCU
- Hazard Pointers
- Cell

There are several forms of Safe Reclamation that are now making their way through the C++ Standard Committee. The reference counting-based shared_ptr was introduced in C++11, and then Atomic Shared Pointer in Concurrency TS1. There are now proposals for Hazard Pointers, RCU, and Cell (an abstraction from Google that can build on top of all the other methods) have all advanced out of Study Group 1 (concurrency). Even better, all three proposals have accrued significant usage experience in production.

Of course, both committee discussions and usage experience have resulted in fundamental changes to the proposals over the last two years. This talk will give an overview and the latest status of the proposals, then expand on the new aspects of hazard pointers and RCU. Some of these experiences are pointing to a bright future beyond lock-free programming towards fast and scalable essential concurrent data structures in demanding production environments.

In this talk, we will dissect each of these important components and compare and contrast their qualitative features and performance profiles. We will cover the features that will be included in C++20, and those on track for inclusion in Concurrency TS2. We will discuss the important changes from the C++ standardization process and how they may impact your usage. We will demonstrate examples of use of these technique.

Beyond the current proposals, there are possible interface additions based on user experience in production. We will present newly added features to the hazard pointer method that expand its applicability to general concurrent data structures. The new interface is based on novel algorithmic additions to the method that use reference counting judiciously, with zero reader overhead and minimal writer overheads. We will show the usage of these interface expansions in common data structures, with code examples from the hazard pointer implementation in the Folly open-source library.