Linked Lists: Locking vs. Lock-Free. Concurrent Algorithms 2013 Programming Assignment

Transcription

1 Linked Lists: Locking vs. Lock-Free Concurrent Algorithms 2013 Programming Assignment

2 Linked list Data structure with group of nodes - representing a sequence Operations - add() - remove() - contains() a c d 2

3 Task Implement 2 versions of a linked list - lock-based - lock-free The algorithms are given - design is tough - implementation can also be tricky 3

4 Deliverables An archive with your code A short report Deadline (strict) - Monday, December 16th, 23:59 4

5 Skeleton Code in C Benchmarking code: do NOT change it Scripts - test correctness - execute experiments - print graphs See README (or ca_prog_assignment.pdf) If C is a problem, contact the TAs 5

6 Programmer s Toolbox Registers: Shared memory locations Atomic Operations: Fetch-and-Add Test-and-Set Compare-and-Swap Provided in atomic_ops.h Use them to build concurrent objects 6

7 Atomic Operations in Practice Example: CAS based lock: void lock(lock_t* lock) { while (CAS(lock,0,1)==1) {} } void unlock(lock_t* lock) { *lock = 0; } 7

8 Linked Lists: Locking vs. Lock-Free Original slides by Maurice Herlihy & Nir Shavit

9 Outline Lock-free linked list Lock-based linked list 9

10 Linked List Using a list-based Set Common application Building block for other apps 10

11 Set Interface Unordered collection of items No duplicates Methods add(x) put x in set remove(x) take x out of set contains(x) tests if x in set 11

12 List Node public class Node { public T item; public int key; public Node next; } 12

13 The List-Based Set - a b c + Sorted with Sentinel nodes (min & max possible keys) 13

14 Reminder: Lock-Free Data Structures No matter what Some thread will complete method call Even if others halt at malicious times Weaker than wait-free, yet Implies that You can t use locks (why?) Um, that s why they call it lock-free 14

15 Why lock-free? Any concurrent data structure based on mutual exclusion has a weakness If one thread Enters critical section And eats the big muffin Cache miss, page fault, descheduled Software error, Everyone else using that lock is stuck! 15

16 Lock-free Lists Eliminate locking entirely contains() wait-free and add() and remove() lock-free Use only compareandswap() 16

17 Problem Bad news a b c d remov e b remov e c 17

18 Problem Method updates node s next field After node has been removed 18

19 Solution Use 1 bit to signify removal Atomically - Swing reference and - Update flag Remove in two steps - Set mark bit in next field - Redirect predecessor s pointer 19

20 Logical vs. Physical Deletion Logical delete Marks current node as removed Physical delete Redirects predecessor s next 20

21 Removing a Node a b CAS c d remov e c 21

22 Removing a Node failed a CAS b CAS c d remov e b remov e c 22

23 Removing a Node a b c d remov e b remov e c 23

24 Removing a Node a d remov e b remov e c 24

25 Traversing the List Q: what do you do when you find a logically deleted node in your path? A: finish the job. CAS the predecessor s next field Proceed (repeat as needed) 25

26 Lock-Free Traversal CAS a b c d Uh-oh 26

27 Summary: Lock-free Removal Logical Removal = Set Mark Bit a 0 b 0 c 10 e 0 Use CAS to verify pointer is correct Not enough! Physical Removal CAS pointer 27

28 Lock-free Removal Logical Removal = Set Mark Bit a 0 b 0 c 10 e 0 Problem: d not added to list Must Prevent manipulation of removed node s pointer Physical Removal CAS d 0 Node added Before Physical Removal CAS 28

29 Our Solution: Combine Bit and Pointer Logical Removal = Set Mark Bit a 0 b 0 c 10 e 0 Mark-Bit and Pointer are CASed together Physical Removal CAS d 0 Fail CAS: Node not added after logical Removal 29

30 A Lock-free Algorithm a 0 b 0 c 10 e 0 1. add() and remove() physically remove marked nodes 2. Wait-free find() traverses both marked and removed nodes 30

31 Outline Lock-free linked list Lock-based linked list 31

