Atomic snapshots in O(log³ n) steps 1

Snapshot Objects p1p1 p1p1 p2p2 p2p2 pnpn pnpn … … update( v ) scan 2 update your location read all locations

Model 3 System of n processes, multi-writer registers Asynchronous schedule controlled by an adversary Crash failures – require wait-free implementations Linearizable implementations p1p1 p1p1 p2p2 p2p2 R1R1 R1R1 pnpn pnpn R2R2 R2R2 R R … … read v write( v ) ok

Snapshots - Step Complexity 4 Using 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(log 3 (n)) steps per operation, for polynomially many update operations Randomized unbounded: O(log 3 (n)) steps per operation, with high probability (without a usage bound)

Pointer to array location 5 s1s1 s1s1 s2s2 s2s2 s3s3 s3s3 s4s4 s4s4 s 1 +s 2 s 3 +s 4 s s 4 0 Tree structure, Updates help Scans Array of views 5 O(log n) steps?

Two Challenges 6 s1s1 s1s1 s2s2 s2s2 s3s3 s3s3 s4s4 s4s4 s 1 +s 2 s 3 +s 4 s s Coping with slow operations. Max-register: returns largest value previously written

Two Challenges 7 s1s1 s1s1 s2s2 s2s2 s3s3 s3s3 s4s4 s4s4 s 1 +s 2 s 3 +s 4 s s Guaranteeing consistent views. Max-array: returns comparable pairs of max-register values

Bounded/Randomized snapshot in O(log 3 n) steps Bounded/Randomized 2-component max-array O(log 2 n) steps Bounded/Randomized 2-component max-array O(log 2 n) steps Bounded/Randomized max-register in O(logn) steps Ingredients 8

Max register 9 Replace multi-writer registers with Max Registers Max Register WriteMax( v ) ok ReadMax v Maximal value previously written

Max register – recursive construction 10 MaxReg 0 : Max register that supports only the value 0 – WriteMax is a no-op, and ReadMax returns 0 MaxReg 1 supports values in {0,1} – Built from two MaxReg 0 objects – and one additional multi-writer register “switch” MaxReg 0 switch WriteMax =1 ReadMax = ? switch=0 : return 0 switch=1 : return 1

Max register – recursive construction 11 MaxReg k supports values in {0,…,k-1} – Built from two MaxReg k/2 objects with values in {0,…,k/2-1} – and one additional multi-writer register “switch” MaxReg k/2 MaxReg k switch WriteMax t t t t < k/2 ? t t t -k/2 ReadMax =1 = ? t t t t switch=0 : return t switch=1 : return t +k/2

MaxReg k unfolded 12 switch MaxReg 0 … switch MaxReg 0 … … MaxReg k 012k-1 Complexity does not depend on n: WriteMax and ReadMax in O(logk) steps O(logk)

Unbalanced tree 13 MaxReg 0 … switch MaxReg 0 Bentley and Yao [1976] switch MaxReg 0 Leaf i is at depth O(log i)

Unbounded max register 14 MaxReg 0 … switch Snapshot-based counter switch MaxReg 0 WriteMax and ReadMax of v in O(min(log v, n)) steps

2-component max array p1p1 p1p1 p2p2 p2p2 pnpn pnpn … max 1max 2 update( v,1 ) scan 15 update( v,2 )

Cannot Simply Read Both Locations 16 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

2-component max array 17 Simply reading one max register and then the other does not work max 1 max 2 1. p 1 read 0 2. p 2 write( 100 ) 3. p 3 read p 3 read 0 5. p 2 write( 100 ) 6. p 1 read 100 p 1 returns (0,100) p 3 returns (100,0)

2-component max array 18 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 pair If you see (0,1) or (1,0) read again max 1 max 2 1. p 1 read 0 2. p 2 write( 100 ) 3. p 3 read p 3 read 0 5. p 2 write( 100 ) 6. p 1 read 100

A 2-component max array 19 MaxReg k/2 MaxReg k switch MaxReg l Write Read switch=0 : switch=1 : v,1 v,2 x=ReadMax component 2 WriteMax(x,2) to left subtree Return ( Read left subtree) x=ReadMax component 2 WriteMax(x,2) to right subtree Return (k/2,0)+( Read right subtree) x x x x = ?

A 2-component max array 20 MaxReg k/2 MaxReg k switch MaxReg l Write Read switch=0 : switch=1 : x=ReadMax component 2 WriteMax(x,2) to left subtree Return ( Read left subtree) x=ReadMax component 2 WriteMax(x,2) to right subtree Return (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

A 2-component max array unfolded 21 switch MaxReg 0 … switch MaxReg 0 … … MaxReg k MaxReg l Complexity is O(logk log l ) steps

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(log 2 n) steps per operation A bounded snapshot object, supporting a polynomial number of update operations, with O(log 3 n) steps per operation 22

Towards an Unbounded Max-Register switch = 0 value 0 value 1 value v value v’ … … … write( v ) switch = 1 read 23

Towards an Unbounded Max-Register switch = 0 value 0 value 1 value v value v’ … … … write( v ) switch = 1 read write( v’ ) switch = 1 write( v’’ ) 24

Randomized Max-Register switch = 0 … … write( v ) switch = 1 m-valued max register 25

Randomized Max-Register switch = 0 … … write( v ) switch = 1 k-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 26 Assumption satisfied in snapshot tree for k=n

Writing to the Max-Register 0 0 … … write( v ) TS: HELP: POINTER: write( v ) pipi v', ts[j]  TS[j] p j (cyclic) i read (random) size n 3 27 read v’ = max(returned value, v)

Reading the Max-Register 0 0 … … read TS: HELP: POINTER: read pipi read (returns v, ts[j]) pjpj read (returns i) +1 (random) size n 3 (logarithmic no. of steps) if ts[j]==TS[j] return v Main argument: many read steps  many fresh values in pointer array, whp Main argument: many read steps  many fresh values in pointer array, whp 28

2-Component Max Array 29 write0( v ) read update first max-register read both max-registers write1( v ) update second max-register

Max Array Implementation switch = 0 value 0 value 1 value v value v’ … … … write0( v ) read 30 Max1 write1( v ) Max1

Randomized 2-Component Max Array switch = 0 … … write( v ) switch = 1 31 Max1 Problem: readers do not travel all the way from root to value Max1 Solution: read Max at root instead of Max at previous location

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(log 2 n) 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(log 3 n) steps per operation, with high probability 32