Chapter 04

Foundations of Shared Memory
Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Art of Multiprocessor Programming
Fundamentals
What is the weakest form of communication that supports mutual exclusion? What is the weakest shared object that allows shared-memory computation?
Alan Turing
Showed what is and is not computable on a sequential machine. Still best model there is.
Turing Computability
0 1 1 0 1 0
Mathematical model of computation What is (and is not) computable Efficiency (mostly) irrelevant
Art of Multiprocessor Programming 5
Shared-Memory Computability?
Shared Memory
10011
Mathematical model of concurrent computation What is (and is not) concurrently computable Efficiency (mostly) irrelevant
6

To understand modern multiprocessors we need to ask some basic questions

To understand modern What is the weakest useful form of multiprocessors we need to ask shared memory? some basic questions

To understand modern What is the weakest useful form of multiprocessors to ask What we canneed it do? shared memory? some basic questions

To understand modern What is the weakest useful form of multiprocessors to ask What we canneed it do? shared memory? What cant it do? some basic questions
10
Register *
Holds a (binary) value
10011
* A memory location: name is historical
Register 10011
Can be read
10011
Register
Can be written
01100
10011
13
Registers
public interface Register<T> { public T read(); public void write(T v); }
14
Registers
public interface Register<T> { public T read(); public void write(T v); }
Type of register (usually Boolean or m-bit Integer)

Single-Reader/Single-Writer Register
10011 01100 10011

16
Multi-Reader/Single-Writer Register
10011
01100
10011
17
Multi-Reader/Multi-Writer Register
mumble
10011
mumble
10011
01010
mumble
10011 11011
Jargon Watch
SRSW
Single-reader single-writer
MRSW
Multi-reader single-writer
MRMW
Multi-reader multi-writer
19
Safe Register
OK if reads and writes dont overlap
read(1001)
write(1001)
20
Safe Register
Some valid value if reads and writes do overlap
$*&v 1111
21
write(1001)
read(????)
0000
1001
Regular Register
write(0) write(1)
read(1)
read(0)
Single Writer Readers return:
Old value if no overlap (safe) Old or one of new values if overlap

Regular or Not?
write(0) write(1)
read(1)
read(0)
23
Regular or Not?
write(0) write(1)
read(1)
read(0)
Overlap: returns new value
24
Regular or Not?
write(0) write(1)
read(0)
Overlap: returns old value
25
Regular or Not?
write(0) write(1)
read(1)
read(0)
26
Regular Linearizable
write(0) write(1)
read(1)
read(0)
explain this! write(1) already happened

Atomic Register
write(1001) write(1010) read(1010)
read(1001)
read(1010)
Linearizable to sequential safe register

Atomic Register
write(1001) write(1010) read(1010)
read(1001)
read(1010)
29
Register Space
MRMW
MRSW M-valued Boolean
SRSW
Safe
Regular Atomic
30
Weakest Register
Single writer
1 0 1
Single reader
Safe Boolean register

Weakest Register
Single writer
0 1 0
Single reader
0 1 0
flipflop
Get correct reading if not during state transition

Results
From SRSW safe Boolean register
All the other registers Mutual exclusion
But not everything!

Consensus hierarchy
Foundations of the field
The really cool stuff

Locking within Registers

Not interesting to rely on mutual exclusion in register constructions We want registers to implement mutual exclusion! No fun to use mutual exclusion to implement itself!
34
Wait-Free Implementations
Definition: An object implementation is wait-free if every method call completes in a finite number of steps
No mutual exclusion
Thread could halt in critical section Build mutual exclusion from registers
From Safe SRSW Boolean to Atomic Snapshots

MRMW MRSW SRSW Safe
M-valued Boolean
Regular Atomic Snapshot

