CSS434 Time and Global States

Slides:



Advertisements
Similar presentations
Time, Clocks, and the Ordering of Events in a Distributed System
Advertisements

Virtual Time Virtual Time and Global States of Distributed Systems Friedmann Mattern, 1989 The Model: An asynchronous distributed system = a set of processes.
Distributed Snapshots: Non-blocking checkpoint coordination protocol Next: Uncoordinated Chkpnt.
Global States.
Dan Deng 10/30/11 Ordering and Consistent Cuts 1.
From Coulouris, Dollimore, Kindberg and Blair Distributed Systems: Concepts and Design Edition 5, © Addison-Wesley 2012 Slides for Chapter 14: Time and.
Distributed Computing 5. Snapshot Shmuel Zaks ©
Synchronization.
Virtual Time “Virtual Time and Global States of Distributed Systems” Friedmann Mattern, 1989 The Model: An asynchronous distributed system = a set of processes.
Lecture 8: Asynchronous Network Algorithms
Parallel and Distributed Simulation Global Virtual Time - Part 2.
Parallel and Distributed Simulation Time Warp: Basic Algorithm.
Time and Global States Part 3 ECEN5053 Software Engineering of Distributed Systems University of Colorado, Boulder.
Synchronization Chapter clock synchronization * 5.2 logical clocks * 5.3 global state * 5.4 election algorithm * 5.5 mutual exclusion * 5.6 distributed.
CS542 Topics in Distributed Systems Diganta Goswami.
Termination Detection. Goal Study the development of a protocol for termination detection with the help of invariants.
CS 582 / CMPE 481 Distributed Systems
Causality & Global States. P1 P2 P Physical Time 4 6 Include(obj1 ) obj1.method() P2 has obj1 Causality violation occurs when order.
Ordering and Consistent Cuts Presented By Biswanath Panda.
CMPT 431 Dr. Alexandra Fedorova Lecture VIII: Time And Global Clocks.
Distributed Systems Fall 2009 Logical time, global states, and debugging.
Slides for Chapter 10: Time and Global State
Time and Global States Chapter 11. Why time? Time is an Important and interesting issue in distributes systems. One we can measure accurately. Can use.
20101 Synchronization in distributed systems A collection of independent computers that appears to its users as a single coherent system.
Ordering and Consistent Cuts Presented by Chi H. Ho.
EEC-681/781 Distributed Computing Systems Lecture 11 Wenbing Zhao Cleveland State University.
Clock Synchronization and algorithm
1 Distributed Process Management: Distributed Global States and Distributed Mutual Exclusion.
Computer Science Lecture 10, page 1 CS677: Distributed OS Last Class: Clock Synchronization Physical clocks Clock synchronization algorithms –Cristian’s.
Time Warp OS1 Time Warp Operating System Presenter: Munehiro Fukuda.
Chapter 5.
CIS 720 Distributed algorithms. “Paint on the forehead” problem Each of you can see other’s forehead but not your own. I announce “some of you have paint.
1 Distributed Systems CS 425 / CSE 424 / ECE 428 Global Snapshots Reading: Sections 11.5 (4 th ed), 14.5 (5 th ed)  2010, I. Gupta, K. Nahrtstedt, S.
© Oxford University Press 2011 DISTRIBUTED COMPUTING Sunita Mahajan Sunita Mahajan, Principal, Institute of Computer Science, MET League of Colleges, Mumbai.
1 Consistent Global States of Distributed Systems: Fundamental Concepts and Mechanisms Author: Ozalp Babaoglu and Keith Marzullo Distributed Systems: 526.
Computer Science Lecture 10, page 1 CS677: Distributed OS Last Class: Naming Name distribution: use hierarchies DNS X.500 and LDAP.
Lecture 6-1 Computer Science 425 Distributed Systems CS 425 / ECE 428 Fall 2013 Indranil Gupta (Indy) September 12, 2013 Lecture 6 Global Snapshots Reading:
Winter, 2004CSS490 Synchronization1 Textbook Ch6 Instructor: Munehiro Fukuda These slides were compiled from the textbook, the reference books, and the.
“Virtual Time and Global States of Distributed Systems”
Distributed Systems Fall 2010 Logical time, global states, and debugging.
CSE 486/586, Spring 2013 CSE 486/586 Distributed Systems Global States Steve Ko Computer Sciences and Engineering University at Buffalo.
Time This powerpoint presentation has been adapted from: 1) sApr20.ppt.
Tanenbaum & Van Steen, Distributed Systems: Principles and Paradigms, 2e, (c) 2007 Prentice-Hall, Inc. All rights reserved DISTRIBUTED SYSTEMS.
Real-Time & MultiMedia Lab Synchronization Distributed System Jin-Seung,KIM.
CSE 486/586 CSE 486/586 Distributed Systems Global States Steve Ko Computer Sciences and Engineering University at Buffalo.
1 Chapter 11 Global Properties (Distributed Termination)
Hwajung Lee. -- How many messages are in transit on the internet? --What is the global state of a distributed system of N processes? How do we compute.
Efficient Algorithms for Distributed Snapshots and Global Virtual Time Approximation Author: Friedermann Mattern Presented By: Shruthi Koundinya.
Distributed Systems Lecture 6 Global states and snapshots 1.
Distributed Web Systems Time and Global State Lecturer Department University.
PDES Introduction The Time Warp Mechanism
Global state and snapshot
Global state and snapshot
Time and Global States Ali Fanian Isfahan University of Technology
CSE 486/586 Distributed Systems Global States
PDES: Time Warp Mechanism Computing Global Virtual Time
Distributed Snapshots & Termination detection
EECS 498 Introduction to Distributed Systems Fall 2017
湖南大学-信息科学与工程学院-计算机与科学系
Time And Global Clocks CMPT 431.
Parallel and Distributed Simulation
Distributed Snapshot Distributed Systems.
Chapter 5 (through section 5.4)
Slides for Chapter 11: Time and Global State
Chap 5 Distributed Coordination
CSE 486/586 Distributed Systems Global States
Jenhui Chen Office number:
Distributed algorithms
CIS825 Lecture 5 1.
Slides for Chapter 14: Time and Global States
Presentation transcript:

CSS434 Time and Global States Textbook Ch11 Professor: Munehiro Fukuda CSS434 Time & Global States

CSS434 Time & Global States Outline Physical clock synchronization Applications: make Logical clock synchronization Parallel and distributed simulation Global states and consistent cuts Distributed garbage collection, deadlock detection, distributed termination detection, and discrete-even simulation Distributed debugging Checking if a captured snapshot is one of transitory states we have considered. CSS434 Time & Global States

Why Clock Synchronization Computer clock: a counter decremented by a crystal oscillation. Single computers: all processes use the same clock. – No problem Multiple computers: impossible to guarantee that the crystals in different computers all run at exactly the same frequency. Synchronization: Absolute (with real time) Necessary for real-time applications such as on-line reservation systems Relative (with each other) Required for those applications that need a consistent view of time across all nodes. CSS434 Time & Global States

CSS434 Time & Global States Clock Synchronization Passive Centralized Algorithms – Christian’s Algorithm T0 T1 Client Time? Time=T Time server Processing Time Assumption: processing time has been measured or estimated Message_delay = (T1 – T0 – processing)/2 New client time = T + message_delay Improvements: Average multiple measurements Discard outlying measurements CSS434 Time & Global States

CSS434 Time & Global States Clock Synchronization Active Centralized Algorithm – Berkeley Algorithm Time server Time? Diff(1) C1_time Client 1 Time? C2_time Diff(2) Client 2 Assumption: processing time has been measured or estimated Server: diff(i) = server_time – (ci_time + message_deley) Client: ci_time = ci_time + diff(i) CSS434 Time & Global States

Clock Synchronization Distributed Algorithm – Averaging Algorithm Node 1 N1_time=31 N2_time=32 N3_time=30 Node 2 N1_time=31 N3_time=30 N2_time=32 Node 3 Assumption: R is large enough to wait for all broadcast messages All nodes broadcast their time periodically Each node computes average. Improvement: Discard outlying time messages. Exchange their time with their local neighbors. CSS434 Time & Global States

Clock Synchronization Network Time Protocol UTC (Coordinated Universal Time) 1 2 3 Note: Arrows denote synchronization control, numbers denote strata. UDP message CSS434 Time & Global States

