Atomic snapshots in o log n steps using randomized helping
This presentation is the property of its rightful owner.
Sponsored Links
1 / 18

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


  • 73 Views
  • Uploaded on
  • Presentation posted in: General

Atomic snapshots in O (log³ n) steps using randomized helping. James Aspnes , Yale Keren Censor-Hillel, Technion. Snapshot Objects. …. update( v ). scan. r ead all locations. update your location. p 1. p 2. p n. …. Model. R 1. R 2. R. …. read. v. write( v ). ok. p 1. p 2.

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Atomic snapshots in o log n steps using randomized helping

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

James Aspnes, Yale

Keren Censor-Hillel, Technion


Snapshot objects

Snapshot Objects

update(v)

scan

read all locations

update your location

p1

p2

pn


Model

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


Snapshots step complexity

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)


Tree structure updates help scans

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


Two challenges

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


Two challenges1

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


Our results

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


Max register

Max-Register

switch = 0

switch = 1

read

switch = 0

switch = 0

value 0

value 1

value v

value v’

write(v)


Max register1

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’’)


Randomized max register

Randomized Max-Register

switch = 0

switch = 1

switch = 0

switch = 1

m-valued max register

switch = 0

write(v)


Randomized max register1

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)


Writing to the max register

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)


Reading the max register

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


2 component max array

2-Component Max Array

write1(v)

write0(v)

update second max-register

update first max-register

read

read both max-registers


Max array implementation

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)


Randomized 2 component max array

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)


Summary

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?


  • Login