36
Road Map
SRSW safe Boolean MRSW safe Boolean MRSW regular Boolean MRSW regular MRSW atomic MRMW atomic Atomic snapshot
Road Map
Next
38
Register Names
public class SafeBoolMRSWRegister implements Register<Boolean> { public boolean read() { } public void write(boolean x) { } }
39
Register Names
property
40
Register Names
property
Size matters
Register Names
property
type
(3)
How many readers & writers?

42
Safe Boolean MRSW from Safe Boolean SRSW

0 0 0 0 readers
zzz
0 0
writer
0 0
43

Lets Write 1!
0 0 0 0
0
44

0 or 1 0 0 0
1 0
0
45

1 0 0 1 1 0 or 1
0
46

1 0 0 1 1 0 or 1 0 0 1
47

1 1 1
Whew!
1
1 1
1
48

public class SafeBoolMRSWRegister implements Register<Boolean> { private SafeBoolSRSWRegister[] r = new SafeBoolSRSWRegister[N]; public void write(boolean x) { for (int j = 0; j < N; j++) r[j].write(x); } public boolean read() { int i = ThreadID.get(); return r[i].read(); }}
49

public class SafeBoolMRSWRegister implements BooleanRegister { private SafeBoolSRSWRegister[] r = new SafeBoolSRSWRegister[N]; public void write(boolean x) { for (int j = 0; j < N; j++) r[j].write(x); } public boolean read() { int i = ThreadID.get(); return r[i].read(); Each thread }}
has own safe SRSW register

50

public class SafeBoolMRSWRegister implements BooleanRegister { private SafeBoolSRSWRegister[] r = new SafeBoolSRSWRegister[N]; public void write(boolean x) { for (int j = 0; j < N; j++) r[j].write(x); } public boolean read() { int i = ThreadID.get(); return r[i].read(); write method }}
51

public class SafeBoolMRSWRegister implements BooleanRegister { private SafeBoolSRSWRegister[] r = new SafeBoolSRSWRegister[N]; public void write(boolean x) { for (int j = 0; j < N; j++) r[j].write(x); } public boolean read() { Write each int i = ThreadID.get(); threads register return r[i].read(); one at a time }}
52

public class SafeBoolMRSWRegister implements BooleanRegister { private SafeBoolSRSWRegister[] r = new SafeBoolSRSWRegister[N]; public void write(boolean x) { for (int j = 0; j < N; j++) r[j].write(x); read } public boolean read() { int i = ThreadID.get(); return r[i].read(); }}
method
53

public class SafeBoolMRSWRegister implements BooleanRegister { private SafeBoolSRSWRegister[] r = new SafeBoolSRSWRegister[N]; public void write(boolean x) { for (int j = 0; j < N; j++) r[j].write(x); } public boolean read() { int i = ThreadID.get(); return r[i].read(); }}
Read my own register

54
Q: Safe Multi-Valued MRSW Safe Multi-Valued SRSW?

1 0 1011 1
1000 0
1000
1011
Any value in range

1000
55
Road Map
SRSW safe Boolean MRSW safe Boolean MRSW regular Boolean MRSW regular MRSW atomic Questions? MRMW atomic Atomic snapshot
Road Map
Next
57
Regular Boolean MRSW from Safe Boolean MRSW

0 1
1 0
0 1 0 1
58

0 1 Regular cannot return 1
0 0
0 1 0 1
59

0
0 Last written: 0 0
0 0
60

public class RegBoolMRSWRegister implements Register<Boolean> { private boolean old; private SafeBoolMRSWRegister value; public void write(boolean x) { if (old != x) { value.write(x); old = x; }} public boolean read() { return value.read(); }}

public class RegBoolMRSWRegister implements Register<Boolean> { threadLocal boolean old; private SafeBoolMRSWRegister value; public void write(boolean x) { if (old != x) { value.write(x); old = x; Last bit this thread (made-up syntax) }} public boolean read() { return value.read(); }}
wrote
62

