![Page 1: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/1.jpg)
Mutual Exclusion
Companion slides forThe Art of Multiprocessor Programming
by Maurice Herlihy & Nir Shavit
![Page 2: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/2.jpg)
Art of Multiprocessor Programming
2
Mutual Exclusion
• We will clarify our understanding of mutual exclusion
• We will also show you how to reason about various properties in an asynchronous concurrent setting
![Page 3: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/3.jpg)
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."
Art of Multiprocessor Programming
3
![Page 4: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/4.jpg)
Art of Multiprocessor Programming
4
Mutual Exclusion
• Formal problem definitions• Solutions for 2 threads• Solutions for n threads• Fair solutions• Inherent costs
![Page 5: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/5.jpg)
Art of Multiprocessor Programming
5
Warning
• You will never use these protocols– Get over it
• You are advised to understand them– The same issues show up everywhere– Except hidden and more complex
![Page 6: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/6.jpg)
Art of Multiprocessor Programming
6
Why is Concurrent Programming so Hard?
• Try preparing a seven-course banquet– By yourself– With one friend– With twenty-seven friends …
• Before we can talk about programs– Need a language– Describing time and concurrency
![Page 7: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/7.jpg)
Art of Multiprocessor Programming
7
• “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
![Page 8: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/8.jpg)
Art of Multiprocessor Programming
8
time
• An event a0 of thread A is
– Instantaneous– No simultaneous events (break ties)
a0
Events
![Page 9: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/9.jpg)
Art of Multiprocessor Programming
9
time
• A thread A is (formally) a sequence a0, a1, ... of events
– “Trace” model
– Notation: a0 a1 indicates order
a0
Threads
a1 a2 …
![Page 10: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/10.jpg)
Art of Multiprocessor Programming
10
• Assign to shared variable
• Assign to local variable
• Invoke method
• Return from method
• Lots of other things …
Example Thread Events
![Page 11: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/11.jpg)
Art of Multiprocessor Programming
11
Threads are State Machines
Events are transitions
a0
a1a2
a3
![Page 12: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/12.jpg)
Art of Multiprocessor Programming
12
States
• Thread State– Program counter– Local variables
• System state– Object fields (shared variables)– Union of thread states
![Page 13: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/13.jpg)
Art of Multiprocessor Programming
13
time
• Thread A
Concurrency
![Page 14: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/14.jpg)
Art of Multiprocessor Programming
14
time
time
• Thread A
• Thread B
Concurrency
![Page 15: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/15.jpg)
Art of Multiprocessor Programming
15
time
Interleavings
• Events of two or more threads– Interleaved– Not necessarily independent (why?)
![Page 16: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/16.jpg)
Art of Multiprocessor Programming
16
time
• An interval A0 =(a0,a1) is
– Time between events a0 and a1
a0 a1
Intervals
A0
![Page 17: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/17.jpg)
Art of Multiprocessor Programming
17
time
Intervals may Overlap
a0 a1A0
b0 b1B0
![Page 18: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/18.jpg)
Art of Multiprocessor Programming
18
time
Intervals may be Disjoint
a0 a1A0
b0 b1B0
![Page 19: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/19.jpg)
Art of Multiprocessor Programming
19
time
Precedence
a0 a1A0
b0 b1B0
Interval A0 precedes interval B0
![Page 20: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/20.jpg)
Art of Multiprocessor Programming
20
Precedence
• Notation: A0 B0
• Formally,– End event of A0 before start event of B0
– Also called “happens before” or “precedes”
![Page 21: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/21.jpg)
Art of Multiprocessor Programming
21
Precedence Ordering
• Remark: A0 B0 is just like saying
– 1066 AD 1492 AD, – Middle Ages Renaissance,
• Oh wait, – what about this week vs this month?
![Page 22: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/22.jpg)
Art of Multiprocessor Programming
22
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!
![Page 23: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/23.jpg)
Art of Multiprocessor Programming
23
Partial Orders(review)
• Irreflexive:– Never true that A A
• Antisymmetric:– If A B then not true that B A
• Transitive:– If A B & B C then A C
![Page 24: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/24.jpg)
Art of Multiprocessor Programming
24
Total Orders(review)
• Also– Irreflexive– Antisymmetric– Transitive
• Except that for every distinct A, B,– Either A B or B A
![Page 25: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/25.jpg)
Art of Multiprocessor Programming
25
Repeated Events
while (mumble) {
a0; a1;}
a0k
k-th occurrence of event a0
A0k
k-th occurrence of interval A0 =(a0,a1)
![Page 26: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/26.jpg)
Art of Multiprocessor Programming
26
Implementing a Counter
public class Counter { private long value;
public long getAndIncrement() { temp = value; value = temp + 1; return temp; }}
Make these steps indivisible using locks
![Page 27: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/27.jpg)
Art of Multiprocessor Programming
27
Locks (Mutual Exclusion)
public interface Lock {
public void lock();
public void unlock();}
![Page 28: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/28.jpg)
Art of Multiprocessor Programming
28
Locks (Mutual Exclusion)
public interface Lock {
public void lock();
public void unlock();}
acquire lock
![Page 29: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/29.jpg)
Art of Multiprocessor Programming
29
Locks (Mutual Exclusion)
public interface Lock {
public void lock();
public void unlock();}
release lock
acquire lock
![Page 30: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/30.jpg)
Art of Multiprocessor Programming
30
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; }}
![Page 31: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/31.jpg)
Art of Multiprocessor Programming
31
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
![Page 32: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/32.jpg)
Art of Multiprocessor Programming
32
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)
![Page 33: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/33.jpg)
Art of Multiprocessor Programming
33
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
![Page 34: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/34.jpg)
Art of Multiprocessor Programming
34
Mutual Exclusion
• Let CSik be thread i’s k-th critical
section execution
![Page 35: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/35.jpg)
Art of Multiprocessor Programming
35
Mutual Exclusion
• Let CSik be thread i’s k-th critical
section execution
• And CSjm be thread j’s m-th critical
section execution
![Page 36: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/36.jpg)
Art of Multiprocessor Programming
36
Mutual Exclusion
• Let CSik be thread i’s k-th critical
section execution
• And CSjm be j’s m-th execution
• Then either– or
![Page 37: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/37.jpg)
Art of Multiprocessor Programming
37
Mutual Exclusion
• Let CSik be thread i’s k-th critical
section execution
• And CSjm be j’s m-th execution
• Then either– or
CSik CSj
m
![Page 38: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/38.jpg)
Art of Multiprocessor Programming
38
Mutual Exclusion
• Let CSik be thread i’s k-th critical
section execution
• And CSjm be j’s m-th execution
• Then either– or
CSik CSj
m
CSjm CSi
k
![Page 39: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/39.jpg)
Art of Multiprocessor Programming
39
Deadlock-Free
• If some thread calls lock()– And never returns– Then other threads must complete lock()
and unlock() calls infinitely often
• System as a whole makes progress– Even if individuals starve
![Page 40: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/40.jpg)
Art of Multiprocessor Programming
40
Starvation-Free
• If some thread calls lock()– It will eventually return
• Individual threads make progress
![Page 41: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/41.jpg)
Art of Multiprocessor Programming
41
Two-Thread vs n-Thread Solutions
• 2-thread solutions first– Illustrate most basic ideas– Fits on one slide
• Then n-thread solutions
![Page 42: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/42.jpg)
Art of Multiprocessor Programming
42
class … implements Lock { … // thread-local index, 0 or 1 public void lock() { int i = ThreadID.get(); int j = 1 - i; … }}
Two-Thread Conventions
![Page 43: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/43.jpg)
Art of Multiprocessor Programming
43
class … implements Lock { … // thread-local index, 0 or 1 public void lock() { int i = ThreadID.get(); int j = 1 - i; … } }
Two-Thread Conventions
Henceforth: i is current thread, j is other thread
![Page 44: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/44.jpg)
LockOneclass LockOne implements Lock {private boolean[] flag = new boolean[2];public void lock() { flag[i] = true; while (flag[j]) {} }
![Page 45: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/45.jpg)
LockOneclass LockOne implements Lock {private boolean[] flag = new boolean[2];public void lock() { flag[i] = true; while (flag[j]) {} } Each thread has flag
![Page 46: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/46.jpg)
LockOneclass LockOne implements Lock {private boolean[] flag = new boolean[2];public void lock() { flag[i] = true; while (flag[j]) {} }
Set my flag
![Page 47: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/47.jpg)
LockOneclass LockOne implements Lock {private boolean[] flag = new boolean[2];public void lock() { flag[i] = true; while (flag[j]) {} }
Wait for other flag to become false
![Page 48: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/48.jpg)
Art of Multiprocessor Programming
48
• Assume CSAj overlaps CSB
k
• Consider each thread's last (j-th and k-th) read and write in the lock() method before entering
• Derive a contradiction
LockOne Satisfies Mutual Exclusion
![Page 49: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/49.jpg)
Art of Multiprocessor Programming
49
• writeA(flag[A]=true) readA(flag[B]==false) CSA
• writeB(flag[B]=true) readB(flag[A]==false) CSB
From the Code
class LockOne implements Lock {… public void lock() { flag[i] = true; while (flag[j]) {} }
![Page 50: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/50.jpg)
Art of Multiprocessor Programming
50
• readA(flag[B]==false) writeB(flag[B]=true)
• readB(flag[A]==false) writeA(flag[A]=true)
From the Assumption
![Page 51: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/51.jpg)
Art of Multiprocessor Programming
51
• Assumptions:– readA(flag[B]==false) writeB(flag[B]=true)
– readB(flag[A]==false) writeA(flag[A]=true)
• From the code– writeA(flag[A]=true) readA(flag[B]==false)
– writeB(flag[B]=true) readB(flag[A]==false)
Combining
![Page 52: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/52.jpg)
Art of Multiprocessor Programming
52
• Assumptions:– readA(flag[B]==false) writeB(flag[B]=true)
– readB(flag[A]==false) writeA(flag[A]=true)
• From the code– writeA(flag[A]=true) readA(flag[B]==false)
– writeB(flag[B]=true) readB(flag[A]==false)
Combining
![Page 53: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/53.jpg)
Art of Multiprocessor Programming
53
• Assumptions:– readA(flag[B]==false) writeB(flag[B]=true)
– readB(flag[A]==false) writeA(flag[A]=true)
• From the code– writeA(flag[A]=true) readA(flag[B]==false)
– writeB(flag[B]=true) readB(flag[A]==false)
Combining
![Page 54: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/54.jpg)
Art of Multiprocessor Programming
54
• Assumptions:– readA(flag[B]==false) writeB(flag[B]=true)
– readB(flag[A]==false) writeA(flag[A]=true)
• From the code– writeA(flag[A]=true) readA(flag[B]==false)
– writeB(flag[B]=true) readB(flag[A]==false)
Combining
![Page 55: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/55.jpg)
Art of Multiprocessor Programming
55
• Assumptions:– readA(flag[B]==false) writeB(flag[B]=true)
– readB(flag[A]==false) writeA(flag[A]=true)
• From the code– writeA(flag[A]=true) readA(flag[B]==false)
– writeB(flag[B]=true) readB(flag[A]==false)
Combining
![Page 56: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/56.jpg)
Art of Multiprocessor Programming
56
• Assumptions:– readA(flag[B]==false) writeB(flag[B]=true)
– readB(flag[A]==false) writeA(flag[A]=true)
• From the code– writeA(flag[A]=true) readA(flag[B]==false)
– writeB(flag[B]=true) readB(flag[A]==false)
Combining
![Page 57: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/57.jpg)
Art of Multiprocessor Programming
57
Cycle!
Impossible in
a
partial o
rder
![Page 58: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/58.jpg)
Art of Multiprocessor Programming
58
Deadlock Freedom
• LockOne Fails deadlock-freedom– Concurrent execution can deadlock
– Sequential executions OK
flag[i] = true; flag[j] = true; while (flag[j]){} while (flag[i]){}
![Page 59: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/59.jpg)
Art of Multiprocessor Programming
59
LockTwopublic class LockTwo implements Lock { private int victim; public void lock() { victim = i; while (victim == i) {}; }
public void unlock() {}}
![Page 60: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/60.jpg)
Art of Multiprocessor Programming
60
LockTwopublic class LockTwo implements Lock { private int victim; public void lock() { victim = i; while (victim == i) {}; }
public void unlock() {}}
Let other go first
![Page 61: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/61.jpg)
Art of Multiprocessor Programming
61
LockTwopublic class LockTwo implements Lock { private int victim; public void lock() { victim = i; while (victim == i) {}; }
public void unlock() {}}
Wait for permission
![Page 62: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/62.jpg)
Art of Multiprocessor Programming
62
LockTwopublic class Lock2 implements Lock { private int victim; public void lock() { victim = i; while (victim == i) {}; }
public void unlock() {}}
Nothing to do
![Page 63: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/63.jpg)
Art of Multiprocessor Programming
63
public void LockTwo() { victim = i; while (victim == i) {}; }
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
![Page 64: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/64.jpg)
Art of Multiprocessor Programming
64
Peterson’s Algorithm
public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {};}public void unlock() { flag[i] = false;}
![Page 65: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/65.jpg)
Art of Multiprocessor Programming
65
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
![Page 66: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/66.jpg)
Art of Multiprocessor Programming
66
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
![Page 67: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/67.jpg)
Art of Multiprocessor Programming
67
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
![Page 68: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/68.jpg)
Art of Multiprocessor Programming
68
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
![Page 69: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/69.jpg)
Art of Multiprocessor Programming
69
Mutual Exclusion
(1) writeB(Flag[B]=true)writeB(victim=B)
public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {};}
From the Code
![Page 70: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/70.jpg)
Art of Multiprocessor Programming
70
Also from the Code
(2) writeA(victim=A)readA(flag[B]) readA(victim)
public void lock() { flag[i] = true; victim = i; while (flag[j] && victim == i) {};}
![Page 71: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/71.jpg)
Art of Multiprocessor Programming
71
Assumption
W.L.O.G. assume A is the last thread to write victim
(3) writeB(victim=B)writeA(victim=A)
![Page 72: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/72.jpg)
Art of Multiprocessor Programming
72
Combining Observations
(1) writeB(flag[B]=true)writeB(victim=B)
(3) writeB(victim=B)writeA(victim=A)
(2) writeA(victim=A)readA(flag[B]) readA(victim)
![Page 73: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/73.jpg)
Art of Multiprocessor Programming
73
Combining Observations
(1) writeB(flag[B]=true)writeB(victim=B)
(3) writeB(victim=B)writeA(victim=A)
(2) writeA(victim=A)readA(flag[B]) readA(victim)
![Page 74: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/74.jpg)
Art of Multiprocessor Programming
74
Combining Observations
(1) writeB(flag[B]=true)writeB(victim=B)
(3) writeB(victim=B)writeA(victim=A)
(2) writeA(victim=A)readA(flag[B]) readA(victim)
A read flag[B] == true and victim == A, so it could not have entered the CS (QED)
![Page 75: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/75.jpg)
Art of Multiprocessor Programming
75
Deadlock Free
• Thread blocked – only at while loop– only if other’s flag is true– only if it is the victim
• Solo: other’s flag is false• Both: one or the other not the victim
public void lock() { … while (flag[j] && victim == i) {};
![Page 76: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/76.jpg)
Art of Multiprocessor Programming
76
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; }
![Page 77: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/77.jpg)
Art of Multiprocessor Programming
77
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
• Only one thread makes it through
ncs
cs
![Page 78: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/78.jpg)
Art of Multiprocessor Programming
78
Filterclass 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
victim
n-1
n-1
0
1
0 0 0 0 0 04
2
2
Thread 2 at level 4
0
4
![Page 79: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/79.jpg)
Art of Multiprocessor Programming
79
Filterclass 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; }}
![Page 80: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/80.jpg)
Art of Multiprocessor Programming
80
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; }}
Filter
One level at a time
![Page 81: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/81.jpg)
Art of Multiprocessor Programming
81
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; }}
Filter
Announce intention to enter
level L
![Page 82: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/82.jpg)
Art of Multiprocessor Programming
82
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; }}
Filter
Give priority to anyone but me
![Page 83: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/83.jpg)
Art of Multiprocessor Programming
83
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; }}
FilterWait as long as someone else is at same or
higher level, and I’m designated victim
![Page 84: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/84.jpg)
Art of Multiprocessor Programming
84
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; }}
Filter
Thread enters level L when it completes the loop
![Page 85: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/85.jpg)
Art of Multiprocessor Programming
85
Claim• Start at level L=0
• At most n-L threads enter level L
• Mutual exclusion at level L=n-1
ncs
cs L=n-1
L=1
L=n-2
L=0
![Page 86: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/86.jpg)
Art of Multiprocessor Programming
86
Induction Hypothesis
• Assume all at level L-1 enter level L
• A last to write victim[L]
• B is any other thread at level L
• No more than n-(L-1) at level L-1 • Induction step: by contradiction
ncs
cs
L-1 has n-(L-1)L has n-L
assume
prove
![Page 87: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/87.jpg)
Art of Multiprocessor Programming
87
Proof Structurencs
cs
Assumed to enter L-1
By way of contradictionall enter L
n-L+1 = 4
n-L+1 = 4
A B
Last to writevictim[L]
Show that A must have seen B in level[L] and since victim[L] == Acould not have entered
![Page 88: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/88.jpg)
Art of Multiprocessor Programming
88
Just Like Peterson
(1) writeB(level[B]=L)writeB(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) {}; }}
From the Code
![Page 89: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/89.jpg)
Art of Multiprocessor Programming
89
From the Code
(2) writeA(victim[L]=A)readA(level[B]) readA(victim[L])
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) {}; }}
![Page 90: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/90.jpg)
Art of Multiprocessor Programming
90
By Assumption
By assumption, A is the last thread to write victim[L]
(3) writeB(victim[L]=B)writeA(victim[L]=A)
![Page 91: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/91.jpg)
Art of Multiprocessor Programming
91
Combining Observations
(1) writeB(level[B]=L)writeB(victim[L]=B)
(3) writeB(victim[L]=B)writeA(victim[L]=A)
(2) writeA(victim[L]=A)readA(level[B]) readA(victim[L])
![Page 92: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/92.jpg)
Art of Multiprocessor Programming
92
Combining Observations
(1) writeB(level[B]=L)writeB(victim[L]=B)
(3) writeB(victim[L]=B)writeA(victim[L]=A)
(2) writeA(victim[L]=A)readA(level[B]) readA(victim[L])
![Page 93: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/93.jpg)
Art of Multiprocessor Programming
93
Combining Observations
(1) writeB(level[B]=L)writeB(victim[L]=B)
(3) writeB(victim[L]=B)writeA(victim[L]=A)
(2) writeA(victim[L]=A)readA(level[B]) readA(victim[L])
A read level[B] ≥ L, and victim[L] = A, so it could not have entered level L!
![Page 94: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/94.jpg)
Art of Multiprocessor Programming
94
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
![Page 95: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/95.jpg)
Art of Multiprocessor Programming
95
Bounded Waiting
• Want stronger fairness guarantees
• Thread not “overtaken” too much
• If A starts before B, then A enters before B?
• But what does “start” mean?
• Need to adjust definitions ….
![Page 96: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/96.jpg)
Art of Multiprocessor Programming
96
Bounded Waiting
• Divide lock() method into 2 parts:– Doorway interval:
• Written DA
• always finishes in finite steps
– Waiting interval:• Written WA
• may take unbounded steps
![Page 97: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/97.jpg)
Art of Multiprocessor Programming
97
• For threads A and B:– If DA
k DB j
• A’s k-th doorway precedes B’s j-th doorway
– Then CSAk CSB
j
• A’s k-th critical section precedes B’s j-th critical section
• B cannot overtake A
First-Come-First-Served
![Page 98: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/98.jpg)
Art of Multiprocessor Programming
98
Fairness Again
• Filter Lock satisfies properties:– No one starves– But very weak fairness
• Can be overtaken arbitrary # of times– That’s pretty lame…
![Page 99: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/99.jpg)
Art of Multiprocessor Programming
99
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
![Page 100: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/100.jpg)
Art of Multiprocessor Programming
100
Bakery Algorithmclass 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;
}
} …
![Page 101: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/101.jpg)
Art of Multiprocessor Programming
101
Bakery Algorithmclass 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;
}
} …
n-10
f f f f t ft
2
f
0 0 0 0 5 04 0
6
CS
![Page 102: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/102.jpg)
Art of Multiprocessor Programming
102
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)); }
![Page 103: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/103.jpg)
Art of Multiprocessor Programming
103
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)); }
Doorway
![Page 104: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/104.jpg)
Art of Multiprocessor Programming
104
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)); }
I’m interested
![Page 105: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/105.jpg)
Art of Multiprocessor Programming
105
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)); }
Take increasing label (read labels in some arbitrary
order)
![Page 106: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/106.jpg)
Art of Multiprocessor Programming
106
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)); }
Someone is interested
![Page 107: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/107.jpg)
Art of Multiprocessor Programming
107
Bakery Algorithmclass Bakery implements Lock { boolean flag[n]; int label[n];
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)); }
Someone is interested …
… whose (label,i) in lexicographic order is lower
![Page 108: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/108.jpg)
Art of Multiprocessor Programming
108
Bakery Algorithm
class Bakery implements Lock { …
public void unlock() { flag[i] = false; }}
![Page 109: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/109.jpg)
Art of Multiprocessor Programming
109
Bakery Algorithm
class Bakery implements Lock { …
public void unlock() { flag[i] = false; }}
No longer interested
labels are always increasing
![Page 110: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/110.jpg)
Art of Multiprocessor Programming
110
No Deadlock
• There is always one thread with earliest label
• Ties are impossible (why?)
![Page 111: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/111.jpg)
Art of Multiprocessor Programming
111
First-Come-First-Served
• If DA DB then– A’s label is smaller
• And:– writeA(label[A])
– readB(label[A])
– writeB(label[B]) readB(flag[A])
• So B sees– smaller label for A – 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));
}
![Page 112: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/112.jpg)
Art of Multiprocessor Programming
112
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));
}
![Page 113: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/113.jpg)
Art of Multiprocessor Programming
113
Mutual Exclusion
• Labels are strictly increasing so
• B must have seen flag[A] == false
![Page 114: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/114.jpg)
Art of Multiprocessor Programming
114
Mutual Exclusion
• Labels are strictly increasing so
• B must have seen flag[A] == false
• LabelingB readB(flag[A]) writeA(flag[A]) LabelingA
![Page 115: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/115.jpg)
Art of Multiprocessor Programming
115
Mutual Exclusion
• Labels are strictly increasing so
• B must have seen flag[A] == false
• LabelingB readB(flag[A]) writeA(flag[A]) LabelingA
• Which contradicts the assumption that A has an earlier label
![Page 116: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/116.jpg)
Art of Multiprocessor Programming
116
Bakery Y232K Bugclass 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)); }
![Page 117: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/117.jpg)
Art of Multiprocessor Programming
117
Bakery Y232K Bugclass 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)); }
Mutex breaks if label[i] overflows
![Page 118: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/118.jpg)
Art of Multiprocessor Programming
118
Does Overflow Actually Matter?
• Yes– Y2K– 18 January 2038 (Unix time_t rollover)– 16-bit counters
• No– 64-bit counters
• Maybe– 32-bit counters
![Page 119: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/119.jpg)
Art of Multiprocessor Programming
119
Timestamps
• Label variable is really a timestamp
• Need ability to– Read others’ timestamps– Compare them– Generate a later timestamp
• Can we do this without overflow?
![Page 120: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/120.jpg)
Art of Multiprocessor Programming
120
• One can construct a– Wait-free (no mutual exclusion)– Concurrent– Timestamping system– That never overflows
The Good News
![Page 121: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/121.jpg)
Art of Multiprocessor Programming
121
• One can construct a– Wait-free (no mutual exclusion)– Concurrent– Timestamping system– That never overflows
The Good News
This part is hard
Bad
![Page 122: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/122.jpg)
Art of Multiprocessor Programming
122
Instead …
• We construct a Sequential timestamping system– Same basic idea– But simpler
• As if we use mutex to read & write atomically
• No good for building locks– But useful anyway
![Page 123: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/123.jpg)
Art of Multiprocessor Programming
123
Precedence Graphs
0 1 2 3
• Timestamps form directed graph
• Edge x to y– Means x is later timestamp– We say x dominates y
![Page 124: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/124.jpg)
Art of Multiprocessor Programming
124
Unbounded Counter Precedence Graph
0 1 2 3
• Timestamping = move tokens on graph• Atomically
– read others’ tokens – move mine
• Ignore tie-breaking for now
![Page 125: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/125.jpg)
Art of Multiprocessor Programming
125
Unbounded Counter Precedence Graph
0 1 2 3
![Page 126: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/126.jpg)
Art of Multiprocessor Programming
126
Unbounded Counter Precedence Graph
0 1 2 3
takes 0 takes 1 takes 2
![Page 127: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/127.jpg)
Art of Multiprocessor Programming
127
Two-Thread Bounded Precedence Graph
0
12
![Page 128: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/128.jpg)
Art of Multiprocessor Programming
128
Two-Thread Bounded Precedence Graph
0
12
![Page 129: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/129.jpg)
Art of Multiprocessor Programming
129
Two-Thread Bounded Precedence Graph
0
12
![Page 130: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/130.jpg)
Art of Multiprocessor Programming
130
Two-Thread Bounded Precedence Graph
0
12
![Page 131: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/131.jpg)
Art of Multiprocessor Programming
131
Two-Thread Bounded Precedence Graph T2
0
12
and so on …
![Page 132: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/132.jpg)
Art of Multiprocessor Programming
132
Three-Thread Bounded Precedence Graph?
12
03
![Page 133: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/133.jpg)
Art of Multiprocessor Programming
133
Three-Thread Bounded Precedence Graph?
12
03
What to do if one thread gets stuck?
![Page 134: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/134.jpg)
Art of Multiprocessor Programming
134
Graph Composition
0
12
0
12
Replace each vertex with a copy of the graph
T3=T2*T2
![Page 135: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/135.jpg)
Art of Multiprocessor Programming
135
Three-Thread Bounded Precedence Graph T3
20
1210
12
00
12
![Page 136: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/136.jpg)
Art of Multiprocessor Programming
136
Three-Thread Bounded Precedence Graph T3
20
1210
12
00
12
20 02 12<<
![Page 137: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/137.jpg)
Art of Multiprocessor Programming
137
Three-Thread Bounded Precedence Graph T3
20
1210
12
00
12
and so on…
![Page 138: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/138.jpg)
Art of Multiprocessor Programming
138
In General
Tk = T2 * Tk-1
K threads need 3k
nodes
label size = Log2(3k) = 2k
![Page 139: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/139.jpg)
Art of Multiprocessor Programming
139
Deep Philosophical Question
• The Bakery Algorithm is– Succinct,– Elegant, and– Fair.
• Q: So why isn’t it practical?
• A: Well, you have to read N distinct variables
![Page 140: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/140.jpg)
Art of Multiprocessor Programming
140
Shared Memory
• Shared read/write memory locations called Registers (historical reasons)
• Come in different flavors– Multi-Reader-Single-Writer (Flag[])– Multi-Reader-Multi-Writer (Victim[])– Not that interesting: SRMW and SRSW
![Page 141: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/141.jpg)
Art of Multiprocessor Programming
141
Theorem
At least N MRSW (multi-reader/single-writer) registers are needed to solve deadlock-free mutual exclusion.
N registers like Flag[]…
![Page 142: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/142.jpg)
Art of Multiprocessor Programming
142
Proving Algorithmic Impossibility
CS
write
C
•To show no algorithm exists:• assume by way of contradiction one does, • show a bad execution that violates properties: • in our case assume an alg for deadlock free mutual exclusion using < N registers
![Page 143: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/143.jpg)
Art of Multiprocessor Programming
143
Proof: Need N-MRSW Registers
Each thread must write to some register
…can’t tell whether A is in critical section
write
CS CS CS
write
A B C
![Page 144: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/144.jpg)
Art of Multiprocessor Programming
144
Upper Bound
• Bakery algorithm– Uses 2N MRSW registers
• So the bound is (pretty) tight
• But what if we use MRMW registers?– Like victim[] ?
![Page 145: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/145.jpg)
Art of Multiprocessor Programming
145
Bad News Theorem
At least N MRMW multi-reader/multi-writer registers are needed to solve deadlock-free mutual exclusion.
(So multiple writers don’t help)
![Page 146: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/146.jpg)
Art of Multiprocessor Programming
146
Theorem (For 2 Threads)
Theorem: Deadlock-free mutual exclusion for 2 threads requires at least 2 multi-reader multi-writer registers
Proof: assume one register suffices and derive a contradiction
![Page 147: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/147.jpg)
Art of Multiprocessor Programming
147
Two Thread Execution
• Threads run, reading and writing R
• Deadlock free so at least one gets in
BA
CS
Write(R)
CS
R
![Page 148: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/148.jpg)
Art of Multiprocessor Programming
148
Covering State for One Register Always Exists
Write(R)
B
In any protocol B has to write to the register before entering CS, so stop
it just before
![Page 149: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/149.jpg)
Art of Multiprocessor Programming
149
Proof: Assume Cover of 1
A B
Write(R)
CS
A runs, possibly writes to the register, enters CS
![Page 150: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/150.jpg)
Art of Multiprocessor Programming
150
Proof: Assume Cover of 1
A B
CS
B Runs, first obliterating any trace of A, then also enters the critical section
Write(R)
CS
![Page 151: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/151.jpg)
Art of Multiprocessor Programming
151
Theorem
Deadlock-free mutual exclusion for 3 threads requires at least 3 multi-reader multi-writer registers
![Page 152: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/152.jpg)
Art of Multiprocessor Programming
152
Proof: Assume Cover of 2
Write(RB)
B
Write(RC)
CA
Only 2 registers
![Page 153: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/153.jpg)
Art of Multiprocessor Programming
153
Run A Solo
Write(RB)
B
Write(RC)
CA
Writes to one or both registers, enters CS CS
![Page 154: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/154.jpg)
Art of Multiprocessor Programming
154
Obliterate Traces of A
Write(RB)
B
Write(RC)
CA
Other threads obliterate evidence that A entered CS CS
![Page 155: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/155.jpg)
Art of Multiprocessor Programming
155
Mutual Exclusion Fails
Write(RB)
B
Write(RC)
CA
CS CS
CS looks empty, so another thread gets
in
![Page 156: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/156.jpg)
Art of Multiprocessor Programming
156
Proof Strategy
• Proved: a contradiction starting from a covering state for 2 registers
• Claim: a covering state for 2 registers is reachable from any state where CS is empty
![Page 157: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/157.jpg)
Art of Multiprocessor Programming
157
• If we run B through CS 3 times, B must return twice to cover some register, say RB
Covering State for Two
Write(RB)
B
Write(RA)
A
![Page 158: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/158.jpg)
Art of Multiprocessor Programming
158
Covering State for Two
• Start with B covering register RB for the 1st time • Run A until it is about to write to uncovered RA
• Are we done?
Write(RB)
B
Write(RA)
A
![Page 159: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/159.jpg)
Art of Multiprocessor Programming
159
Covering State for Two
• NO! A could have written to RB
• So CS no longer looks empty to thread C
Write(RB)
B
Write(RA)
A
![Page 160: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/160.jpg)
Art of Multiprocessor Programming
160
Covering State for Two
• Run B obliterating traces of A in RB
• Run B again until it is about to write to RB
• Now we are done
Write(RB)
B
Write(RA)
A
![Page 161: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/161.jpg)
Art of Multiprocessor Programming
161
Inductively We Can Show
• There is a covering state– Where k threads not in CS cover k distinct registers– Proof follows when k = N-1
Write(RB)
B
Write(RC)
C
Write(RA)
A
![Page 162: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/162.jpg)
Art of Multiprocessor Programming
162
Summary of Lecture
• In the 1960’s several incorrect solutions to starvation-free mutual exclusion using RW-registers were published…
• Today we know how to solve FIFO N thread mutual exclusion using 2N RW-Registers
![Page 163: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/163.jpg)
Art of Multiprocessor Programming
163
Summary of Lecture
• N RW-Registers inefficient– Because writes “cover” older writes
• Need stronger hardware operations – that do not have the “covering problem”
• In next lectures - understand what these operations are…
![Page 164: Mutual Exclusion Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit](https://reader036.vdocuments.us/reader036/viewer/2022081721/55147962550346ea6e8b45de/html5/thumbnails/164.jpg)
Art of Multiprocessor Programming
164
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
• You are free:– to Share — to copy, distribute and transmit the work – to Remix — to adapt the work
• Under the following conditions:– Attribution. You must attribute the work to “The Art of
Multiprocessor Programming” (but not in any way that suggests that the authors endorse you or your use of the work).
– Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under the same, similar or a compatible license.
• For any reuse or distribution, you must make clear to others the license terms of this work. The best way to do this is with a link to– http://creativecommons.org/licenses/by-sa/3.0/.
• Any of the above conditions can be waived if you get permission from the copyright holder.
• Nothing in this license impairs or restricts the author's moral rights.