## +21 ## Hazard Pointer Synchronous Reclamation Beyond Concurrency TS2 ## MAGED MICHAEL ## Basic Hazard Pointer Algorithm Hazard pointers protect access to objects that may be removed concurrently concurrently. A hazard pointer is a single-writer multi-reader pointer. If a hazard pointer points to an object before its removal, then the object will not be reclaimed as long as the hazard pointer remains unchanged Concurrency TS2 Essential Hazard Pointer Interface class hazard_pointer { template T* protect(const std::atomic& src) noexcept; }; hazard_pointer make_hazard_pointer(); Base class

Don’t we already have a Concurrency TS? • Why do we need a new one? • implementation status 2.TS2 Hazard Pointer • how I learn to love C++ tricks ### 3. TS2 RCU • From C to C++ in 2500 days ![Image scalability 3. So Procrastinate away! Use Structured Deferral 4. Shared ptr vs atomic shared ptr vs hazard pointers vs Read 5.Hazard Pointers 6. Read Copy Update 7.A Concurrency Toolkit for C++ ![Ima These are cell, hazard ptr and RCU. These extend the existing shared_ptr and the proposed atomic_shared_ptr which all have safe reclamation facilities. As such we also propose moving shared_ptr and atomic>

ModernesCpp.net ## Smart Pointer A First Overview std::unique_ptr – Exclusive Ownership std::shared_ptr - Shared Ownership std::weak_ptr – Break of Cyclic References Performance Concurrency Function Return Values ## Smart Pointer A First Overview std::unique_ptr – Exclusive Ownership std::shared_ptr - Shared Ownership std::weak ptr – Break of Cyclic References Performance Concurrency Function |---|---|---| |std::auto\_ptr|C++98|Owns the resource exclusively| |std::unique\_ptr|C++11|Owns the resource exclusivelyCan not be copiedDeals with non-copy objects| |std::shared\_ptr|C++11|Shares a resourceSupports

variable std::string func( std::string param, std::string* ptr ) { std::string local = "Hello" + param; *ptr = param; *ptr = local; if (some_condition()) { return param; return *ptr; } ## Guideline: Don’t std::move the return of a local variable std::string func( std::string param, std::string* ptr ) { std::string local = "Hello" + param; *ptr = param; param; *ptr = local; if (some_condition()) { return param; } else if (other_condition()) { return local; } return *ptr; } ## Guideline: Don’t std::move the return of a local

WONG 20 24 September 15 - 20 ## Agenda 1. Improving C++20 Atomic Min/Max(P0493; Michael) 2. Hazard pointer extensions (P3135; Maged) 3. Pointer tagging (P3125; Maged) 4. Parallel Range algorithms benefits Additional functions for more specific needs ## Hazard Pointer Extensions beyond C++26 ## Hazard Pointers in C++26 -- Background Hazard pointers protect dynamic objects from being reclaimed, allowing 7_1.jpg) ## Hazard Pointers C++26 template > class hazard_pointer_obj_base { void retire(D d = D()) noexcept; }; class hazard_pointer {

net ## What we'll learn today • How shared ptr is implemented under the hood • Atomics and concurrency patterns • How existing atomicptr> are implemented (the split reference count technique) • You’ve heard of shared_ptr Things we won't cover • Alias pointers, weak pointers Carnegie Mellon Universityptr> ## What we'll learn today • How shared ptr is implemented under the the hood • Atomics and concurrency patterns • How existing atomicptr> are implemented (the split reference count technique) • Deferred reclamation, i.e., garbage collection in C++ ## Some assumed

to_chars) 2 if (auto result = std::to_chars(p, last, 42)) { 3 // okay, use char pointer 4 auto [ptr, _] = result; 5 } else { 6 // handle errors 7 auto [_, ec] = result; 8 } 9 10 //after: 11 if to_chars) 2 if (auto result = std::to_chars(p, last, 42)) { 3 // okay, use char pointer 4 auto [ptr, _] = result; 5 } else { 6 // handle errors 7 auto [_, ec] = result; 8 } 9 10 //after: 11 if for success or failure of functions ## • in draft struct to_chars_result { char* ptr; errc ec; friend bool operator=(const to_chars_result&, const to_chars_result&) = default;

exact match in the set of operators considered), use it. Lack of an exact match creates a security hazard when calling, via qualified name 1 (not typical), any operator found in a schema that permits untrusted If exactly one candidate passes this test, use it. Otherwise, fail. Some examples follow. 1 The hazard does not arise with a non-schema-qualified name, because a search path containing schemas that permit two functions are in the same schema, the non-variadic one is preferred. This creates a security hazard when calling, via qualified name 2, a variadic function found in a schema that permits untrusted

exact match in the set of operators considered), use it. Lack of an exact match creates a security hazard when calling, via qualified name $ {}^{1} $ (not typical), any operator found in a schema. that two functions are in the same schema, the non-variadic one is preferred. This creates a security hazard when calling, via qualified name $ {}^{2} $ , a variadic function found in a schema that permits as though you executed them. Substitute a call bearing the VARIADIC keyword, which bypasses this hazard. Calls populating VARIADIC "any" parameters often have no equivalent formulation containing

exact match in the set of operators considered), use it. Lack of an exact match creates a security hazard when calling, via qualified name $ {}^{1} $ (not typical), any operator found in a schema that two functions are in the same schema, the non-variadic one is preferred. This creates a security hazard when calling, via qualified name $ {}^{2} $ , a variadic function found in a schema that permits as though you executed them. Substitute a call bearing the VARIADIC keyword, which bypasses this hazard. Calls populating VARIADIC "any" parameters often have no equivalent formulation containing