Mutual Exclusion. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit

Transcription

1 Mutual Exclusion Companion slides for The by Maurice Herlihy & Nir Shavit

2 Mutual Exclusion In his 1965 paper E. W. Dijkstra wrote: "Given in this paper is a solution to a problem which, to the knowledge of the author, has been an open question since at least 1962, irrespective of the solvability. [...] Although the setting of the problem might seem somewhat academic at first, the author trusts that anyone familiar with the logical problems that arise in computer coupling will appreciate the significance of the fact that this problem indeed can be solved." 2

3 Absolute, true and mathematical time, of itself and from its own nature, flows equably without relation to anything external. (I. Newton, 1689) Time is, like, Nature s way of making sure that everything doesn t happen all at once. (Anonymous, circa 1968) time Time 3

4 Events An event a 0 of thread A is Instantaneous No simultaneous events (break ties) a 0 time 4

5 A thread A is (formally) a sequence a 0, a 1,... of events Trace model Threads Notation: a 0 è a 1 indicates order a 0 a 1 a 2 time 5

6 Example Thread Events Assign to shared variable Assign to local variable Invoke method Return from method Lots of other things mas nem todos são de fato instantâneos 6

7 Threads are State Machines a 0 Events are transitions a 3 a 2 a 1 estado: variáveis globais pilha: variáveis locais, chamadas... 7

8 States Thread State Program counter Local variables System state Object fields (shared variables) Union of thread states 8

9 Concurrency Thread A time 9

10 Concurrency Thread A time Thread B time 10

11 Interleavings Events of two or more threads Interleaved Not necessarily independent (why?) time 11

12 Intervals An interval A 0 =(a 0,a 1 ) is Time between events a 0 and a 1 a 0 a 1 A 0 time 12

13 Intervals may Overlap b 0 B 0 b 1 a 0 A 0 a 1 time 13

14 Intervals may be Disjoint b 0 B 0 b 1 a 0 A 0 a 1 time 14

15 Precedence Interval A 0 precedes interval B 0 a 0 A 0 a 1 b 0 B 0 b 1 time 15

16 Precedence Notation: A 0 è B 0 Formally, End event of A 0 before start event of B 0 Also called happens before or precedes 16

17 Precedence Ordering Remark: A 0 è B 0 is just like saying 1066 AD è 1492 AD, Middle Ages è Renaissance, Oh wait, what about this week vs this month? 17

18 Precedence Ordering Never true that A è A If A è B then not true that B è A If A è B & B è C then A è C Funny thing: A è B & B è A might both be false! 18

19 Irreflexive: Partial Orders (you may know this already) Never true that A è A Antisymmetric: If A Transitive: è B then not true that B è A If A è B & B è C then A è C 19

20 Total Orders (you may know this already) Also Irreflexive Antisymmetric Transitive Except that for every distinct A, B, Either A è B or B è A 20

