Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects MAGED M. MICHAEL PRESENTED BY NURIT MOSCOVICI ADVANCED TOPICS IN CONCURRENT PROGRAMMING, TECHNION, WINTER

Motivation o Many lock-free algorithms dynamically allocate memory o Reclamation is difficult with no Garbage Collection o In lock-free algorithms any thread can operate on any part of the object at any time. 2

Memory Reclamation o Reclamation for reuse by algorithm: o May corrupt object (ABA) o Reclamation for return to OS: o May cause violation error 3

Memory Reclamation o Reclamation for reuse by algorithm: o May corrupt object (ABA) o Reclamation for return to OS: o May cause violation error 4

ABA problem o Common in lock-free algorithms when memory is released and then reused. o Some ABA problems fixed by safe memory reclamation o Common misconception: All ABA can be fixed this way A P1 B P2 P2: Read val=A Write val = B Write val = A 5 Val

Example – Lock-Free Queue 6 Access Hazard! ABA Hazard!ABA Hazard! ABA Hazard! Access+ ABA Hazard! ABA Hazard! Structure: Head, Tail Node: {Data, Next}

What do we want? o Lock-freedom: tolerate thread delays and failures o Bounded un-reclaimable memory o Enable reuse of memory/return to OS o Easily applicable to existing algorithms o Portability: No need for special HW/kernel support o Efficiency 7

Agenda o Previous Solutions o Hazard Pointers: Basic Solution o Correctness o Using Hazard Pointers o Hazard Pointers: Extended Solution o Results 8

Previous Solutions 9

Non-Blocking Solutions ABA-Prevention Tags o Requires double-width atomic operations o Often does not allow return to OS Lock-Free Reference Counting o Two options: o Use DCAS (mostly unsupported) o Independently CAS pointers and counter non-atomically (hinders reclamation) 10 A12 Cas(&Val,, ) B13 A34

Scheduler-Dependent and Blocking Methods 11

Hazard Pointers 12

Assumptions o For now, assume number of threads is known to be N o Assume each thread has exactly K unsafe references o Unsafe reference: may cause problems if used without validation o Observation: most lock-free algorithms use only a small number of unsafe references per thread. 13

General Idea null C B C ABC … D 14

null General Idea Using Memory: o Must store references in hazard pointers before accessing memory. Reclaiming Memory: o Check hazard pointers of all other threads o Reclamation is forbidden if node referenced by some hazard pointer. A B null C B C ABC … D AB 15

Data Structures o Shared Data: o HPList: Linked list of HPRecords containing hazard pointers o Private (per-thread) Data: o RList: List of nodes the thread has retired from the structure, but has not yet released. AB HPList Head … (N records) C E RList CB 16

Algorithm Algorithm consists of two parts: 1. Algorithm for processing retired nodes o Can be used as-is in every lock-free data structure 2. Condition: an invariant that must be upheld when adding hazard pointers to existing code. o Requires understanding of target lock-free data structure o Must be specially adjusted for every such data structure 17

Part 1: Retiring a Node 18 AFB HPList Head … (N records) C E RList CB F

Scan: Phase 1 o Create temporary local hash table o Iterate over all HPRecs in HPList o Add every non-NULL Hazard Pointer to hash table 19 AFB HPList Head … (N records) C E RList CB F A FB C H G

Scan: Phase 2 o Copy Rlist to temporary new local list o Iterate over tempList and search for each node in hash table o Found: return to Rlist until next scan o Not Found: Call function to release/reuse node o Free the temporary hash table and list 20 RList C E F A FB C H G C E F C F

Complexity of Retiring a Node 21

Complexity of Retiring a Node 22

Some Definitions 23 Head

Safety 24

Some More Definitions 25

Condition for correctness 26 What does this give us?

Correctness 27

A Quick Sketch of Correctness 28

Which gives us: 29

Using Hazard Pointers 30

So, How Do We Apply Hazard Pointers? 31

Back to the Lock-Free Queue 32 Access Hazard! ABA Hazard!ABA Hazard! ABA Hazard! Access+ ABA Hazard! ABA Hazard! Structure: Head, Tail Node: {Data, Next}

What About Dequeue? 33 ABA Hazard!ABA Hazard! Access Hazard! ABA Hazard!

What About Dequeue? 34 ABA Hazard!ABA Hazard! Access Hazard! ABA Hazard!

What About Dequeue? 35 ABA Hazard!ABA Hazard! Access Hazard! ABA Hazard! Access Hazard!

What Now? 36

Applying Hazard Pointers to Enqueue 37 ABA Hazard!ABA Hazard!

Applying Hazard Pointers to Dequeue 38 ABA Hazard!ABA Hazard!

Hazard Pointer Application o Hazard Pointer algorithm can be applied by algorithm designers o Cannot easily be done automatically (by a compiler) o Requires a good understanding of the semantics of the algorithm 39

List-Based Set 40 ABA Hazard!ABA Hazard!

List-Based Set: Adding Hazard Pointers 41 ABA Hazard!ABA Hazard! Assume prev holds head, and so is safe here.

List-Based Set 42 ABA Hazard!ABA Hazard! Search( head, key ) return Find( head, key )

Extended Version 43

Unknown Number of Threads o Allow threads to push new records to global list o Can also be used to make K dynamic o Wait free, as number of threads is finite* 44 HPList Head null

Unknown Number of Threads o Allow threads to push new records to global list o Can also be used to make K dynamic o Wait free, as number of threads is finite* 45 HPList Head null

Unknown Number of Threads o Allow threads to push new records to global list o Can also be used to make K dynamic o Wait free, as number of threads is finite* 46 HPList Head null

Dynamic Join and Leave of Threads Allow reuse of HPs : o Add active indicator flag to each HP record o Acquire inactive record using TAS on flag o Only allocate new record if all existing records are active o Save retired list in record, so retiring thread can pass on it’s un-reclaimed nodes 47 HPList Head null

Guarantee Freeing of All Nodes 48 HPList Head null

Results 49

Results o Same as lock-based implementation under no contention o Better than or equal to ABA-tags and reference counting 50

Questions? 51