Clock Synchronization Network Time Protocol -2 - 3 Server B Server A Time m m' o t’ t Ti-2 = Ti-3 + t + o Ti = Ti-1 + t’ - o di = t + t’ = Ti-2 – Ti-3 + Ti – Ti-1 2o = Ti-2 – Ti-3 – t + Ti-1 – Ti + t’ o = (Ti-2 – Ti-3 + Ti-1 – Ti)/2 + (t’ – t)/2 CSS434 Time & Global States

Event Ordering Happened-Before Relation Most applications need not maintain the real-time synchronized clock. Event eki: The kth event of process i Sequence hki: The history of process I through to the event eki Cause-and-effect e→e’: e proceeds e’. Parallel events e∥e’: e and e’ happen in parallel Happens-Before Relation: If eki, eli ∈hi and k < l, then eki → eli, If ei = send(m) and ej = receive(m), then ei → ej, If e → e’ and e’ → e”, then e → e” CSS434 Time & Global States

Event Ordering Logical Clock LC(ei) := (ei != receive(m)) ? LC + 1 : max(LC, TS(m)) + 1 where TS(m) is the timestamp of message m: P1 P2 P3 e11 e21 e12 e22 e13 e23 LC=1 LC=2 LC=3 LC=4 LC=5 m1 ee’ LC(e) < LC(e’) for all events However, we cannot inferLC(e) < LC(e’)  ee’ Example: LC(e21) > LC(e13) but e21 || e13 CSS434 Time & Global States

Event Ordering Vector Clock Vi[I] = vi[i] + 1; Pi includes the value t = Vi in every message it sends Vi[j] = max(vi[j], t[j]) for j = 1,2,…,N P1 P2 P3 e11 e21 e12 e22 e13 e23 m1 (1,0,0) (2,0,0) (2,1,0) (2,2,0) (0,0,1) (2,2,2) ee’ V(e) < V(e’) V(e) < V(e’)  ee’ Example:neither V(e21)  V(e13) nor V(e21)  V(e13), and thus e21 || e13 CSS434 Time & Global States

Global State Applications necessary to detect a correct global state This is not a garbage, because the in-transit message points to it Both p1 and p2 are passive and thus seems ready to finish, but an in-transit message makes p1 active again. CSS434 Time & Global States

Global State Consistent Cut Finding C such that (e ∈ C) ∧(e’ → e) ⇒ e’ ∈ C p1 p2 p3 p4 e11 e13 e12 e22 e32 e21 e23 e14 e24 e34 C C’ (send) (receive) CSS434 Time & Global States

Global State Distributed Snapshot – Chandy/Lamport [1985] Snapshot request Message recording P1 s s s Ordinary message P2 P1 P2 s m m m s A process that wants to take a snapshot sends a snapshot request to the others. Each process records its state upon receiving the first snapshot request. Each process keep recording the messages until receiving a snapshot request from each of the other process except the one that has originally initiated a snapshot. CSS434 Time & Global States

Global State Distributed Snapshot – Chandy/Lamport [1985] Marker (Snapshot request) receiving rule for process pi On pi’s receipt of a marker (snapshot request) 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 (Snapshot request) 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). CSS434 Time & Global States

A Distributed Snapshot Example Start recording its state Consistent Cut Record its state Stop recording M Time line CSS434 Time & Global States

CSS434 Time & Global States Samadi’s Algorithm [1985] Each process returns an ack whenever receiving a message. Once receiving a snapshot message, each process returns a tag instead of an ack until a new GVT is compute. When receiving a snapshot message, each process returns to P0 the minimum time among: - the minimum timestamp among events that have not yet been processes. - the minimum timestamp among messages that have not yet been acknowledged. - the minimum timestamp among tags it has received. Take snapshot Report 12 Report 20 Report 15 p0 Done p1 12 16 p2 20 tag ack 20 p3 15 CSS434 Time & Global States

Mattern’s Algorithm [1993] Process Pi maintains a vector counter: Vi[1..n]. Pi writes in Vi[j] the number of messages sent to Pj. Pi subtract one from Vi[j] when receiving a message from Pj During the 1st circulation of a ‘take snapshot’ message, Pi performs: C[1..n]+=Vi[1..n]; Vi[1..n] = 0 Upon completing the 1st circulation, c[I] presents the number of messages in transit to Pi. During the 2nd circulation, Pi wait for performs: C[i] = 0 p2 p1 p3 p4 (0,0,0,0) (0,1,0,0) (0,2,-1,0) (0,0,0,1) (0,0,1,1) (0,0,1,0) 1st snapshot 2nd snapshot +1 -1 +1 -1 +1 -1 +1 -1 +1 -1 CSS434 Time & Global States

