Distributed Systems

Synchronization

1
Synchronization
•An important issue in distributed system is how processes cooperate
and synchronize with one another
– Cooperation is partially supported by naming, which allow them to share
resources
• Example of synchronization
– Access to shared resources
– Agreement on the ordering of events
• Will discuss
– Synchronization based on actual time
– Synchronization based on relative orders
– Algorithms for election of synchronization coordinators

2
Clock Synchronization
• When each machine has its own clock, an event that
occurred after another event may nevertheless be
assigned an earlier time

3
Physical Clock
• All computers have a circuit to keep track of time using a
quartz crystal
• However, quartz crystals at different computers often run at
a slightly different speed
– This leads to the so called clock skew between different machines
• Some systems (e.g., real-time systems) need external
physical clock
– Solar day: inter val between two consecutive noons
• Solar day varies due to many reasons

– International atomic time (TAI): transitions of cesium 133 atom

• Cannot be directly used as everyday clock. TAI second < Solar second

– Solution: leap second whenever the difference is 800msec -> UTC

4
Global Positioning System
• Used to locate a physical point on earth
• Need at least 3 satellites to measure:
– Longitude, Latitude, and Altitude (height)
• Example: computing a position in a 2D space

5
GPS Challenges
• Clock skew complicates the GPS localization
– The receiver’s clock is generally not well synchronized
with that of a satellite
– E.g. 1 sec of clock offset could lead to 300,000 kilometers error in
distance estimation
• Other source of errors
– The position of satellite is not known precisely
– The receivers clock has a finite accuracy
– The signal propagation speed is not constant
– Earth is not a perfect sphere - need further correction

6
Clock Synchronization Algorithms
• The goal of synchronization is to
– keep all machines synchronized to an external reference clock, or
– just keep all machines together as well as possible

• The relation between clock time and UTC when clocks tick at
different rates

7
Network Time Protocol (NTP)
• Pairwise clock synchronization
– e.g., a client synchronize its clock with a ser ver

What is the clock offset?

8
The Berkeley Algorithm
• Goal: just keep all machine together
• Steps
– The time daemon tell all machines its time
– Other machines answer how far ahead or behind
– The time daemon computes the average and tell other how to adjust

9
Clock Sync. in Wireless Networks
• In traditional distributed systems, we can deploy
many time ser vers
– that can easily contact each other for efficient
information dissemination
• However, in wireless networks, communication
becomes expensive and unreliable
• RBS (Reference Broadcast Synchronization) is a
clock synchronization protocol
– where a sender broadcasts a reference message that
will allow its receivers to adjust their clocks

10
Reference Broadcast Synchronization

• To estimate the mutual, relative clock offset, two nodes

– exchange the time when they receive the same broadcast
– the difference is the offset in one broadcast
– The average of M offsets is then used as the result
• However, offset increases over time due to clock skew (how to overcome?)

11
Logical Clocks
• In many applications, what matters is not the real time
– It is the order of the events

• For the algorithms that synchronize the order of events,

the clocks are often refereed to as logical clocks
• Example: Lamport’s logical clock, which defines the
“happen-before” relation
– If a and b are events in the same process, and a occurs
before b, then a → b is true.

– If a is the event of a message being sent by one process, and

b is the event of the message being received by another
process, then a → b

12
Lamport’s Logical Clocks

Three processes, each with

its own clock. The clocks Lamport’s algorithm corrects
run at different rates. the clock

13
Lamport’s Algorithm
• Each process Pi maintains a counter Ci
1. Before executing an event P executes C ← C + 1.
i i i

2. When process P sends a message m to P , it sets m’s timestamp ts (m) equal to C

i j i
after having executed the previous step.
3. Upon the receipt of a message m, process P adjusts its own local counter as C
j j
← max{C , ts (m)}, after which it then executes the first step and delivers the
j
message to the application.

14
Application of Lamport’s Algorithm
Updating a replicated database and
leaving it in an inconsistent state.

15
Totally Ordered Multicasting
• Apply Lamport’s algorithm
– Every message is timestamped and the local counter is adjusted
according to every message
• Each update triggers a multicast to all ser vers
• Each ser ver multicasts an acknowledgement for every
received update request
• Pass the message to the application only when
– the message is at the head of the queue
– all acknowledgements of this message has been received
• The above steps guarantees that the messages are in the
same order at every ser ver, assuming
– message transmission is reliable
16
Problem with Lamport’s Algorithm
• Lamport’s algorithm guarantees that
– if event a happened before event b, then we have C(a)<C(b)
• However, this does not mean that
– C(a)<C(b) implies event a happened before event b

17
Vector Clocks (1)
• Vector clocks are constructed by letting each
process Pi maintain a vector VCi with the

following two properties:

1. VCi [ i ] is the number of events that have
occurred so far at Pi.
• VCi [ i ] is the local logical clock at process Pi .
2. If VCi [ j ] = k then Pi knows that k events have
occurred at Pj.
• It is thus Pi’s knowledge of the local time at Pj .

18
Vector Clocks (2)
• Steps carried out to accomplish the property 2
of previous slide
– Before executing an event Pi executes VCi[i]←VCi[i]+1

– When process Pi sends a message m to Pj, it sets m’s

