Atomic snapshots in O (log³ n) steps
description
Transcript of Atomic snapshots in O (log³ n) steps
![Page 1: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/1.jpg)
1
Atomic snapshots in O(log³ n) steps
![Page 2: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/2.jpg)
Snapshot Objects
p1 p2 pn…
…
update(v) scan
2
update your location
read all locations
![Page 3: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/3.jpg)
3
Model
System of n processes, multi-writer registersAsynchronous schedule controlled by an adversaryCrash failures – require wait-free implementationsLinearizable implementations
p1 p2
R1
pn
R2 R…
…
read v write(v) ok
![Page 4: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/4.jpg)
4
Snapshots - Step ComplexityUsing multi-writer registers:
can be done in O(n) steps [Inoue and Chen, WDAG 1994]and requires Ω(n) steps [Jayanti, Tan, and Toueg, SICOMP 1996]
Goal: a faster snapshot implementation (polylog)
Limited-use: O(log3(n)) steps per operation, for polynomially many update operations
Randomized unbounded: O(log3(n)) steps per operation, with high probability (without a usage bound)
![Page 5: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/5.jpg)
5
Pointer to array location
s1 s2 s3 s4
s1+s2 s3+s4
s1+...+s4
0
Tree structure, Updates help Scans
0 01 1
12
2 2
3
3
45
Array of views
5X
O(log n) steps?
![Page 6: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/6.jpg)
6
Two Challenges
s1 s2 s3 s4
s1+s2 s3+s4
s1+...+s4
5
1. Coping with slow operations. Max-register: returns largest
value previously written
![Page 7: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/7.jpg)
7
Two Challenges
s1 s2 s3 s4
s1+s2 s3+s4
s1+...+s4
5
2. Guaranteeing consistent views. Max-array: returns comparable
pairs of max-register values
![Page 8: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/8.jpg)
8
Bounded/Randomized snapshot in O(log3n) steps
Bounded/Randomized 2-component max-arrayO(log2n) steps
Bounded/Randomized max-register in O(logn) steps
Ingredients
![Page 9: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/9.jpg)
9
Max register
• Replace multi-writer registers with Max Registers
Max Register
WriteMax(v)ok
ReadMaxv
Maximal value previously
written
![Page 10: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/10.jpg)
10
Max register – recursive construction
• MaxReg0: Max register that supports only the value 0– WriteMax is a no-op, and ReadMax returns 0
• MaxReg1 supports values in {0,1}– Built from two MaxReg0 objects– and one additional multi-writer register “switch”
MaxReg0
MaxReg0 MaxReg0
switchWriteMax 01 =1
ReadMax= ?
switch=0 : return 0
switch=1 : return 1
![Page 11: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/11.jpg)
11
Max register – recursive construction
• MaxRegk supports values in {0,…,k-1}– Built from two MaxRegk/2 objects with values in {0,…,k/2-1}– and one additional multi-writer register “switch”
MaxRegk/2 MaxRegk/2
MaxRegk
switchWriteMax tt < k/2 ?t t-k/2
ReadMax
=1
= ?
t tswitch=0 : return t
switch=1 : return t+k/2
![Page 12: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/12.jpg)
12
MaxRegk unfolded
switch
MaxReg0 …
switch
switch switch
MaxReg0MaxReg0 MaxReg0MaxReg0
… …
MaxRegk
0 1 2 k-1
Complexity does not depend on n:WriteMax and ReadMax in O(logk) steps
O(logk)
![Page 13: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/13.jpg)
13
Unbalanced tree
MaxReg0
…
switch
switch
switchswitch
MaxReg0 MaxReg0
Bentley and Yao [1976]
switch
switchswitch
MaxReg0 MaxReg0 MaxReg0 MaxReg0
Leaf i is at depth O(log i)
![Page 14: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/14.jpg)
14
Unbounded max register
MaxReg0
…
switch
switch
Snapshot-based counter
switchswitch
MaxReg0 MaxReg0
WriteMax and ReadMax of vin O(min(log v, n)) steps
![Page 15: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/15.jpg)
2-component max array
p1 p2 pn…
max 1 max 2
update(v,1)scan
15
update(v,2)
![Page 16: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/16.jpg)
16
Cannot Simply Read Both Locations
• We need to make sure that pairs of values that are read from sibling nodes are comparable– As in a snapshot
• In general, snapshots are linear• However, we only need to take a snapshot of
two max registers
![Page 17: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/17.jpg)
17
2-component max array
Simply reading one max register and then the other does not work
max 1 max 21. p1 read 02. p2 write(100)3. p3 read 100
4. p3 read 05. p2 write(100)6. p1 read 100
p1 returns(0,100)p3 returns(100,0)
![Page 18: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/18.jpg)
18
2-component max array
Read max registers again to see if they change– Might change many times– What if they were only binary?
(0,0) and (1,1) are comparable with any pairIf you see (0,1) or (1,0) read again
max 1 max 21. p1 read 02. p2 write(100)3. p3 read 100
4. p3 read 05. p2 write(100)6. p1 read 100
![Page 19: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/19.jpg)
19
A 2-component max array
MaxRegk/2 MaxRegk/2
MaxRegk
switch MaxRegl
MaxRegl MaxRegl
Write
Read
switch=0 :
switch=1 :
v,1v,2
x=ReadMax component 2
WriteMax(x,2) to left subtreeReturn (Read left subtree)
x=ReadMax component 2WriteMax(x,2) to right subtreeReturn (k/2,0)+(Read right subtree)
xx
= ?
![Page 20: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/20.jpg)
20
A 2-component max array
MaxRegk/2 MaxRegk/2
MaxRegk
switch MaxRegl
MaxRegl MaxRegl
Write
Read
switch=0 :
switch=1 :
x=ReadMax component 2
WriteMax(x,2) to left subtreeReturn (Read left subtree)
x=ReadMax component 2WriteMax(x,2) to right subtreeReturn (k/2,0)+(Read right subtree)
Key idea: a reader going right at the switch always sees a value for component 2 that is at least as large as any value that a reader going left sees
![Page 21: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/21.jpg)
21
A 2-component max array unfolded
switch
MaxReg0 …
switch
switch switch
MaxReg0MaxReg0 MaxReg0MaxReg0
… …
MaxRegk MaxRegl
MaxRegl
MaxRegl MaxRegl
MaxRegl MaxRegl MaxRegl MaxRegl MaxRegl
Complexity is O(logk logl) steps
![Page 22: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/22.jpg)
22
Summary of the Bounded Snapshot
For k which is polynomial in n we get:
A max-register with O(logn) steps per operation
A 2-component max-array with O(log2n) steps per operation
A bounded snapshot object, supporting a polynomial number of update operations, with O(log3n) steps per operation
![Page 23: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/23.jpg)
23
Towards an Unbounded Max-Register
switch = 0
switch = 0 switch = 0
value 0 value 1
value v value v’
… ……
write(v)
switch = 1 read
![Page 24: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/24.jpg)
24
Towards an Unbounded Max-Register
switch = 0
switch = 0 switch = 0
value 0 value 1
value v value v’
… ……
write(v)
switch = 1 read
write(v’)
switch = 1
write(v’’)
![Page 25: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/25.jpg)
25
Randomized Max-Registerswitch = 0
switch = 0
switch = 0
…
…
write(v)
switch = 1
switch = 1
m-valued max register
![Page 26: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/26.jpg)
26
Randomized Max-Registerswitch = 0
switch = 0
switch = 0
…
…
write(v)
switch = 1
switch = 1k-bounded increments:
value of write ≤ k + value of largest write
m-valued max register
O(log m + kn/m) = O(log n) steps per write
Assumption satisfied in snapshot tree for k=n
![Page 27: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/27.jpg)
27
Writing to the Max-Register
0
…
…
write(v)
1
1…TS:
…HELP:
…POINTER:
write(v)pi
v', ts[j]TS[j]
pj (cyclic)
i
read
(random)size n3
read v’ = max(returned value, v)
![Page 28: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/28.jpg)
28
Reading the Max-Register
0
…
…
read
1
1…TS:
…HELP:
…POINTER:
readpi
read (returns v, ts[j])
pj
read (returns i)
+1
(random)size n3
(logarithmic no. of steps)
if ts[j]==TS[j] return v
Main argument:many read steps
many fresh values in pointer array, whp
![Page 29: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/29.jpg)
29
2-Component Max Array
write0(v)
read
update first max-register
read both max-registers
write1(v)update second max-register
![Page 30: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/30.jpg)
30
Max Array Implementationswitch = 0
switch = 0 switch = 0
value 0 value 1
value v value v’
… ……
write0(v)
readMax1
Max1 Max1
Max1 Max1
Max1 Max1
write1(v) Max1
Max1
Max1
![Page 31: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/31.jpg)
31
Randomized 2-Component Max Array
switch = 0
switch = 0
switch = 0
…
…
write(v)
switch = 1
switch = 1 Max1
Max1Max1
Max1
Max1 Max1
Max1
Max1
Max1
Problem: readers do not travel all the way
from root to valueMax1
Max1Max1
Solution: read Max at root instead of Max at
previous location
![Page 32: Atomic snapshots in O (log³ n) steps](https://reader036.fdocuments.net/reader036/viewer/2022062323/56816356550346895dd40103/html5/thumbnails/32.jpg)
32
Summary of the Unbounded Snapshot
A randomized max-register with O(logn) steps per operation, with high probability, under the bounded-increments assumption
A randomized 2-component max-array with O(log2n) steps per operation, with high probability, under the bounded-increments assumption
An randomized unbounded snapshot object, supporting a polynomial number of update operations, with O(log3n) steps per operation, with high probability