1 / 18

Atomic snapshots in O (log³ n) steps using randomized helping

This talk discusses the implementation of atomic snapshots in a faster and more efficient manner using randomized helping. The goal is to reduce the number of steps per operation and improve the overall efficiency of the snapshot implementation. The talk also addresses challenges such as coping with slow operations and guaranteeing consistent views. The main technique used is randomized helping. The talk concludes with open problems and potential future research directions.

samanthal
Download Presentation

Atomic snapshots in O (log³ n) steps using randomized helping

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Atomic snapshots in O(log³ n) steps using randomized helping James Aspnes, Yale Keren Censor-Hillel, Technion

  2. Snapshot Objects … update(v) scan read all locations update your location p1 p2 pn …

  3. Model R1 R2 R … read v write(v) ok p1 p2 pn … System of nprocesses, multi-writer registers Asynchronous schedule controlled by an adversary Crash failures – require wait-free implementations Linearizable implementations

  4. Snapshots - Step Complexity 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(log3(n)) steps per operation, for polynomially many update operations [Aspnes, Attiya, Censor-Hillel, and Ellen, PODC 2012] This Talk: O(log3(n)) steps per operation, with high probability(without a usage bound)

  5. Tree structure, Updates help Scans [Aspnes, Attiya, Censor-Hillel, and Ellen, PODC 2012] O(log n) steps? Array of views Pointer to array location X 5 2 0 1 4 3 5 s1+...+s4 1 2 0 0 2 3 1 s1+s2 s3+s4 s1 s2 s3 s4

  6. Two Challenges 1. Coping with slow operations. Max-register: returns largest value previously written [Aspnes, Attiya, and Censor-Hillel, JACM 2012] Consecutive values differ by at most n 5 s1+...+s4 s1+s2 s3+s4 s1 s2 s3 s4

  7. Two Challenges 2. Guaranteeing consistent views. Max-array: returns comparable pairs of max-register values [Aspnes, Attiya, Censor-Hillel, and Ellen, PODC 2012] 5 s1+...+s4 s1+s2 s3+s4 s1 s2 s3 s4

  8. Our Results Randomized max-register inO(logn) steps with high probability Randomized 2-component max-array O(log2n) steps whp Randomized snapshot in O(log3n) steps whp Main technique: randomized helping

  9. Max-Register switch = 0 switch = 1 read switch = 0 switch = 0 … … value 0 value 1 value v value v’ … write(v)

  10. Max-Register switch = 0 switch = 1 read switch = 0 switch = 1 switch = 0 … … value 0 value 1 value v value v’ … write(v) write(v’) write(v’’)

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

  12. Randomized Max-Register switch = 0 switch = 1 k-bounded increments:value of write ≤ k + value of largest write switch = 0 switch = 1 … m-valued max register switch = 0 … O(log m + kn/m) = O(log n) steps per write write(v)

  13. Writing to the Max-Register pj(cyclic) 1 TS: read 1 v’ = max(returned value, v) read write(v) pi … HELP: 0 v', ts[j]TS[j] (random) … size n3 POINTER: i write(v)

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

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

  16. MaxArray Implementation Max1 Max1 switch = 0 write1(v) read switch = 0 Max1 Max1 switch = 0 Max1 … … value 0 Max1 value 1 Max1 value v value v’ Max1 Max1 Max1 … write0(v)

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

  18. Summary Randomized snapshot in O(log3n) steps whp Main Technique: Randomized helping Open problems: • Snapshot implementations using single-writer registers • Additional randomized implementations • Randomized lower bounds Thank you! Questions?

More Related