public class RegBoolMRSWRegister implements Register<Boolean> { threadLocal boolean old; private SafeBoolMRSWRegister value; public void write(boolean x) { if (old != x) { value.write(x); old = x; }} public boolean read() { return value.read(); Actual value }}

public class RegBoolMRSWRegister implements Register<Boolean> { threadLocal boolean old; private SafeBoolMRSWRegister value; public void write(boolean x) { if (old != x) { value.write(x); Is new value different old = x; from last value I wrote? }} public boolean read() { return value.read(); }}

public class RegBoolMRSWRegister implements Register<Boolean> { threadLocal boolean old; private SafeBoolMRSWRegister value; public void write(boolean x) { if (old != x) { value.write(x); old = x; }} public boolean read() { If so, change it return value.read(); }} (otherwise dont!)

public class RegBoolMRSWRegister implements Register<Boolean>{ threadLocal boolean old; private SafeBoolMRSWRegister value; public void write(boolean x) { if (old != x) { Overlap? No Overlap? value.write(x); No problem old = x; either Boolean value works }} public boolean read() { return value.read(); }}
Regular Multi-Valued MRSW from Safe Multi-Valued MRSW?

Safe register can return value in range other than old or new when value changes 0101 0101 0101
Multi-valued Regular register can return only old or new when value changes!
67
Road Map
SRSW safe Boolean MRSW safe Boolean MRSW regular Boolean MRSW regular MRSW atomic MRMW atomic Questions? Atomic snapshot
Road Map
Next
69
Writing M-Valued
Unary representation: bit[i] means value i
1 0 0 0 00 0
Initially 0
01234567
70
Writing M-Valued
Write 5
1 0 0 00 01234567
71
Writing M-Valued
Write 5
Initially 0
0 1 0 0 0 1 01234567
72
Writing M-Valued
Write 5
5 01234567
0 1 0 0 0 1
73
MRSW Regular M-valued from MRSW Regular Boolean

public class RegMRSWRegister implements Register{ RegBoolMRSWRegister[M] bit; public void write(int x) { this.bit[x].write(true); for (int i=x-1; i>=0; i--) this.bit[i].write(false); } public int read() { for (int i=0; i < M; i++) if (this.bit[i].read()) return i; }}
74

public class RegMRSWRegister implements Register{ RegBoolMRSWRegister[M] bit; public void write(int x) { this.bit[x].write(true); for (int i=x-1; i>=0; i--) this.bit[i].write(false); } Unary representation:
bit[i] public int read() { for (int i=0; i < M; i++) if (this.bit[i].read()) return i; }}
means value i
75

public class RegMRSWRegisterimplements Register { RegBoolMRSWRegister[m] bit; public void write(int x) { this.bit[x].write(true); for (int i=x-1; i>=0; i--) this.bit[i].write(false); } public int read() { for (int i=0; i < M; i++) if (this.bit[i].read()) return i; }}
Set bit x
76

public class RegMRSWRegisterimplements Register { RegBoolMRSWRegister[m] bit; public void write(int x) { this.bit[x].write(true); for (int i=x-1; i>=0; i--) this.bit[i].write(false); } public int read() { for (int i=0; i < M; i++) if (this.bit[i].read()) return i; }}
Clear bits from higher to lower
77

public class RegMRSWRegisterimplements Register { RegBoolMRSWRegister[m] bit; public void write(int x) { Scan from this.bit[x].write(true); to higher & for (int i=x-1; i>=0; i--) this.bit[i].write(false); first bit } public int read() { for (int i=0; i < M; i++) if (this.bit[i].read()) return i; }}
lower return set
78
Road Map
SRSW safe Boolean MRSW safe Boolean MRSW regular Boolean MRSW regular MRSW atomic MRMW atomic Questions? Atomic snapshot
Road Map
Road Map (Slight Detour)

SRSW safe Boolean MRSW safe Boolean MRSW regular Boolean MRSW regular SRSW Atomic MRSW atomic MRMW atomic Atomic snapshot
SRSW Atomic From SRSW Regular