(vector) timestamp ts(m) equal to VCi after having
executed the previous step.
– Upon the receipt of a message m, process Pj adjusts
its own vector by setting VCj[k]←max{VCj[k], ts(m[k]}

for each k, after which it executes the first step and

delivers the message to the application.
19
Vector Clocks (Casual Communications)

18
Mutual Exclusion
• Concurrent access may corrupt the resource or make it
inconsistent
• Token-based approach for mutual exclusion
– only 1 token is passed around in the system
– Process can only access when it has the token
– Easy to avoid star vation and deadlock
– However, situation becomes complicated if token is lost

• Permission-based approach for mutual exclusion

– A process has to get permission before accessing a resource
– Grant permission to only one process at any time

20
A Centralized Algorithm
•

Three steps:
(a) Process 1 asks the coordinator for resource. Permission is granted
(b) Process 2 asks the coordinator for resource. The coordinator does not reply
(c) When process 1 releases the resource, it notifies the coordinator. The
coordinator then grants permission to process 2

• Easy to implement, but has the single point of failure problem

21
A Decentralized Algorithm

Whenever a process wants to access the resource, it will simply need to get a
majority vote from m > n/2 coordinators.

Voting System

21
A Distributed Algorithm
• When a process wants to access a shared resource, it builds a
messages containing:
– Name of the resource, Its process number, and the current time

• Then, sends the message to all other processes, even to itself

• Three different cases
– If the receiver (of a message) is not accessing the resource and does not
want to access it, it sends back an OK message to the sender.
– If the receiver already has access to the resource, it simply does not
reply. Instead, it queues the request.
– If the receiver wants to access the resource as well but has not yet done
so, it compares the timestamp of the incoming message with the one
contained in the message that it has sent everyone. The lowest one wins.

• When a process receives OK from all other processes, it starts access

22
An Example

(a) Two processes want to access a shared resource at the same moment
(b) Process 0 has the lowest timestamp, so it wins.
(c) When process 0 is done, it sends an OK also, so 2 can now go ahead.

23
Problems in the Distributed Algorithm
• Any process fails, the algorithm fail
– worse than the centralized algorithm

• Each process has to maintain a list of all other processes

– process addition, leaving, and crashing

• Every process needs to do the same amount of work as

the coordinator in the centralized algorithm
• Improvements
– A majority voting, e.g., as long as you get more than half
votes, you can access the resource
• The algorithm is still slow, expensive, and not robust
– Distributed algorithms are not always the best option
24
A Token Ring Algorithm
• When a ring is initialized, process 0 is given a token.
– Token is passed from k to k+1 (modulo the ring size) in a point-
to-point message.
– Ordering is logical, usually based on the process number or
other means
• When a process acquires the token from its neighbor, it
checks to see if needs to access the shared resource.
– If yes, go ahead with the resource, and then release the
resource and pass the token when it finishes
– If not, pass the token immediately to the next one
• Each process only needs to know who is next inline
• Problem: if the token is lost, it is hard to detect
25
Election Algorithms

• The main objective

– select one process as the coordinator to
perform some special roles such as
synchronization
• Examples of election algorithms
– The bully algorithm
– the ring algorithm
– Election algorithms for wireless networks
26
The Bully Algorithm
• Assume every process knows the process numbers of
all other processes
– But do not know which ones are dead or alive

• When any process, P, notices the coordinator is no

longer responding to requests, it initiates an election.
– P sends an ELECTION message to all processes with
higher numbers.
– If no one responds, process P wins the election and
becomes the coordinator.
– If one of the processes with higher numbers answers, it
takes over. Process P’s job is done.
27
An Example (1)

The bully election algorithm. (a) Process 4 holds an

election. (b) Processes 5 and 6 respond, telling 4 to stop.
(c) Now 5 and 6 each hold an election.

28
An Example (2)
The bully election algorithm. (d) Process 6 tells 5 to
stop. (e) Process 6 wins and tells everyone.

29
The Ring Algorithm
• No token is used in the algorithm
• Every process knows the ring structure
– i.e., how processes are arranged

• Whenever a process notices that the coordinator is not

functioning
– It builds an ELECTION message, add its process number in it, and
pass it to the next alive process one in the ring
– Whoever receives the election message will add its process number in
it and pass it to the next alive process
• Eventually, the message will circuit back to the original process
that initiated the ELECTION message
– This process will converts it to a COORDINATOR message and notify
other processes that the one with the highest number in the list wins
30
An Example
Election algorithm using a ring when two nodes initiated the
ELECTION at the same time

31
Election in Wireless Networks
• Bully or Ring algorithms are not realistic in wireless
environments since
– they assume message passing is reliable which is not true in
wireless environments

• Our goal is to select the best node as the coordinator (or

leader) not just any node
– e.g. best capacity based on remaining battery

• To elect a leader, any node, called source, can initiate an

election by sending an ELECTION message to its neighbors
– A tree is build during the propagation of this election message
– The best eligible node is passed from leafs to root

32
An Example (1)

Election algorithm in a wireless network, with node a as the

source. (a) Initial network. (b)–(e) The build-tree phase

33
A n Example (2)
Election algorithm in a wireless network, with node a as the
source. (a) Initial network. (b)–(e) The build-tree phase

34
A n Example (3)
Election algorithm in a wireless network, with node a as the
source. (a) Initial network. (b)–(e) The build-tree phase

35