lock free concurrent data structures
play

Lock-Free Concurrent Data Structures Danny Hendler Ben-Gurion - PowerPoint PPT Presentation

Jan 17, 2023 •482 likes •2.32k views

Lock-Free Concurrent Data Structures Danny Hendler Ben-Gurion University 1 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017 Key synchronization alternatives 1. Lock-based synchronizaGon 2. Nonblocking algorithms 3. TransacGonal

  1. AtomicReference Atomically update reference ce class • At Atomi micR cRefere rence – Java.util.concurrent.atomic package Public object get(); Public object get(); Public Public boolean boolean compareAndSet compareAndSet (T expected, T new); (T expected, T new); Apply CAS: if expected value, change to new 39 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  2. Michael & Scott queue Deq head tail Read value 40 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  3. Michael & Scott queue Deq Make first Node new sentinel CAS head tail 41 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  4. Michael & Scott queue Queue node public class public class Node { Node { public public T value; T value; public public AtomicReference AtomicReference<Node> next; <Node> next; public public Node(T value) { Node(T value) { this.value this.value=value; =value; next=new next=new AtomicReference AtomicReference<Node>(null); <Node>(null); } } } } 42 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  5. Michael & Scott queue Queue node public class Node { public class Node { public public T value; T value; public public AtomicReference AtomicReference<Node> next; <Node> next; public Node(T value) { public Node(T value) { this.value this.value=value; =value; next=new next=new AtomicReference AtomicReference<Node>(null); <Node>(null); } } } } Value stored by node 43 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  6. Michael & Scott queue Queue node public class Node { public class Node { public T value; public T value; public public AtomicReference AtomicReference<Node> next; <Node> next; public Node(T value) { public Node(T value) { this.value this.value=value; =value; next=new next=new AtomicReference AtomicReference<Node>(null); <Node>(null); } } } } Reference to next queue node 44 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  7. Michael & Scott queue Queue node public class Node { public class Node { public T value; public T value; public public AtomicReference AtomicReference<Node> next; <Node> next; public public Node(T value) { Node(T value) { this.value this.value=value; =value; next=new next=new AtomicReference AtomicReference<Node>(null); <Node>(null); } } } } New node created with null ‘next’ 45 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  8. Michael & Scott queue Enq pseudo-code public public boolean boolean enq enq(T value) { (T value) { Node node=new Node(value); Node node=new Node(value); while while ( (true true) { ) { Node last = tail.get Node last = tail.get(); (); Node next = Node next = last.next.get last.next.get(); (); if if (last == (last == tail.get tail.get()) { ()) { if if (next == (next == null null) { ) { if if ( (last.next.compareAndSet last.next.compareAndSet(null null,node ,node) { ) { tail.compareAndSet tail.compareAndSet(last,node last,node); ); return; return; } } } } else else { { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } } } } } 46 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  9. Michael & Scott queue Enq pseudo-code public public boolean boolean enq enq(T value) { (T value) { Node Node node=new Node(value); node=new Node(value); while (true) { while (true) { Node last = tail.get Node last = tail.get(); (); Node next = Node next = last.next.get last.next.get(); (); if (last == tail.get if (last == tail.get()) { ()) { if (next == null) { if (next == null) { if ( if (last.next.compareAndSet last.next.compareAndSet(null,node null,node) { ) { tail.compareAndSet tail.compareAndSet(last,node last,node); ); return; return; } } } else { } else { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } Create new node } } } } 47 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  10. Michael & Scott queue Enq pseudo-code public boolean public boolean enq enq(T value) { (T value) { Node node=new Node(value); Node node=new Node(value); while (true) { while (true) { Node last = Node last = tail.get tail.get(); (); Node next = Node next = last.next.get last.next.get(); (); if (last == tail.get if (last == tail.get()) { ()) { if (next == null) { if (next == null) { if ( if (last.next.compareAndSet last.next.compareAndSet(null,node null,node) { ) { tail.compareAndSet tail.compareAndSet(last,node last,node); ); return; return; } } } else { } else { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } Repeat until successful } } } } 48 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  11. Michael & Scott queue Enq pseudo-code public boolean public boolean enq enq(T value) { (T value) { Node node=new Node(value); Node node=new Node(value); while (true) { while (true) { Node last = Node last = tail.get tail.get(); (); Node next = last.next.get Node next = last.next.get(); (); if (last == if (last == tail.get tail.get()) { ()) { if (next == null) { if (next == null) { if ( if (last.next.compareAndSet last.next.compareAndSet(null,node null,node) { ) { tail.compareAndSet tail.compareAndSet(last,node last,node); ); return; return; } } } else { } else { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } Read tail and its next reference } } } } 49 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  12. Michael & Scott queue Enq pseudo-code public boolean public boolean enq enq(T value) { (T value) { Node node=new Node(value); Node node=new Node(value); while (true) { while (true) { Node last = Node last = tail.get tail.get(); (); Node next = Node next = last.next.get last.next.get(); (); if (last == tail.get if (last == tail.get()) { ()) { if (next == null) { if (next == null) { if ( if (last.next.compareAndSet last.next.compareAndSet(null,node null,node) { ) { tail.compareAndSet tail.compareAndSet(last,node last,node); ); return; return; } } } else { } else { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } } } If no need to fix tail, CAS last . next } } 50 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  13. Michael & Scott queue Enq pseudo-code public boolean public boolean enq enq(T value) { (T value) { Node node=new Node(value); Node node=new Node(value); while (true) { while (true) { Node last = Node last = tail.get tail.get(); (); Node next = Node next = last.next.get last.next.get(); (); if (last == tail.get if (last == tail.get()) { ()) { if (next == null) { if (next == null) { if ( if (last.next.compareAndSet last.next.compareAndSet(null,node null,node) { ) { tail.compareAndSet tail.compareAndSet(last,node last,node); ); return; return; } } } else { } else { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } If successful, try to fix tail } } } } 51 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  14. Michael & Scott queue Enq pseudo-code public boolean public boolean enq enq(T value) { (T value) { Node node=new Node(value); Node node=new Node(value); while (true) { while (true) { Node last = Node last = tail.get tail.get(); (); Node next = Node next = last.next.get last.next.get(); (); if (last == tail.get if (last == tail.get()) { ()) { if (next == null) { if (next == null) { if ( if (last.next.compareAndSet last.next.compareAndSet(null,node null,node) { ) { tail.compareAndSet tail.compareAndSet(last,node last,node); ); return; return; } } } else { } else { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } } } Try to fix tail } } 52 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  15. Michael & Scott queue Deq pseudo-code public T public T deq deq() throws () throws EmptyException EmptyException{ { while while ( (true true) { ) { Node first = Node first = head.get head.get(); (); Node last = Node last = tail.get tail.get(); (); Node next = Node next = first.next.get first.next.get(); (); if if (first == last) { (first == last) { if if (next == (next == null null) { ) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } else else { { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; } } } } } } 53 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  16. Michael & Scott queue Deq pseudo-code public T deq public T deq() throws () throws EmptyException EmptyException{ { while (true) { while (true) { Node first = Node first = head.get head.get(); (); Node last = Node last = tail.get tail.get(); (); Node next = Node next = first.next.get first.next.get(); (); if (first == last) { if (first == last) { if (next == null) { if (next == null) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } else { } else { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; } } } } Return value or throw EmptyException } } 54 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  17. Michael & Scott queue Deq pseudo-code public T deq public T deq() throws () throws EmptyException EmptyException{ { while while ( (true true) { ) { Node first = Node first = head.get head.get(); (); Node last = tail.get Node last = tail.get(); (); Node next = Node next = first.next.get first.next.get(); (); if (first == last) { if (first == last) { if (next == null) { if (next == null) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } else { } else { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; } } } } Repeat until completed } } 55 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  18. Michael & Scott queue Deq pseudo-code public T deq public T deq() throws () throws EmptyException EmptyException{ { while (true) { while (true) { Node first = Node first = head.get head.get(); (); Node last = Node last = tail.get tail.get(); (); Node next = first.next.get Node next = first.next.get(); (); if if (first == last) { (first == last) { if (next == null) { if (next == null) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } else { } else { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; } } } } If head and tail are same node… } } 56 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  19. Michael & Scott queue Deq pseudo-code public T deq public T deq() throws () throws EmptyException EmptyException{ { while (true) { while (true) { Node first = Node first = head.get head.get(); (); Node last = Node last = tail.get tail.get(); (); Node next = Node next = first.next.get first.next.get(); (); if (first == last) { if (first == last) { if if (next == (next == null null) { ) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } else { } else { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; If queue contains only sentinel, } } } } it is empty } } 57 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  20. Michael & Scott queue Deq pseudo-code public T deq public T deq() throws () throws EmptyException EmptyException{ { while (true) { while (true) { Node first = Node first = head.get head.get(); (); Node last = Node last = tail.get tail.get(); (); Node next = first.next.get Node next = first.next.get(); (); if (first == last) { if (first == last) { if (next == null) { if (next == null) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } else { } else { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; } } Otherwise, tail should be fixed } } } } 58 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  21. Michael & Scott queue Deq pseudo-code public T deq public T deq() throws () throws EmptyException EmptyException{ { while (true) { while (true) { Node first = Node first = head.get head.get(); (); Node last = Node last = tail.get tail.get(); (); Node next = first.next.get Node next = first.next.get(); (); if (first == last) { if (first == last) { if (next == null) { if (next == null) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } else else { { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; } } Try to dequeue from first node } } } } 59 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  22. Michael & Scott queue Enq linearization points public public boolean boolean enq enq(T value) { (T value) { Node node=new Node(value); Node node=new Node(value); while while ( (true true) { ) { Node last = tail.get Node last = tail.get(); (); Node next = Node next = last.next.get last.next.get(); (); if if (last == (last == tail.get tail.get()) { ()) { if if (next == (next == null null) { ) { if if ( (last.next.compareAndSet last.next.compareAndSet(null null,node ,node) { ) { tail.compareAndSet tail.compareAndSet(last,node last,node); ); return; return; } } } } else else { { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } } } } } 60 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  23. Michael & Scott queue Enq linearization points public public boolean boolean enq enq(T value) { (T value) { Node node=new Node(value); Node node=new Node(value); while while ( (true true) { ) { Node last = Node last = tail.get tail.get(); (); Node next = last.next.get Node next = last.next.get(); (); if if (last == (last == tail.get tail.get()) { ()) { if if (next == (next == null null) { ) { if if ( (last.next.compareAndSet last.next.compareAndSet(null null,node ,node) { ) { Upon tail.compareAndSet tail.compareAndSet(last,node last,node); ); success return; return; } } } } else else { { tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } } } } } 61 } } Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  24. Michael & Scott queue Deq linearization points public T public T deq deq() throws () throws EmptyException EmptyException{ { while while ( (true true) { ) { Node first = Node first = head.get head.get(); (); Node last = tail.get Node last = tail.get(); (); Node next = Node next = first.next.get first.next.get(); (); if if (first == last) { (first == last) { if if (next == (next == null null) { ) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } else else { { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; } } } } } } Danny Hendler, SPTCC summer school, 62 } } Saint-Petersburg, 2017

  25. Michael & Scott queue Deq linearization points public T public T deq deq() throws () throws EmptyException EmptyException{ { while while ( (true true) { ) { Node first = Node first = head.get head.get(); (); Node last = tail.get Node last = tail.get(); (); Node next = Node next = first.next.get first.next.get(); (); if if (first == last) { (first == last) { if if (next == (next == null null) { ) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } else else { { T value = T value = next.value next.value; ; Upon if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) success return value; return value; } } } } } } Danny Hendler, SPTCC summer school, 63 } } Saint-Petersburg, 2017

  26. Michael & Scott queue Deq linearization points public T public T deq deq() throws () throws EmptyException EmptyException{ { while while ( (true true) { ) { Node first = Node first = head.get head.get(); (); Node last = Node last = tail.get tail.get(); (); When Node next = Node next = first.next.get first.next.get(); (); empty if if (first == last) { (first == last) { if if (next == (next == null null) { ) { throw new throw new EmptyException EmptyException(); (); } } tail.compareAndSet tail.compareAndSet(last,next last,next); ); } } else else { { T value = T value = next.value next.value; ; if ( if (head.compareAndSet head.compareAndSet(first,next first,next)) )) return value; return value; } } } } } } Danny Hendler, SPTCC summer school, 64 } } Saint-Petersburg, 2017

  27. Talk Outline n Preliminaries n A simple lock-free stack algorithm Linearizability o n Michael & Sco] queue algorithm n The Harris-Michael linked list algorithm n EliminaGon-based stack n Discussion & conclusions 65 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  28. Set interface q Unordered collecGon of items q No duplicates q Methods – add(x) put x in set – remove(x) take x out of set – contains(x) tests if x in set 66 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  29. List-based sets public interface Set<T> { public interface Set<T> { public public boolean boolean add(T x); add(T x); public public boolean boolean remove(T x); remove(T x); public public boolean boolean contains(T x); contains(T x); } } Add item to set 67 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  30. List-based sets public interface Set<T> { public interface Set<T> { public public boolean boolean add(T x); add(T x); public public boolean boolean remove(T x); remove(T x); public public boolean boolean contains(Tt x); contains(Tt x); } } Remove item from set 68 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  31. List-based sets public interface Set<T> { public interface Set<T> { public public boolean boolean add(T x); add(T x); public boolean public boolean remove(T x); remove(T x); public public boolean boolean contains(T x); contains(T x); } } Is item in set? 69 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  32. List Node public class public class Node { Node { public public T item; T item; public public int int key; key; public public Node next; Node next; } } 70 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  33. List Node public class Node { public class Node { public public T item; T item; public int key; public int key; public Node next; public Node next; } } item of interest 71 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  34. List Node public class Node { public class Node { public T item; public T item; public public int int key; key; public Node next; public Node next; } } Usually hash code 72 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  35. List Node public class Node { public class Node { public T item; public T item; public int key; public int key; public public Node next; Node next; } } Reference to next node 73 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  36. The List-Based Set - ∞ a b c + ∞ Sorted with Sentinel nodes (min & max possible keys) 74 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  37. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d Danny Hendler, SPTCC summer school, 75 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  38. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 76 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  39. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 77 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  40. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 78 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  41. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 79 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  42. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 80 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  43. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 81 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  44. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 82 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  45. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 83 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  46. The List-Based Set Why synchronization is required q Scan list from leP to right, apply operaGon `at the right place’ q Not so simple… a b c d remove(c) remove(c) SUCCESS X SUCCESS Danny Hendler, SPTCC summer school, 84 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  47. The List-Based Set Use compare-and-swap (CAS)! a b c d remove(c) remove(c) Danny Hendler, SPTCC summer school, 85 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  48. The List-Based Set Use compare-and-swap (CAS)! a b c d CAS remove(c) remove(c) Danny Hendler, SPTCC summer school, 86 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  49. The List-Based Set Use compare-and-swap (CAS)! CAS a b c d CAS remove(c) remove(c) Danny Hendler, SPTCC summer school, 87 Saint-Petersburg, 2017 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  50. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d 88 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  51. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d remove(c) remove(b) 89 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  52. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d remove(c) remove(b) 90 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  53. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d remove(c) remove(b) 91 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  54. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d remove(c) remove(b) 92 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  55. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d remove(c) remove(b) 93 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  56. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d remove(c) remove(b) 94 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  57. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d remove(c) remove(b) 95 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  58. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a b c d remove(c) remove(b) 96 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  59. The List-Based Set Why synchronization is required (2) q Apply operaGon `at the right place’ using CAS q Not so simple… a X c d remove(c) remove(b) 97 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  60. The List-Based Set Logical remove, then physical remove q Scan list from leP to right q Apply modificaGons using CAS q Separate removal to two steps – Logical removal: mark node to be deleted – Physical removal: change predecessor's next reference 98 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  61. The List-Based Set Logical remove, then physical remove a a d b c 99 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

  62. The List-Based Set Logical remove, then physical remove a a d b c Present in list 100 Danny Hendler, SPTCC summer school, Saint-Petersburg, 2017

Recommend

Lock-Free, Wait-Free and Multi-core Programming Roger Deran boilerbay.com Fast, Efficient

Lock-Free, Wait-Free and Multi-core Programming Roger Deran boilerbay.com Fast, Efficient

Lock-Free, Wait-Free and Multi-core Programming Roger Deran boilerbay.com Fast, Efficient Concurrent Maps AirMap Lock-Free and Wait-Free Data Structures Overview The Java Maps that use Lock-Free techniques Graphical performance

538 views • 31 slides
Lock-Free Search Data Structures: Throughput Modeling with Poisson Processes Aras Atalar, Paul

Lock-Free Search Data Structures: Throughput Modeling with Poisson Processes Aras Atalar, Paul

Lock-Free Search Data Structures: Throughput Modeling with Poisson Processes Aras Atalar, Paul Renaud-Goud, Philippas Tsigs Chalmers University of Technology qwwe Concurrent Data Structures Pp Pp Concurrency: Concurrency is the

606 views • 22 slides
Composable lock-free programming for Multicore OCaml KC Sivaramakrishnan University of OCaml

Composable lock-free programming for Multicore OCaml KC Sivaramakrishnan University of OCaml

Composable lock-free programming for Multicore OCaml KC Sivaramakrishnan University of OCaml Cambridge Labs JVM: java.util.concurrent .Net: System.Concurrent.Collections Synchronization Data structures Reentrant locks Queues Not

263 views • 23 slides
Easy Lock-Free Programming in Non-Volatile Memory Tia ianzheng Wang Justin Levandoski

Easy Lock-Free Programming in Non-Volatile Memory Tia ianzheng Wang Justin Levandoski

Easy Lock-Free Programming in Non-Volatile Memory Tia ianzheng Wang Justin Levandoski Paul Larson The making of concurrent data structures With locks: one thread at a time Lock-free: use atomic instructions directly

249 views • 20 slides
Analyzing the Performance of Lock-Free Data Structures: A Conflict-based Model Aras Atalar, Paul

Analyzing the Performance of Lock-Free Data Structures: A Conflict-based Model Aras Atalar, Paul

Analyzing the Performance of Lock-Free Data Structures: A Conflict-based Model Aras Atalar, Paul Renaud-Goud and Philippas Tsigas Chalmers University of Technology qwwe Motivation Pp Pp Lock-free Data Structures: Literature and

606 views • 25 slides
Thread-Modular Reasoning for Lock-Free Data Structures Roland Meyer based on joint work with

Thread-Modular Reasoning for Lock-Free Data Structures Roland Meyer based on joint work with

Thread-Modular Reasoning for Lock-Free Data Structures Roland Meyer based on joint work with Luk Holk, Tom Vojnar, and Sebastian Wol ff . Lock-Free Data Structures Key Take Aways: e ffi cient but complex correctness =

641 views • 53 slides
Decoupling Lock-Free Data Structures from Memory Reclamation for Static Analysis [POPL'19]

Decoupling Lock-Free Data Structures from Memory Reclamation for Static Analysis [POPL'19]

Decoupling Lock-Free Data Structures from Memory Reclamation for Static Analysis [POPL'19] Roland Meyer and Sebastian Wol ff TU Braunschweig, Germany Lock-free Queue (Michael&amp;Scott) void dequeue() { Head a while (true) { head =

838 views • 46 slides
Non-Volatile Memory Tia ianzheng Wang Justin Levandoski Paul Larson The making of

Non-Volatile Memory Tia ianzheng Wang Justin Levandoski Paul Larson The making of

Easy Lock-Free Programming in Non-Volatile Memory Tia ianzheng Wang Justin Levandoski Paul Larson The making of concurrent data structures With locks: one thread at a time Lock-free: use atomic instructions directly

436 views • 20 slides
Concurrent Datatype Verification Verifying lock free data types using CSP and FDR Jonathan

Concurrent Datatype Verification Verifying lock free data types using CSP and FDR Jonathan

Concurrent Datatype Verification 01 Concurrent Datatype Verification Verifying lock free data types using CSP and FDR Jonathan Lawrence jonathan.lawrence@cs.ox.ac.uk Concurrent Datatype Verification 02 Introduction Case study using

618 views • 27 slides
A Persistent Friedman Lock-Free Queue Maurice Herlihy for Non-Volatile Memory Virendra

A Persistent Friedman Lock-Free Queue Maurice Herlihy for Non-Volatile Memory Virendra

1 Michal A Persistent Friedman Lock-Free Queue Maurice Herlihy for Non-Volatile Memory Virendra Marathe Erez Petrank NVMW 19 2 THIS TALK Non-Volatile Concurrent Data Byte-Addressable Structures Memory Platform &amp;

378 views • 25 slides
Fast, less-complicated, lock-free Data Structures Ulrich Drepper ulrich.drepper@gs.com

Fast, less-complicated, lock-free Data Structures Ulrich Drepper ulrich.drepper@gs.com

Fast, less-complicated, lock-free Data Structures Ulrich Drepper ulrich.drepper@gs.com Accelerate Code Not (much) through new hardware Split into independent pieces Splitting comes at a cost Marshaling between stages

699 views • 68 slides
Relaxed Linear References for Lock-free Data Structures Elias Castegren , Tobias Wrigstad

Relaxed Linear References for Lock-free Data Structures Elias Castegren , Tobias Wrigstad

Relaxed Linear References for Lock-free Data Structures Elias Castegren , Tobias Wrigstad ECOOP17, Barcelona sa Structured Aliasing http://www.kristianstadik.se/www/wordpress/wp-content/uploads/2016/06/midsommar.jpg

1.12k views • 67 slides
From Lock-Free to Wait-Free: Linked List Edward Duong Outline 1) Outline operations of the

From Lock-Free to Wait-Free: Linked List Edward Duong Outline 1) Outline operations of the

From Lock-Free to Wait-Free: Linked List Edward Duong Outline 1) Outline operations of the locality conscious linked list [Braginsky 2012] 2) Transformation concept from lock-free -&gt; wait-free [Timnat 2014] Why Build Concurrent ADTs

513 views • 37 slides
LOCK/WAIT FREE SYNCHRONIZATION Synchronization Mutex Blocking Lock-free At

LOCK/WAIT FREE SYNCHRONIZATION Synchronization Mutex Blocking Lock-free At

LOCK/WAIT FREE SYNCHRONIZATION Synchronization Mutex Blocking Lock-free At least one operation in a set of concurrent operations finishes in a finite number of its processors own steps finishes in a finite number of its

492 views • 23 slides
Lock-free Concurrent Level Hashing for Persistent Memory Zhangyu Chen , Yu Hua, Bo Ding, Pengfei

Lock-free Concurrent Level Hashing for Persistent Memory Zhangyu Chen , Yu Hua, Bo Ding, Pengfei

Lock-free Concurrent Level Hashing for Persistent Memory Zhangyu Chen , Yu Hua, Bo Ding, Pengfei Zuo Huazhong University of Science and Technology USENIX ATC 2020 Persistent Memory (PM) PM features Non-volatility Byte-addressability

1.63k views • 117 slides
A Persistent Lock- Free Queue for Maurice Herlihy Non-Volatile Virendra Memory (PPoPP18)

A Persistent Lock- Free Queue for Maurice Herlihy Non-Volatile Virendra Memory (PPoPP18)

Highlight Paper: 1 Michal Friedman A Persistent Lock- Free Queue for Maurice Herlihy Non-Volatile Virendra Memory (PPoPP18) Marathe Erez Petrank SYSTOR 19 2 THIS TALK Non-Volatile Concurrent Data Byte-Addressable

709 views • 25 slides
Black-box Concurrent Data Structures for NUMA Architectures Irina Calciu (VRG) Siddhartha Sen

Black-box Concurrent Data Structures for NUMA Architectures Irina Calciu (VRG) Siddhartha Sen

Black-box Concurrent Data Structures for NUMA Architectures Irina Calciu (VRG) Siddhartha Sen (MSR) Mahesh Balakrishnan (Yale) Marcos K. Aguilera (VRG) Concurrent Data Structures (CDS) Used everywhere: kernel, libraries, applications Issues:

357 views • 20 slides
Automatic Atomicity Verification for Clients of Concurrent Data Structures Mohsen Lesani Todd

Automatic Atomicity Verification for Clients of Concurrent Data Structures Mohsen Lesani Todd

Automatic Atomicity Verification for Clients of Concurrent Data Structures Mohsen Lesani Todd Millstein Jens Palsberg Concurrent Data Structures class ConcurrentHashmap&lt;K, V&gt; { // data structure V get(K k) { ... } void put(K k, V v)

512 views • 36 slides
RCU Usage in Linux History of Concurrency in Linux Multiprocessor support 15 years ago - via

RCU Usage in Linux History of Concurrency in Linux Multiprocessor support 15 years ago - via

CS510 Concurrent Systems Jonathan Walpole RCU Usage in Linux History of Concurrency in Linux Multiprocessor support 15 years ago - via non-preemption in kernel mode Today's Linux - fine-grain locking - lock-free data structures - per-CPU

600 views • 36 slides
Transactional Memory: Architectural support for Lock-Free Data Structure Transactional Memory:

Transactional Memory: Architectural support for Lock-Free Data Structure Transactional Memory:

Transactional Memory: Architectural support for Lock-Free Data Structure Transactional Memory: Architectural Support for Lock-Free Data By Maurice Herlihy and J. Eliot B. Moss Structures 1993 By Maurice Herlihy and J Eliot B. Moss 1993

499 views • 19 slides
Efficient and Reliable Lock-Free Memory Introduction The Problem Reclamation

Efficient and Reliable Lock-Free Memory Introduction The Problem Reclamation

Outline Efficient and Reliable Lock-Free Memory Introduction The Problem Reclamation Lock-free synchronization Based on Reference Counting Our solution Anders Gidenstam, Marina Papatriantafilou, Idea Hkan Sundell and

81 views • 6 slides
A Scalable, Portable, and Memory-Effjcient Lock-Free FIFO Queue Ruslan Nikolaev Systems

A Scalable, Portable, and Memory-Effjcient Lock-Free FIFO Queue Ruslan Nikolaev Systems

A Scalable, Portable, and Memory-Effjcient Lock-Free FIFO Queue Ruslan Nikolaev Systems Software Research Group Virginia Tech, USA Motivation Effjcient concurrent FIFO queues are hard Elimination techniques and relaxed FIFO queues are

178 views • 17 slides
NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 21 November 2014 Lecture 7

NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 21 November 2014 Lecture 7

NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 21 November 2014 Lecture 7 Linearizability Lock-free progress properties Queues Reducing contention Explicit memory management Linearizability 3

1.07k views • 93 slides
NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 18 November 2016 Lecture 7

NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 18 November 2016 Lecture 7

NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 18 November 2016 Lecture 7 Linearizability Lock-free progress properties Queues Reducing contention Explicit memory management Linearizability 3

1.17k views • 88 slides

More recommend