Regular writer Regular reader
1234 5678
1234
Concurrent Reading When is this a problem?

Instead of 5678
82

1234 5678
Initially 1234
5678
Reg write(5678) Reg read(5678)
time

1234 5678
Initially 1234
1234
Instead of 5678
time

1234 5678
Initially 1234
1234
Instead of 5678
Reg read(5678)
Write time 5678 happened
85
Timestamped Values
1234 1:45 5678 2:00 Writer writes value and stamp together
2:00
5678
Reader saves last read (value,stamp) and returns new value only if higher stamp
86
writer
reader 1:45 2:00 1:45 1234 1234 5678

1:45 1234 Less than 2:00 5678 So stick with 5678
Reg write(2:00 5678) read(2:00 5678)
read(1:45 1234)
time
old = 2:00 5678

>
Atomic Single Reader to Atomic Multi-Reader

stamp 1:45 1:45 1:45 1:45 value 1234 1234 1234 1234
One per reader
88
Another Scenario
Writer starts write stamp 2:00 1:45 1:45 1:45 value 5678 1234 1234 1234
89
Another Scenario
zzz stamp 2:00 1:45 1:45 1:45 value 5678 1234 1234 1234 2:00, 5678
reader reads
later reader
1:45 1234
Yellow was completely after Blue but read earlier valuenot linearizable!
90
Multi-Reader Redux
One per thread
1 1:45 1:45 1:45 1234 1234 1234 1:45 1:45 1:45 2 1234 1234 1234 1:45 1:45 1:45 3 1234 1234 1234 1 2 3
91
Writer writes column
Multi-Reader Redux
2:00, 5678
1 1 1:45 2:00 1:45 2:00 2:00 1:45 1234 5678 1234 5678 5678 1234 1:45 1:45 1:45 2 1234 1234 1234
reader reads row

3 1:45 1:45 1:45
2 1 2 3
1234 1234 1234
92
zzzafter second write
Multi-Reader Redux
2:00, 5678
reader writes column to 1 notify others of what it 2 read 1 2 3 1:45 1234 1:45 1234 2:00 5678 1:45 1234 1 2:00 5678 1:45 1234 1:45 1234 2:00 5678 1:45 1234 2 2:00 5678 1:45 1234 2:00 1:45 5678 1234 1:45 1234 3
Yellow reader will read new value in column written by earlier Blue reader
Cant Yellow Miss Blues Update? Only if Readers Overlap
1:45 1234
write(2:00 5678) read(2:00 5678) read(1:45 1234)
In which case time its OK to read 1234

Bad Case Only When Readers Dont Overlap

1:45 1234
write(2:00 5678)
read(2:00 5678)
In which case Blue will complete writing 2:00 5678 to its column
read(2:00 5678)
time
95
Road Map
SRSW safe Boolean MRSW safe Boolean MRSW regular Boolean MRSW regular MRSW atomic Next MRMW atomic Atomic snapshot
Multi-Writer Atomic From MultiReader Atomic

stamp
Each writer reads all then writes Max+1 to its register
value
1:45 1:45 2:00 1:45 2:15 1:45
1234 1234 5678 1234 XYZW 1234
Readers read all and take max (Lexicographic like Bakery)
Max is 2:15, return XYZW