32 Locks Used to ensure mutual exclusion in critical sections 2 methods: acquire() release() Many algorithms to implement locks 32

33 What about lock-based algorithms? Generally easier to design In many cases simpler code May be faster? However Deadlocks etc. 33

34 Coarse Grained Locking a b d 34

35 Coarse Grained Locking a b d c 35

36 Coarse Grained Locking a b d honk! honk! c Simple but hotspot + bottleneck 36

37 Coarse-Grained Locking Easy, same as synchronized methods Simple, clearly correct Deserves respect! Works poorly with contention Queue locks help But bottleneck still an issue 37

38 Fine-grained Locking Requires careful thought Split object into pieces Each piece has own lock Methods that work on disjoint pieces need not exclude each other 38

39 Hand-over-Hand locking a b c 39

40 Hand-over-Hand locking a b c 40

41 Hand-over-Hand locking a b c 41

42 Hand-over-Hand locking a b c 42

43 Hand-over-Hand locking a b c 43

44 Removing a Node a b c d remove(b) 44

45 Removing a Node a b c d remove(b) 45

46 Removing a Node a b c d remove(b) 46

47 Removing a Node a b c d remove(b) 47

48 Removing a Node a c d remove(b) 48

49 Removing a Node a b c d remove(b) remove(c) 49

50 Removing a Node a b c d remove(b) remove(c) 50

51 Removing a Node a b c d remove(b) remove(c) 51

52 Removing a Node a b c d remove(b) remove(c) 52

53 Removing a Node a b c d remove(b) remove(c) 53

54 Removing a Node a b c d remove(b) remove(c) 54

55 Removing a Node a b c d remove(b) remove(c) 55

56 Removing a Node a b c d remove(b) remove(c) 56

57 Uh, Oh a c d remove(b) remove(c) 57

58 Uh, Oh Bad news a c d remove(b) remove(c) 58

59 Problem To delete node b Swing node a s next field to c Problem is, a b Someone could delete c concurrently c a b c 59

60 Insight If a node is locked No one can delete node s successor If a thread locks Node to be deleted And its predecessor Then it works 60

61 Hand-Over-Hand Again a b c d remove(b) 61

62 Hand-Over-Hand Again a b c d remove(b) 62

63 Hand-Over-Hand Again a b c d remove(b) 63

64 Hand-Over-Hand Again a b c d remove(b) Found it! 64

65 Hand-Over-Hand Again a b c d remove(b) Found it! 65

66 Hand-Over-Hand Again a c d remove(b) 66

67 Removing a Node a b c d remove(b) remove(c) 67

68 Removing a Node a b c d remove(b) remove(c) 68

69 Removing a Node a b c d remove(b) remove(c) 69

70 Removing a Node a b c d remove(b) remove(c) 70

71 Removing a Node a b c d remove(b) remove(c) 71

72 Removing a Node a b c d remove(b) remove(c) 72

73 Removing a Node a b c d remove(b) remove(c) 73

74 Removing a Node a b c d remove(b) remove(c) 74

75 Removing a Node a b c d remove(b) remove(c) 75

76 Removing a Node a b c d remove(b) remove(c) 76

77 Removing a Node a b d remove(b) 77

78 Removing a Node a b d remove(b) 78

79 Removing a Node a b d remove(b) 79

80 Removing a Node a d remove(b) remove(c) 80

81 Removing a Node a d 81

82 Adding Nodes To add node e Must lock predecessor Must lock successor Neither can be deleted (Is successor lock actually required?) 82

83 Drawbacks Better than coarse-grained lock Threads can traverse in parallel Still not ideal Long chain of acquire/release Inefficient 83

84 To Lock or Not to Lock Locking vs. Non-blocking: Extremist views on both sides Programming assignment: Locking & non-blocking linked list implementations. 84

85 Grading (bonus) Lock-based: 0.5 points Lock-free: 0.5 points Fastest implementation Lock-based: 0.5 points Lock-free: 0.5 points A student can get only one bonus bonus If needed: 2 nd fastest (lock-based) will get it 85

86 Recap Implement 2 linked list algorithms A lock-based A lock-free Deadline (strict): Monday, December 16 th, 23:59 86