21 Locks (Mutual Exclusion) public interface Lock { public void lock(); public void unlock(); 21

22 Using Locks public class Counter { private long value; private Lock lock; public long getandincrement() { lock.lock(); try { int temp = value; value = value + 1; finally { lock.unlock(); return temp; 22

23 Using Locks public class Counter { private long value; private Lock lock; public long getandincrement() { lock.lock(); try { int temp = value; value = value + 1; finally { lock.unlock(); return temp; acquire Lock 23

24 Using Locks public class Counter { private long value; private Lock lock; public long getandincrement() { lock.lock(); try { int temp = value; value = value + 1; finally { lock.unlock(); return temp; Release lock (no matter what) 24

25 Using Locks public class Counter { private long value; private Lock lock; public long getandincrement() { lock.lock(); try { int temp = value; value = value + 1; finally { lock.unlock(); return temp; Critical section 25

26 Two-Thread vs n -Thread Solutions Two-thread solutions first Illustrate most basic ideas Fits on one slide Then n-thread solutions 26

27 Two-Thread Conventions class implements Lock { // thread-local index, 0 or 1 public void lock() { int i = ThreadID.get(); int j = 1 - i; 27

28 Two-Thread Conventions class implements Lock { // thread-local index, 0 or 1 public void lock() { int i = ThreadID.get(); int j = 1 - i; Henceforth: i is current thread, j is other thread 28

29 LockOne class LockOne implements Lock { private boolean[] flag = new boolean[2]; public void lock() { flag[i] = true; while (flag[j]) { 29

30 LockOne class LockOne implements Lock { private boolean[] flag = new boolean[2]; public void lock() { flag[i] = true; while (flag[j]) { Set my flag 30

31 LockOne class LockOne implements Lock { private boolean[] flag = new boolean[2]; public void lock() { flag[i] = true; while (flag[j]) { Set my flag Wait for other flag to go false 31

32 LockOne Satisfies Mutual Exclusion Assume CS j overlaps A CS k B Consider each thread's last (j-th and k-th) read and write in the lock() method before entering Derive a contradiction 32

33 From the Code write A (flag[a]=true) à read A (flag[b]==false) à CS A write B (flag[b]=true) à read B (flag[a]==false) à CS B class LockOne implements Lock { public void lock() { flag[i] = true; while (flag[j]) { 33

34 From the Assumption read A (flag[b]==false) à write B (flag[b]=true) read B (flag[a]==false) à write A (flag[b]=true) 34

35 Combining Assumptions: read A (flag[b]==false) à write B (flag[b]=true) read B (flag[a]==false) à write A (flag[a]=true) From the code write A (flag[a]=true) à read A (flag[b]==false) write B (flag[b]=true) à read B (flag[a]==false) 35

36 Combining Assumptions: read A (flag[b]==false) à write B (flag[b]=true) read B (flag[a]==false) à write A (flag[a]=true) From the code write A (flag[a]=true) à read A (flag[b]==false) write B (flag[b]=true) à read B (flag[a]==false) 36

37 Combining Assumptions: read A (flag[b]==false) à write B (flag[b]=true) read B (flag[a]==false) à write A (flag[a]=true) From the code write A (flag[a]=true) à read A (flag[b]==false) write B (flag[b]=true) à read B (flag[a]==false) 37

38 Combining Assumptions: read A (flag[b]==false) à write B (flag[b]=true) read B (flag[a]==false) à write A (flag[a]=true) From the code write A (flag[a]=true) à read A (flag[b]==false) write B (flag[b]=true) à read B (flag[a]==false) 38

39 Combining Assumptions: read A (flag[b]==false) à write B (flag[b]=true) read B (flag[a]==false) à write A (flag[a]=true) From the code write A (flag[a]=true) à read A (flag[b]==false) write B (flag[b]=true) à read B (flag[a]==false) 39

40 Combining Assumptions: read A (flag[b]==false) à write B (flag[b]=true) read B (flag[a]==false) à write A (flag[a]=true) From the code write A (flag[a]=true) à read A (flag[b]==false) write B (flag[b]=true) à read B (flag[a]==false) 40

41 Cycle! 41

42 Deadlock Freedom LockOne Fails deadlock-freedom Concurrent execution can deadlock flag[i] = true; flag[j] = true; while (flag[j]){ while (flag[i]){ Sequential executions OK 42

43 LockTwo public class LockTwo implements Lock { private int victim; public void lock() { victim = i; while (victim == i) {; public void unlock() { 43

44 LockTwo public class LockTwo implements Lock { private int victim; public void lock() { victim = i; while (victim == i) {; public void unlock() { Let other go first 44

45 LockTwo public class LockTwo implements Lock { private int victim; public void lock() { victim = i; while (victim == i) {; public void unlock() { Wait for permission 45

46 LockTwo public class Lock2 implements Lock { private int victim; public void lock() { victim = i; while (victim == i) {; public void unlock() { Nothing to do 46

47 LockTwo Claims Satisfies mutual exclusion If thread i in CS Then victim == j Cannot be both 0 and 1 Not deadlock free Sequential execution deadlocks Concurrent execution does not public void LockTwo() { victim = i; while (victim == i) {; 47

48 Peterson s Algorithm public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {; public void unlock() { flag[i] = false; 48

49 Peterson s Algorithm Announce I m interested public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {; public void unlock() { flag[i] = false; 49

50 Peterson s Algorithm Announce I m interested public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {; public void unlock() { flag[i] = false; Defer to other 50

51 Peterson s Algorithm public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {; public void unlock() { flag[i] = false; Announce I m interested Defer to other Wait while other interested & I m the victim 51

52 Peterson s Algorithm public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {; public void unlock() { flag[i] = false; No longer interested Announce I m interested Defer to other Wait while other interested & I m the victim 52

53 Mutual Exclusion public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {; If thread 0 in critical section, flag[0]=true, victim = 1 If thread 1 in critical section, flag[1]=true, victim = 0 Cannot both be true 53

54 do código: write A (flag[a]=true) à write A (victim=a) à read A (flag[b]) à read A (victim) à CS A write B (flag[b]=true) à write B (victim=b) à read B (flag[a]) à read B (victim) à CS B vamos assumir: write B (victim=b) à write A (victim=a) como A entrou na RC: write A (victim=a) à read A (flag[b] == false) mas então write B (flag[b]=true) à write B (victim=b) à write A (victim=a) à read A (flag[b] == false) 54

55 Deadlock Free public void lock() { while (flag[j] && victim == i) {; Thread blocked only at while loop only if it is the victim One or the other must not be the victim 55

56 Starvation Free Thread i blocked only if j repeatedly re-enters so that flag[j] == true and victim == i When j re-enters it sets victim to j. So i gets in public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {; public void unlock() { flag[i] = false; 56

57 The Filter Algorithm for n Threads There are n-1 waiting rooms called levels At each level At least one enters level At least one blocked if many try ncs cs Only one thread makes it through 57

58 Filter class Filter implements Lock { int[] level; // level[i] for thread i int[] victim; // victim[l] for level L public Filter(int n) { level = new int[n]; victim = new int[n]; for (int i = 1; i < n; i++) { level[i] = 0; level Thread 2 at level victim n-1 58 n-1

59 Filter class Filter implements Lock { public void lock(){ for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; while (( k!= i level[k] >= L) && victim[l] == i ); public void unlock() { level[i] = 0; 59

60 Filter class Filter implements Lock { public void lock() { for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; while (( k!= i) level[k] >= L) && victim[l] == i); public void release(int i) { level[i] = 0; One level at a time 60

61 Filter class Filter implements Lock { public void lock() { for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; while (( k!= i) level[k] >= L) && victim[l] == i); // busy wait public void release(int i) { level[i] = 0; Announce intention to enter level L 61

62 Filter class Filter implements Lock { int level[n]; int victim[n]; public void lock() { for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; while (( k!= i) level[k] >= L) && victim[l] == i); public void release(int i) { level[i] = 0; Give priority to anyone but me 62

63 Filter class Filter implements Lock { int level[n]; int victim[n]; public void lock() { for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; Wait as long as someone else is at same or higher level, and I m designated victim while (( k!= i) level[k] >= L) && victim[l] == i); public void release(int i) { level[i] = 0; 63

64 Filter class Filter implements Lock { int level[n]; int victim[n]; public void lock() { for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; while (( k!= i) level[k] >= L) && victim[l] == i); public void release(int i) { level[i] = 0; the loop Thread enters level L when it completes 64

65 Claim Start at level L=0 At most n-l threads enter level L Mutual exclusion at level L=n-1 ncs L=0 L=1 L=n-2 cs L=n-1 65

66 Induction Hypothesis No more than n-l+1 at level L-1 Induction step: by contradiction Assume all at level L-1 enter level L A last to write victim[l] B is any other thread at level L ncs cs assume L-1 has n-l+1 L has n-l prove 66

67 Proof Structure Last to write victim[l] A ncs cs B Assumed to enter L-1 n-l+1 = 4 n-l+1 = 4 By way of contradiction all enter L Show that A must have seen B in level[l] and since victim[l] == A could not have entered 67

68 From the Code (1) write B (level[b]=l)è write B (victim[l]=b) public void lock() { for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; while (( k!= i) level[k] >= L) && victim[l] == i) {; 68

69 From the Code (2) write A (victim[l]=a)è read A (level[b]) public void lock() { for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; while (( k!= i) level[k] >= L) && victim[l] == i) {; 69

70 By Assumption (3) write B (victim[l]=b)è write A (victim[l]=a) By assumption, A is the last thread to write victim[l] 70

71 Combining Observations (1) write B (level[b]=l)è write B (victim[l]=b) (3) write B (victim[l]=b)è write A (victim[l]=a) (2) write A (victim[l]=a)è read A (level[b]) 71

72 Combining Observations (1) write B (level[b]=l)è write B (victim[l]=b) (3) write B (victim[l]=b)è write A (victim[l]=a) (2) write A (victim[l]=a)è read A (level[b]) public void lock() { for (int L = 1; L < n; L++) { level[i] = L; victim[l] = i; while (( k!= i) level[k] >= L) && victim[l] == i) {; 72

73 Combining Observations (1) write B (level[b]=l)è write B (victim[l]=b) (3) write B (victim[l]=b)è write A (victim[l]=a) (2) write A (victim[l]=a)è read A (level[b]) Thus, A read level[b] L, A was last to write victim[l], so it could not have entered level L! 73

74 No Starvation Filter Lock satisfies properties: Just like Peterson Alg at any level So no one starves But what about fairness? Threads can be overtaken by others 74

75 Bounded Waiting Want stronger fairness guarantees Thread not overtaken too much Need to adjust definitions. 75

76 Bounded Waiting Divide lock() method into 2 parts: Doorway interval: Written D A always finishes in finite steps Waiting interval: Written W A may take unbounded steps 76

77 r-bounded Waiting For threads A and B: If D A k è D B j A s k-th doorway precedes B s j-th doorway Then CS A k è CS B j+r A s k-th critical section precedes B s (j+r)- th critical section B cannot overtake A by more than r times First-come-first-served means r = 0. 77

78 Fairness Again Filter Lock satisfies properties: No one starves But very weak fairness Not r-bounded for any r! That s pretty lame 78

79 Bakery Algorithm Provides First-Come-First-Served How? Take a number Wait until lower numbers have been served Lexicographic order (a,i) > (b,j) If a > b, or a = b and i > j 79

80 Bakery Algorithm class Bakery implements Lock { boolean[] flag; Label[] label; public Bakery (int n) { flag = new boolean[n]; label = new Label[n]; for (int i = 0; i < n; i++) { flag[i] = false; label[i] = 0; 80

81 Bakery Algorithm class Bakery implements Lock { boolean[] flag; Label[] label; public Bakery (int n) { flag = new boolean[n]; label = new Label[n]; for (int i = 0; i < n; i++) { flag[i] = false; label[i] = 0; 0 2 f f t f f t f f CS 6 n-1 81

82 Bakery Algorithm class Bakery implements Lock { public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); 82

83 Bakery Algorithm class Bakery implements Lock { Doorway public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); 83

84 Bakery Algorithm class Bakery implements Lock { public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; I m interested while ( k flag[k] && (label[i],i) > (label[k],k)); 84

85 Bakery Algorithm Take increasing label (read labels in some arbitrary order) class Bakery implements Lock { public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); 85

86 Bakery Algorithm Someone is interested class Bakery implements Lock { public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); 86

87 Bakery Algorithm class Bakery implements Lock { boolean flag[n]; int label[n]; Someone is interested public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); With lower (label,i) in lexicographic order 87

88 Bakery Algorithm class Bakery implements Lock { public void unlock() { flag[i] = false; 88

89 Bakery Algorithm class Bakery implements Lock { No longer interested public void unlock() { flag[i] = false; labels are always increasing 89

90 No Deadlock There is always one thread with earliest label Ties are impossible (why?) 90

91 First-Come-First-Served If D A è D B then A s label is smaller And: write A (label[a]) è read B (label[a]) è write B (label[b]) è read B (flag[a]) So B is locked out while flag[a] is true class Bakery implements Lock { public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); 91

92 Mutual Exclusion Suppose A and B in CS together Suppose A has earlier label When B entered, it must have seen flag[a] is false, or label[a] > label[b] class Bakery implements Lock { public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); 92

93 Mutual Exclusion Labels are strictly increasing so B must have seen flag[a] == false 93

94 Mutual Exclusion Labels are strictly increasing so B must have seen flag[a] == false Labeling B è read B (flag[a]) è write A (flag[a]) è Labeling A 94

95 Mutual Exclusion Labels are strictly increasing so B must have seen flag[a] == false Labeling B è read B (flag[a]) è write A (flag[a]) è Labeling A Which contradicts the assumption that A has an earlier label 95

96 Bakery Y2 32 K Bug class Bakery implements Lock { public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); 96

97 Bakery Y2 32 K Bug Mutex breaks if label[i] overflows class Bakery implements Lock { public void lock() { flag[i] = true; label[i] = max(label[0],,label[n-1])+1; while ( k flag[k] && (label[i],i) > (label[k],k)); 97

98 Does Overflow Actually Matter? Yes Y2K 18 January 2038 (Unix time_t rollover) 16-bit counters No 64-bit counters Maybe 32-bit counters 98

99 palavras de cautela esses algoritmos assumem coisas que achamos intuitivas instruções em uma thread serão executadas na ordem em que as enxergamos... mas compilador pode pensar diferente... 99