Atomic Execution Means its Linearizable
write(1) write(2) Read (max = 1)
Read(max= 2) write(3) write(2)
write(4) Read(max = 3) Read(max = 4)
time time
Linearization Points
time time
Look at Writes First
write(1) write(2) write(3) write(2)
write(4)
time time
Order writes by TimeStamp
write(1) write(2) write(3) write(2)
write(4)
time time
Order reads by max stamp read
time time
Order reads by max stamp read
time time
The linearization point depends on the execution (not a line in the code)!
time time
Road Map
SRSW safe Boolean MRSW safe Boolean MRSW regular Boolean MRSW regular MRSW atomic Questions? MRMW atomic Atomic snapshot
Road Map
SRSW safe Boolean MRSW safe Boolean MRSW regular Boolean MRSW regular MRSW atomic MRMW atomic Next Atomic snapshot
Atomic Snapshot
update
scan
107
Atomic Snapshot
Array of SWMR atomic registers Take instantaneous snapshot of all Generalizes to MRMW registers
108
Snapshot Interface
public interface Snapshot { public int update(int v); public int[] scan(); }
109
Snapshot Interface
Thread i writes v to its register
public interface Snapshot { public int update(int v); public int[] scan(); }
110
Snapshot Interface
Instantaneous snapshot of all theads registers public interface Snapshot { public int update(int v); public int[] scan(); }
111
Atomic Snapshot
Collect
Read values one at a time
Problem
Incompatible concurrent collects Result not linearizable
112
Clean Collects
Clean Collect
Collect during which nothing changed Can we make it happen? Can we detect it?
113
Simple Snapshot
Put increasing labels on each entry Collect Problem:twice Scanner might not be collecting a snapshot! If both agree,
Were done
Collect1 x y z w r z x Art of Multiprocessor Programming
Otherwise,
Try again
Collect2
x
y z w r z x 114
Scanner reads x==x and z==z Claim: We Must Use Labels

but as we said x and z were never in memory together
z x z
Scanner
Updater
Updater time
y
z w
y
z
x and z are never in memory together 115 Art of Multiprocessor Programming
Scanner reads x and z with Must Use Labels different labels and recognizes this is not a clean collect
Scanner 1,x 1,z 3,x 3,z
Updater
Updater time
1,x
2,y
1,z 2,w
3,x
4,y
3,z
116
Simple Snapshot
Collect twice If both agree,
Were done
Otherwise,
Try again
Collect1 1 22 1 7 13 18 12 Art of Multiprocessor Programming
Collect2
1
22 1 7 13 18 12 117
Simple Snapshot: Update

public class SimpleSnapshot implements Snapshot { private AtomicMRSWRegister[] register; public void update(int value) { int i = Thread.myIndex();
LabeledValue oldValue = register[i].read();
LabeledValue newValue = new LabeledValue(oldValue.label+1, value); register[i].write(newValue); }
118

public class SimpleSnapshot implements Snapshot { private AtomicMRSWRegister[] register; public void update(int value) { int i = Thread.myIndex(); LabeledValue oldValue = register[i].read(); LabeledValue newValue = new LabeledValue(oldValue.label+1, value); register[i].write(newValue); }
One single-writer register per thread


public class SimpleSnapshot implements Snapshot { private AtomicMRSWRegister[] register; public void update(int value) { int i = Thread.myIndex(); LabeledValue oldValue = register[i].read(); LabeledValue newValue = new LabeledValue(oldValue.label+1, value); register[i].write(newValue); }
Write each time with higher label

Simple Snapshot: Collect

private LabeledValue[] collect() { LabeledValue[] copy = new LabeledValue[n]; for (int j = 0; j < n; j++) copy[j] = this.register[j].read(); return copy; }
121
Simple Snapshot
private LabeledValue[] collect() { LabeledValue[] copy = new LabeledValue[n]; for (int j = 0; j < n; j++) copy[j] = this.register[j].read(); return copy; }
Just read each register into array
122
Simple Snapshot: Scan

public int[] scan() { LabeledValue[] oldCopy, newCopy; oldCopy = collect(); collect: while (true) { newCopy = collect(); if (!equals(oldCopy, newCopy)) { oldCopy = newCopy; continue collect; }} return getValues(newCopy); }}}

public int[] scan() { LabeledValue[] oldCopy, newCopy; Collect oldCopy = collect(); collect: while (true) { newCopy = collect(); if (!equals(oldCopy, newCopy)) { oldCopy = newCopy; continue collect; }} return getValues(newCopy); }}}
once
124

