Global states
Download
1 / 17

Global States - PowerPoint PPT Presentation


  • 69 Views
  • Uploaded on

Global States. Algorithms to Find Global States. Why? (Distributed) garbage collection (Distributed) deadlock detection, termination [think database transactions] What? Capture the instantaneous states of a collection of processes

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Global States' - isadora-cooley


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

Algorithms to find global states
Algorithms to Find Global States

  • Why?

    • (Distributed) garbage collection

    • (Distributed) deadlock detection, termination [think database transactions]

  • What?

    • Capture the instantaneous states of a collection of processes

    • And the messages in transit on different communication channels

  • How?

    • We’ll see this lecture!





Obvious first solution
Obvious First Solution…

  • Synchronize clocks of all processes (which algorithm?)

  • Ask all processes to record their states at known time t

  • Problems?

    • Time synchronization possible only approximately (but distributed banking applications cannot take approximations)

    • Does not record the state of messages in the channels

  • Again: synchronization not required – causality is enough!


Process histories and states
Process Histories and States

  • For a process Pi,

    history(Pi) = hi = <ei0, ei1, … >

    prefix history(Pik) = hik = <ei0, ei1, …,eik >

    Sik : Pi ‘s state immediately before kth event

  • For a set of processes,

    global history:H = i (hi)

    global state:S = i (Siki)

    a cut C  H = h1c1 h2c2 …  hncn

    the frontier of C = {eici, i = 1,2, … n}


Consistent states

Consistent cut

Inconsistent cut

Consistent States

  • A cut C is consistent if

    e  C(if f  e then f  C)

  • A global state S is consistent if

    it corresponds to a consistent cut

e12

e10

e11

e13

P1

e21

P2

e22

e20

P3

e31

e30

e32


Global states1
Global States

  • ARunis a total ordering of events in H that is consistent with each hi’s ordering

  • A Linearization is a run consistent with happens-before () relation in H.

  • Linearizations pass through consistent global states.

  • A global state Sk is reachable from global state Si, if there is a linearization, L, that passes through Si and then through Sk.

  • A DS evolves as a series of transitions between global states S0 ,S1 , ….


Global state predicates
Global State Predicates

  • Aglobal-state-predicateis a function from the set of global states to {true, false} , e.g. deadlock, termination

  • If P is a global-state predicate of reaching termination, then

    liveness(P(S0))   L linearizations from S0 ,SL :L passes through SL & P(SL) = true

  • A stable global-state-predicateis one that once it becomes true, it remains true in subsequent global states, e.g. deadlock

  • if P is a global-state-predicate of being deadlocked, then

    safety(P(S0)) S reachable from S0, P(S) = false

  • We need a way to record global states


The snapshot algorithm
The “Snapshot” Algorithm

  • Records a set of process and channel states such that the combination is a consistent GS.

  • Assumptions:

    • No failure, all messages arrive intact, exactly once

    • Communication channels are unidirectional and FIFO-ordered

    • There is a comm. path between any two processes

    • Any process may initiate the snapshot (sends Marker)

    • Snapshot does not interfere with normal execution

    • Each process records its state and the state of its incoming channels (no central collection)


The snapshot algorithm 2
The “Snapshot” Algorithm (2)

1. Marker sending rule for initiator process P0

  • After P0 has recorded its state

    • for each outgoing channel C, send a marker on C

      2. Marker receiving rule for a process Pk

      on receipt of a marker over channel C

  • ifPk has not yet recorded its state

    • record Pk’s state

    • record the state of C as “empty”

    • turn on recording of messages over other incoming channels

    • for each outgoing channel C, send a marker on C

  • else

    • record the state of C as all the messages received over C since Pk saved its state


Chandy and lamport s snapshot algorithm
Chandy and Lamport’s ‘Snapshot’ Algorithm

  • Marker receiving rule for process pi

    • On pi’s receipt of a marker message over channel c:

    • if (pi has not yet recorded its state) it

      • records its process state now;

      • records the state of c as the empty set;

      • turns on recording of messages arriving over other incoming channels;

    • else

      • pi records the state of c as the set of messages it has received over c

      • since it saved its state.

    • end if

  • Marker sending rule for process pi

    • After pi has recorded its state, for each outgoing channel c:

    • pi sends one marker message over c

    • (before it sends any other message over c).


Snapshot example

e11,2

e14

M

M

e25

M

M

e21,2,3

M

M

e34

e31,2,3

1- P1 initiates snapshot: records its state (S1); sends Markers to P2 & P3; turns on recording for channels C21 and C31

2- P2 receives Marker over C12, records its state (S2), sets state(C12) = {} sends Marker to P1 & P3; turns on recording for channel C32

3- P1 receives Marker over C21, sets state(C21) = {a}

4- P3 receives Marker over C13, records its state (S3), sets state(C13) = {} sends Marker to P1 & P2; turns on recording for channel C23

5- P2 receives Marker over C32, sets state(C32) = {b}

6- P3 receives Marker over C23, sets state(C23) = {}

Snapshot Example

e10

e13

P1

a

e24

P2

e20

b

P3

e30


Reachability between states in snapshot algorithm
Reachability Between States in Snapshot Algorithm

  • Let ei and ej be events occurring at pi and pj, respectively such that ei ej

  • the snapshot algorithm ensures that

  • if ej is in the cut then ei is also in the cut.

  • if ej occurred before pj recorded its state, then ei must have occurred before

  • pi recorded its state.


Causality violation

Include(obj1)

obj1.method()

P2 has obj1

Causality Violation

Physical Time

1

2

P1

0

1

P2

0

5

6

2

4

P3

0

4

3

  • Causality violation occurs when order of messages causes an action based on information that another host has not yet received.

  • In designing a DS, potential for causality violation is important


Detecting causality violation

Violation: (1,0,0) < (2,1,2)

Detecting Causality Violation

Physical Time

1,0,0

2,0,0

0,0,0

P1

(1,0,0)

P2

0,0,0

2,1,2

2,2,2

(2,0,0)

(2,0,2)

P3

0,0,0

2,0,2

2,0,1

  • Potential causality violation can be detected by vector timestamps.

  • If the vector timestamp of a message is less than the local vector timestamp, on arrival, there is a potential causality violation.


ad