Distributed Systems Principles and Paradigms Chapter 06 (version - PDF document

Distributed Systems Principles and Paradigms Chapter 06 (version April 7, 2008 ) Maarten van Steen Vrije Universiteit Amsterdam, Faculty of Science Dept. Mathematics and Computer Science Room R4.20. Tel: (020) 598 7784 E-mail:steen@cs.vu.nl, URL: www.cs.vu.nl/ ∼ steen/ 01 Introduction 02 Architectures 03 Processes 04 Communication 05 Naming 06 Synchronization 07 Consistency and Replication 08 Fault Tolerance 09 Security 10 Distributed Object-Based Systems 11 Distributed File Systems 12 Distributed Web-Based Systems 13 Distributed Coordination-Based Systems 00 – 1 /

Clock Synchronization • Physical clocks • Logical clocks • Vector clocks 06 – 1 Distributed Algorithms/6.1 Clock Synchronization

Physical Clocks (1/3) Problem: Sometimes we simply need the exact time, not just an ordering. Solution: Universal Coordinated Time (UTC): • Based on the number of transitions per second of the cesium 133 atom (pretty accurate). • At present, the real time is taken as the average of some 50 cesium-clocks around the world. • Introduces a leap second from time to time to compensate that days are getting longer. UTC is broadcast through short wave radio and satel- lite. Satellites can give an accuracy of about ± 0.5 ms. 06 – 2 Distributed Algorithms/6.1 Clock Synchronization

Physical Clocks (2/3) Problem: Suppose we have a distributed system with a UTC-receiver somewhere in it ⇒ we still have to distribute its time to each machine. Basic principle: • Every machine has a timer that generates an in- terrupt H times per second. • There is a clock in machine p that ticks on each timer interrupt. Denote the value of that clock by C p ( t ) , where t is UTC time. • Ideally, we have that for each machine p , C p ( t ) = t , or, in other words, dC / dt = 1 . 06 – 3 Distributed Algorithms/6.1 Clock Synchronization

Physical Clocks (3/3) dC dt > 1 dC Clock time, C dt = 1 k Fast clock c o l c t c dC e f dt < 1 r Slow clock e P UTC, t In practice: 1 − ρ ≤ dC dt ≤ 1 + ρ . Goal: Never let two clocks in any system differ by more than δ time units ⇒ synchronize at least every δ / ( 2 ρ ) seconds. 06 – 4 Distributed Algorithms/6.1 Clock Synchronization

Global Positioning System (1/2) Basic idea: You can get an accurate account of the time as a side-effect of GPS. Principle: Height Point to be� ignored (14,14) r = 16 (-6,6) x r = 10 Problem: Assuming that the clocks of the satellites are accurate and synchronized: • It takes a while before a signal reaches the re- ceiver • The receiver’s clock is definitely out of synch with the satellite 06 – 5 Distributed Algorithms/6.1 Clock Synchronization

Global Positioning System (2/2) • ∆ r is unknown deviation of the receiver’s clock. • x r , y r , z r are unknown coordinates of the receiver. • T i is timestamp on a message from satellite i • ∆ i = ( T now − T i ) + ∆ r is measured delay of the message sent by satellite i . • Measured distance to satellite i : c × ∆ i ( c is speed of light) � ( x i − x r ) 2 + ( y i − y r ) 2 + ( z i − z r ) 2 • Real distance is d i = 4 satellites ⇒ 4 equations in 4 unknowns (with ∆ r as one of them): d i + c ∆ r = c ∆ i 06 – 6 Distributed Algorithms/6.1 Clock Synchronization

Clock Synchronization Principles Principle I: Every machine asks a time server for the accurate time at least once every δ / ( 2 ρ ) seconds ( Network Time Protocol ). Okay, but you need an accurate measure of round trip delay, including interrupt handling and processing in- coming messages. Principle II: Let the time server scan all machines periodically, calculate an average, and inform each machine how it should adjust its time relative to its present time. Okay, you’ll probably get every machine in sync. Note: you don’t even need to propagate UTC time. Fundamental: You’ll have to take into account that setting the time back is never allowed ⇒ smooth ad- justments. 06 – 7 Distributed Algorithms/6.1 Clock Synchronization

The Happened-Before Relationship Problem: We first need to introduce a notion of order- ing before we can order anything. The happened-before relation on the set of events in a distributed system: • If a and b are two events in the same process, and a comes before b , then a → b . • If a is the sending of a message, and b is the re- ceipt of that message, then a → b • If a → b and b → c , then a → c Note: this introduces a partial ordering of events in a system with concurrently operating processes. 06 – 8 Distributed Algorithms/6.2 Logical Clocks

Logical Clocks (1/2) Problem: How do we maintain a global view on the system’s behavior that is consistent with the happened- before relation? Solution: attach a timestamp C ( e ) to each event e , satisfying the following properties: P1: If a and b are two events in the same process, and a → b , then we demand that C ( a ) < C ( b ) . P2: If a corresponds to sending a message m , and b to the receipt of that message, then also C ( a ) < C ( b ) . Problem: How to attach a timestamp to an event when there’s no global clock ⇒ maintain a consistent set of logical clocks, one per process. 06 – 9 Distributed Algorithms/6.2 Logical Clocks

Logical Clocks (2/2) Solution: Each process P i maintains a local counter C i and adjusts this counter according to the following rules: 1: For any two successive events that take place within P i , C i is incremented by 1. 2: Each time a message m is sent by process P i , the message receives a timestamp ts ( m ) = C i . 3: Whenever a message m is received by a process P j , P j adjusts its local counter C j to max { C j , ts ( m ) } ; then executes step 1 before passing m to the ap- plication. Property P1 is satisfied by (1); Property P2 by (2) and (3). Note: it can still occur that two events happen at the same time. Avoid this by breaking ties through pro- cess IDs. 06 – 10 Distributed Algorithms/6.2 Logical Clocks

Logical Clocks – Example P 1 P 2 P 3 P 1 P 2 P 3 0� 0� 0� 0� 0� 0� 6� m 1 8� 10� 6� m 1 8� 10� 12� 16� 20� 12� 16� 20� 18� 24� m 2 30� 18� 24� m 2 30� 24� 32� 40� 24� 32� 40� P adjusts� 30� 40� 50� 30� 40� 50� 2 its clock 36� 48� 60� 36� 48� 60� m 3 m 3 42� 56� 70� 42� 61� 70� 48� 64� 80� 48� 69� 80� m 4 m 4 54� 72� 90� 70� 77� 90� 60 80 100 76 85 100 P adjusts� 1 its clock (a) (b) Note: Adjustments take place in the middleware layer: Application layer Application sends message Message is delivered to application Adjust local clock� Adjust local clock Middleware layer and timestamp message Middleware sends message Message is received Network layer 06 – 11 Distributed Algorithms/6.2 Logical Clocks

Example: Totally Ordered Multicast (1/2) Problem: We sometimes need to guarantee that con- current updates on a replicated database are seen in the same order everywhere: • P 1 adds $100 to an account (initial value: $1000) • P 2 increments account by 1% • There are two replicas Update 1 Update 2 Replicated database Update 1 is Update 2 is performed before performed before update 2 update 1 Result: in absence of proper synchronization: replica #1 ← $1111, while replica #2 ← $1110. 06 – 12 Distributed Algorithms/6.2 Logical Clocks

Example: Totally Ordered Multicast (2/2) Solution: • Process P i sends timestamped message msg i to all others. The message itself is put in a local queue queue i . • Any incoming message at P j is queued in queue j , according to its timestamp, and acknowledged to every other process. P j passes a message msg i to its application if: (1) msg i is at the head of queue j (2) for each process P k , there is a message msg k in queue j with a larger timestamp. Note: We are assuming that communication is reliable and FIFO ordered. 06 – 13 Distributed Algorithms/6.2 Logical Clocks

Vector Clocks (1/2) Observation: Lamport’s clocks do not guarantee that if C ( a ) < C ( b ) that a causally preceded b : P 1 P 2 P 3 0� 0� 0� 6� m 1 8� 10� m 2 12� 16� 20� 18� 24� 30� m 3 24� 32� 40� 30� 40� 50� 36� 48� 60� 42� 61� 70� m 4 48� 69� 80� m 5 70� 77� 90� 76 85 100 Observation: Event a : m 1 is received at T = 16 . Event b : m 2 is sent at T = 20 . We cannot conclude that a causally precedes b . 06 – 14 Distributed Algorithms/6.2 Logical Clocks

Vector Clocks (1/2) Solution: • Each process P i has an array VC i [ 1.. n ] , where VC i [ j ] denotes the number of events that process P i knows have taken place at process P j . • When P i sends a message m , it adds 1 to VC i [ i ] , and sends VC i along with m as vector timestamp vt ( m ) . Result: upon arrival, recipient knows P i ’s timestamp. • When a process P j receives a message m from P i with vector timestamp ts ( m ) , it (1) updates each VC j [ k ] to max { VC j [ k ] , ts ( m )[ k ] } (2) increments VC j [ j ] by 1. Question: What does VC i [ j ] = k mean in terms of messages sent and received? 06 – 15 Distributed Algorithms/6.2 Logical Clocks