An Example: Parallel and Distributed Simulation Process 0 Process 1 1cell/time unit 1cell/5 time units Process 3 Process 2 1cell/20 time units CSS434 Time & Global States

An Example: Parallel and Distributed Simulation (Cont’d) Barrier per every simulation cycle Process 0 e1 e2 e3 e4 What drawbacks does this method have? attack Process 1 e5 e6 e7 e1 attack Process 2 e1 e8 e9 e10 e11 e12 Process 3 CSS434 Time & Global States

An Example: Parallel and Distributed Simulation (Cont’d) Discrete event simulation with optimistic synchronization Old event history kept so as to rollback computation. Process 0 e1 e2 e3 e4 When can we garbage collect such history? attack Process 1 e5 e6 e7 e1 e2 e3 Rollback attack Process 2 e1 e8 e9 e10 e11 e12 Rollback Process 3 e13 e14 CSS434 Time & Global States

CSS434 Time & Global States Time Warp[Jefferson 1985] Optimistic Distributed Simulation Each process has an input message, an output message, and an event history queue. When a process receives a message whose timestamp is older than its local time:   1.Roll back its local event execution to that old timestamp.   2.Roll back its receipt of input messages whose timestamp is newer than that old timestamp. 3.Send anti-messages to cancel all emanated messages whose timestamp is newer than that old timestamp. GVT (Global Virtual Time): is periodically computed to garbage-collect all the executed events whose timestamp is older than GVT. 152 p2 p1 p3 163 142 143 162 141 120 122 121 Arrived late 135 Rollback Anti-message LVT CSS434 Time & Global States

SPEEDS[Steinman 1992] Breathing Time Buckets This is an optimistic distributed simulator, but so aggressive as Time Warp. Each process broadcasts the oldest local even among those it will execute. This is called a Local Event Horizon (LEH). A process must suspend its even processing if it has received an older LEH than the one it is currently processing. The oldest LEH among all processes become the next Global Event Horizon (GEH). Each process may send out all messages and process all events before this new GEH. Processes which have already processed beyond GEH must roll back their computation to GEH. No anti-messages are sent out. P1’s LEH p1 p2 Next GEH (GVT) P2’s LEH CSS434 Time & Global States

Vector timestamps and variable values for the execution Constraints |x1 – x2| <= 50. Before this is violated, a process must send its value to its partner. CSS434 Time & Global States

The lattice of global states for the execution CSS434 Time & Global States

Evaluating possibly and definitely f Possibility Must be True, and thud we don’t care F Definitely = T for all linialization (4,3) = T and this is definitely All included: (2,2) = True CSS434 Time & Global States

Paper Review by Students Distributed Snapshot Samadi’s Algorithm Mattern’s Algorithm Discussions: What are pros & cons of these algorithms? Optimistic Synchronization SPEEDS Time Warp Discussions: What are pros & cons of these algorithms in terms of performance, process creation/termination, dynamic memory allocation, and I/O handling? CSS434 Time & Global States

Exercises (No turn-in) Textbook p627, Q14.7: An NTP server B receives server A’s message at 16:34:23.480 bearing a timestamp 16:34:13.430 and replies to it. A receives the message at 16:34:15.725, bearing B’s timestamp 16:34:25.7. Estimate the offset between B and A and the accuracy of the estimate. Textbook p628, Q14.14: Two processes P and Q are connected in a ring using two channels, and they constantly rotate a message m. At any one time, there is only one copy of m in the system. Each process’s state consists of the number of times its has received m, and P sends m first. At a certain point, P has the message and its state is 101. Immediately after sending m, P initiates the snapshot algorithm. Explain the operation of the algorithm in this case, given the possible global state(s) reported by it. Textbook p429, Q14.15: The figure below shows events occurring for each of two processes, p1 and p2. Arrows between processes denote message transmission. Draw and label the lattice of consistent states (p1 state, p2 state), beginning with the initial state (0,0). p1 time p2 CSS434 Time & Global States