public int[] scan() { LabeledValue[] oldCopy, newCopy; Collect once oldCopy = collect(); collect: while (true) { Collect twice newCopy = collect(); if (!equals(oldCopy, newCopy)) { oldCopy = newCopy; continue collect; }} return getValues(newCopy); }}}

public int[] scan() { LabeledValue[] oldCopy, newCopy; Collect once oldCopy = collect(); collect: while (true) { Collect twice newCopy = collect(); if (!equals(oldCopy, newCopy)) { oldCopy = newCopy; continue collect; }} return getValues(newCopy); try again }}}
On mismatch,
126

public int[] scan() { LabeledValue[] oldCopy, newCopy; Collect once oldCopy = collect(); collect: while (true) { Collect twice newCopy = collect(); if (!equals(oldCopy, newCopy)) { oldCopy = newCopy; On match, return continue collect; values }} return getValues(newCopy); }}}
Simple Snapshot
Linearizable Update is wait-free
No unbounded loops
But Scan can starve

If interrupted by concurrent update
128
Wait-Free Snapshot
Add a scan before every update Write resulting snapshot together with update value If scan is continuously interrupted by updates, scan can take the updates snapshot
129
Wait-free Snapshot
If As scan observes that B moved twice, then B completed an update while As scan was in progress
Collect Collect Collect 26 24 12
26 24 12 Update
26 24 12
B time
130
Wait-free Snapshot
A
26 24 12
Update
26 24 12
time
Wait-free Snapshot
A
26 24 12 Scan
Write
26 24 12
Update
time
Wait-free Snapshot
Bs 1st update must have written during 1st collect
Collect
Collect
Collect
26 24 12 Scan
Write
26 24 12 Scan
Write
26 24 12
So A can steal result of Bs scan So scan of Bs second update must be within interval of As scan time
Update
Wait-free Snapshot
A
Collect Collect Collect 26 24 12 Scan
Write
26 24 12 Scan
Write
26 24 12
But no guarantee that scan of Bs 1st update can be used Why? time
Once is not Enough

A
Collect Collect 26 24 12
Write
26 24 12
Scan
Update
time
Why cant A steal result of Bs scan Update Because another update might have interfered before the scan
Someone Must Move Twice

26 24 12 Update
26 24 12
B
time
If we collect n timessome thread must move twice (pigeonhole principle)

Scan is Wait-free
scan
At most n-1 depth
update
scan
update scan
So some thread must have had clean collect

137
Wait-Free Snapshot Label

public class SnapValue { public int label; public int value; public int[] snap; }
138

Counter incremented with each snapshot
139

Actual value
140

most recent snapshot

