Synchronization

Instructor: Dr. Nayef Saleh
Student: Sara Shall
*

*
• Logical Clocks
• Physical Clocks
• Clock Synchronization Algorithms
• Use Of Synchronized Clocks
• Mutual Exclusion
• Election Algorithms
• Atomic Transactions
• Deadlocks in Distributed Operating System

*
• Logical clocks is concerned about “what event happened before?”
• The expression a b is read “ a happens before b”.
• The happens-before relation can be observed in two situations:
- If a and b are in the same process, and a occurs before b.
- If a is the events of a message being sent by one process, and b is
The event of the message being received by another process.
- If a and b are two events within the same process and a occurs
before b then C(a) < C(b).

*
• We have additional requirements: no two events ever occur at
exactly the same time.
• If events happened in processes 1 and 2, both with time 40, the
former becomes 40.1 and the latter becomes 40.2.
• Then, using this method we can assign time in distributed
operating system:
a) If a happens before b in the same process, C(a) < C(b).
b) If a and b represent the sending and receiving of a message, C(a)
< C(b).
c) For all events a and b, C(b) != C(b).

*
• In some systems, the actual clock time is important.
• Radio receivers for WWV, GEOS, and the other UTC sources are
available and can provide accurate clock time.
• They require accurate knowledge of the relevant position of the
sender and receiver.
• Coordinated Universal Time(UTC): It is based on an atomic clock
to which adjustments of a second (called a leap second) are
sometimes made to allow for variations in the solar cycle.

*
• If one machine has a WWV receiver, the goal becomes keeping all
the other machines synchronize to it.
• If no machines have WWV receivers, each machine keeps track of
its own time.
• It is impossible to guarantee that
the crystals in different computer all
run at exactly the same frequency. So,
A particular machine can get a value in
the range 215,998 and 216,002 ticks
Per hour.

*
• Christian's Algorithm:
• This algorithm is suited to systems I which one machine has a
WWV receiver and the goal is to have all other machines stay
synchronized to it.

• The Berkeley Algorithm:
• This method is suitable for a system in which no machine has a
WWV receiver.
• The time her is coordinated by Time daemon.
*

*
• At-Most-Once Message Delivery:
1. Every message carry a connection identifier and timestamp.
2. For each connection the server record in a table the most recent
timestamp it has seen.
3. If any incoming message for a connection is lower than the
timestamp stored for that connection the message is rejected as
a duplicate.
4. To remove old timestamps, each server maintains a global
variable:
G= CurrentTime – MaxLifetime – MaxClockSkew
• G is a summary of the message numbers of all old messages.
• ∆𝑇 is the current time is written to the disk.

*
• Clock-Based Cache Consistency:
• Caching introduces potential inconsistency if two clients modify
the same file at the same time.
• The usual solution is to distinguish between caching a file for
reading and caching a file for writing.
• Another idea is when a client wants a file, it is given a lease on it
with specified period of time.
• This lease can be renewed when it expired.
• If one or more clients have a file cached for reading and then
another client wants to write on the file, the server has to ask
the readers to prematurely terminate their leases.
• If one or more of them has crashed, the server can just wait until
the dead server's lease times out.

*
• A Centralized Algorithm:

*
• A Distributed Algorithm:

*
• A Comparison Of The Three Algorithms:

*
• The task of election algorithms is to elect which process will be
the coordinator.
• The goal of an election algorithm is to ensure that when an
election starts, it concludes that all processes agreeing on who
the new coordinator is to be.

*
• The Bully Algorithm:
• When a process notices that the coordinator in no longer
responding to requests, it initiates an election as follows:
1. P sends an ELECTION message to all processes with higher
numbers.
2. If no one responds, P wins the election and becomes coordinator.
3. If one of the higher-ups answers, it takes over. P’s job is done.
*if a process that was previously down comes back up, it holds an
election. If it happens to be the highest-numbered process currently
running, it will win the election and take over the coordinator’s job.

*
• A Ring Algorithm:
• It is base on a ring but without a token.
• The processes are physically or logically ordered and each process
knows who its successor.
• When any process notices that the coordinator is not functioning, it
build an ELECTION message containing its own process number and
sends it to its successor.
• This message will circulate over the ring and pass process that is not
responsive.
• At each step the sender adds it own process number to the list in the
message.
• When the message arrive to the process that started it, the process
will recognize its own number. At this point the message type is
changed to COORDINATOR message and circulated again in the ring.