1101111010100010110000
label
value
Last snapshot
142
Wait-free Update
public void update(int value) { int i = Thread.myIndex(); int[] snap = this.scan(); SnapValue oldValue = r[i].read(); SnapValue newValue = new SnapValue(oldValue.label+1, value, snap); r[i].write(newValue); }
Wait-free Scan
public void update(int value) { Take scan int i = Thread.myIndex(); int[] snap = this.scan(); SnapValue oldValue = r[i].read(); SnapValue newValue = new SnapValue(oldValue.label+1, value, snap); r[i].write(newValue); }
Wait-free Scan
public void update(int value) { Take scan int i = Thread.myIndex(); int[] snap = this.scan(); SnapValue oldValue = r[i].read(); SnapValue newValue = new SnapValue(oldValue.label+1, value, snap); r[i].write(newValue); Label value with scan }
Wait-free Scan
public int[] scan() { SnapValue[] oldCopy, newCopy; boolean[] moved = new boolean[n]; oldCopy = collect(); collect: while (true) { newCopy = collect(); for (int j = 0; j < n; j++) { if (oldCopy[j].label != newCopy[j].label) { }} return getValues(newCopy); }}}
146
Wait-free Scan
public int[] scan() { SnapValue[] oldCopy, newCopy; boolean[] moved = new boolean[n]; oldCopy = collect(); collect: while (true) { newCopy = collect(); for (int j = 0; j < n; j++) { if (oldCopy[j].label != newCopy[j].label) { Keep track of who moved }} return getValues(newCopy); }}}
147
Wait-free Scan
Repeated double collect
148
Wait-free Scan
If mismatch detectedlets expand here Art of Multiprocessor Programming
149
Mismatch Detected
if (oldCopy[j].label != newCopy[j].label) { if (moved[j]) { // second move return newCopy[j].snap; } else { moved[j] = true; oldCopy = newCopy; continue collect; }}} return getValues(newCopy); }}}
150
Mismatch Detected
if (oldCopy[j].label != newCopy[j].label) { if (moved[j]) { return newCopy[j].snap; } else { moved[j] = true; oldCopy = newCopy; continue collect; If thread moved twice, }}} just steal its second return getValues(newCopy); snapshot }}}
151
Mismatch Detected
if (oldCopy[j].label != newCopy[j].label) { if (moved[j]) { // second move return newCopy[j].snap; } else { moved[j] = true; Remember that oldCopy = newCopy; thread moved continue collect; }}} return getValues(newCopy); }}}
152
Observations
Uses unbounded counters
can be replaced with 2 bits
Assumes SWMR registers

for labels can be extended to MRMW
153
Summary
We saw we could implement MRMW multi valued snapshot objects From SRSW binary safe registers (simple flipflops) But what is the next step to attempt with read-write registers?
154
Grand Challenge
Snapshot means
Write any one array element Read multiple array elements
155
Grand Challenge
What about atomic writes to multiple locations?
Writes to 0 and 1
Writes to 1 and 2
Write many and snapshot
156
This work is licensed under a Creative Commons AttributionShareAlike 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.
157

Chapter 04

Загружено:

Сведения о документе

Исходное описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Chapter 04

Загружено:

Авторское право:

Доступные форматы

Foundations of Shared Memory

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Foundations of Shared Memory

Art of Multiprocessor Programming

Foundations of Shared Memory

Art of Multiprocessor Programming

Foundations of Shared Memory

Art of Multiprocessor Programming

Foundations of Shared Memory

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Type of register (usually Boolean or m-bit Integer)

10011 01100 10011

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Single Writer Readers return:

Old value if no overlap (safe) Old or one of new values if overlap

Art of Multiprocessor Programming

Overlap: returns new value

Art of Multiprocessor Programming

Overlap: returns old value

Art of Multiprocessor Programming

Art of Multiprocessor Programming

explain this! write(1) already happened

Linearizable to sequential safe register

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Safe Boolean register

Get correct reading if not during state transition

But not everything!

Foundations of the field

The really cool stuff

Locking within Registers

Art of Multiprocessor Programming

From Safe SRSW Boolean to Atomic Snapshots

Regular Atomic Snapshot

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Art of Multiprocessor Programming

Art of Multiprocessor Programming

How many readers & writers?

Art of Multiprocessor Programming

Safe Boolean MRSW from Safe Boolean SRSW

Art of Multiprocessor Programming

Safe Boolean MRSW from Safe Boolean SRSW

Art of Multiprocessor Programming

Safe Boolean MRSW from Safe Boolean SRSW

Art of Multiprocessor Programming

Safe Boolean MRSW from Safe Boolean SRSW

Art of Multiprocessor Programming

Safe Boolean MRSW from Safe Boolean SRSW

Art of Multiprocessor Programming

Safe Boolean MRSW from Safe Boolean SRSW

Art of Multiprocessor Programming

Safe Boolean MRSW from Safe Boolean SRSW

Art of Multiprocessor Programming

Safe Boolean MRSW from Safe Boolean SRSW

has own safe SRSW register