*
• Elections in Wireless Environments:
• To elect a leader, any node in the network, called the source, can
initiate an election by sending an ELECTION message to its
immediate neighbors .
• P:287

*
• Elections in Wireless Environments:

*
• Elections in Large-Scale Systems:
• In large scale system the are several nodes should be selected.
Such as in the case of superpeers in peer-to-peer networks.
• Requirements for superpeer selection:
1. Normal nodes should have low-latency access to superpeers.
2. Super peers should be evenly distributed across the overlay
network.
3. There should be predefined portion of superpeers relative to the
total number of nodes in the overlay network.
4. Each superpeer should not need to serve more than a fixed
number of normal nodes.

*
• Elections in Large-Scale Systems:
 Unstructured Systems:
• A total of N tokens are spread across N randomly-chosen nodes.
• Each token represents a repelling force by which another token is
inclined to move away.

*
• Atomic transactions allow the programmer to concentrate on the
algorithms and how processes work together in parallel.
• The Transaction Model:
• Stable Storage:
• RAM memory is wiped out when the power fails or machine
crashes.
• Disk storage survives CPU failures but can be lost in disk head
crashes.
• Stable Storage is designed to survives anything except major
calamities. It can be implemented with a pair of ordinary
disks.

*
• Transaction Primitives:
1. BEGIN_TRANSACTION: mark the start of a transaction.
2. END_TRANSACTION: Terminate the transaction and try to
commit.
3. ABORT_TRANSACTION: Kill the transaction; restore the old
values.
4. READ: Read data from file(or other object).
5. WRITE: Write data to file (or other object).
• The exact list of primitives depends on what kinds of objects
used in transaction.
• In an email server there might be primitives to send, receive
and forward mail.

*
• Properties of Transactions:
Transactions have four essential properties:
 Atomicity:
All or nothing- transaction either completes successfully, or
has no effect at all
 Isolation
Each transaction must be performed without interference
from other transactions
 Consistency
a transaction takes the system from one consistent state to
another consistent state
 Durability
After a transaction has completed successfully, all its effects
are saved in permanent storage

*
• Nested Transactions:
Transactions that may contain sub transactions, often called nested
transaction.

*
• Implementation:
Private Workspace:
when a process starts a transaction, it is given a private workspace
containing all the files to which has access.
Until the transaction either commits or aborts, all of its reads and
writes go to the private workspace.

*
• Implementation:
Writeahead Log:
With this method, files are modified in place, but before any block
is changed, a record is written to the writeahead log on stable
storage telling which transaction is making the change, which file
and block is being changed, and what the old and new values are.

*
• Implementation:
Two-Phase Commit Protocol:

*
Concurrency Control:
When multiple transactions are executing simultaneously in
different processes we need concurrency control algorithm to
keep the out of each other’s way.
Locking
• If a process need to read from a file it locks this file to make sure
that the file will not change, but other processes can also read
from the same file.
• In contrast, when a file is locked for writing, no other locks of
any kind are permitted.

*
Locking:
• Tow-phase Locking: The process first acquires all the locks it
needs during the growing phase, then release them during the
shrink phase.

*
Locking:
• Strict Tow-phase Locking: The process first acquires all the locks
it needs during the growing phase, then release them when
transaction has finished running and has either committed or
aborted.

*
Optimistic Concurrency Control:
The idea behind this technique is just go ahead and do whatever you
want to, without paying attention to what anybody else is doing. If
there is a problem, worry about it later.
• Transactions are allowed to proceed until the client completes its
task and issues a closeTransaction request.
• When a conflict arises, some transaction will be aborted and will
need to be restarted by the client.
• Works well with private workspaces
• Advantage: – Deadlock free – Maximum parallelism.
• Disadvantage: – Rerun transaction if aborts – Probability of
conflict rises substantially at high loads
• Not used widely

*
Timestamps:
• It is to assign each transaction a timestamp at the moment it
does BEGIN_TRANSACTION.
• Every file in the system has a read timestamp and a write
timestamp associated with it.

*
Distributed Deadlock Detection:
• Centralized Deadlock Detection:
The central coordinator maintains the resource graph for the entire
system. When the coordinator detects a cycle, it kills off one
process to break the deadlock.
• False deadlock:

*
• Distributed Deadlock Detection:
In this algorithm, processes are allowed to request multiple
resources at once, instead of one at a time.

*
• It consists of designing the system to that deadlocks are
structurally impossible.
• In a distributed operating system there is a method that is based
on assigning each transaction a global timestamp at the moment
it starts.

Synchronization

In this document