Synchronization Pradeep K Sinha

Synchronization
Pradeep K Sinha
M.Jawwad Rafiq FA15-R01-017
JawwadJLF@gmali.com
+92-333-6335584
Zain Arhsad FA15-R01-007
1

Outline
 Introduction
 Issues in Synchronization
 Clock synchronization
 Event Ordering
 Mutual Exclusion
 Deadlock
 Election algorithms
 Clock Synchronization
 How Computer Clocks are Implemented
 Drifting of Clocks
 Types of Clock Synchronization and issues in them
 Clock Synchronization Algorithms
• Distributed and Centralized Algorithms
• Case Study
 Event Ordering
 Happened Before Relation
 Logical Clocks Concept and Implementation
 Centralized Approach, Distributed Approach, Token Passing Approach 2

Process Synchronization
 Concurrent access to shared data may result in data inconsistency.
 Process Synchronization means sharing system resources in a such a
way that, Concurrent access to shared data is handled by minimizing
the inconsistency.
[http://www.studytonight.com/operating-system/process-synchronization]
3

Introduction
 A distributed system consist of multiple concurrent processes.
 It is economical to share the system resources among these
processes.
 Sharing may be:
• Competitive
• Co-operative
 Tape drive cannot be used simultaneously , A process must wait if
another process is using it.
 Two process Client-Server relationship, for file access operation they
cooperate each other.
 Both competitive and cooperative sharing require correct interaction.
Correction interaction implemented in the form of synchronization.
4

Issues in synchronization
 Clock synchronization
 Event Ordering
 Deadlock
 Election algorithms
5

Clock Synchronization
 Every computer needs a computer clock to keep track of computer
time and calculating the time spent by a process in execution on
processor.
 An application may have many processes that concurrently running
on different nodes of the system.
 Every node need clock that should be synchronized.
 Example, Air-line Reservation System
 If the clock of these nodes are not synchronized ,it is difficult to
achieve the correct result. That problem is called the clock
synchronization problem.
 Need some suitable ways to properly synchronizing the clocks.
6

How computer clocks are implemented
 A computer clock consists of three components.
• Quartz crystal (Oscillate 60 times in a second)
• Counter register
• Constant register (frequency of quartz crystal)
 To make the computer clock function as an ordinary clock.
• The value in the constant register is chosen 60 . (60 clock ticks in a second)
• The computer clock is synchronized with the real time.
• Two values stored in system , Date and Time, Number of Ticks
7

Quarts crystal (vibrating crystal create an electrical signal with
a precise frequency)
8

Drifting of Clocks
 Due to differences in crystals ,two clock rates different from each other.
 Difference is small but observable , no matter how accurately initialized.
 Therefore, Passage of time, a computer clock drifts from the real-time
clock.
 After 11.6 days of 1 second.
 Hence, Computer clock must be periodically synchronized with the real-
time clock called non-faulty.
 Even non-faulty clocks do not always maintain perfect time.
 A clock is called non-faulty if there is bound on the amount of drift.
9

Drifting of Clocks cont..
Slow, perfect and fast clocks 10

Types of Clock Synchronization
 External clocks
 Required for real time applications
 Allows the system to exchange information about the timing with other
systems and users.
 A external time source used UTC( Coordinated universal time).
 Internal clocks
 Provide a constant view of time across all the nodes of distributed systems.
 Note
 Externally synchronized clocks are also internally synchronized.
11

Clock Synchronization Issues
• Two clocks cannot be perfectly synchronized.
• In practically for the synchronization, the difference of time value of
two clocks should less than ∆.
• The difference in time values of two clocks is called clock skew.
• It is necessary of synchronization that each node should read the
clock values of other nodes. The mechanism of reading the clock
values of other nodes varies in different algorithms.
• Un-predictable communication delays of clock message between two
nodes.
• Time must never run backward because it causes repetition of
certain operations, when fast clock is set to slow down.
• Time should not be slowed down or moved backward at once, it
should be gradually updated with each interrupt.
12

Clock Synchronization algorithms
 Centralized Algorithms
• Passive time server
• Active time server
 Distributed Algorithms
• Global Averaging Algorithms
• Localized Averaging Algorithms
13

Centralized Algorithms
 One node has a real-time receiver called time server node.
 Clock time this node used to correct the time of all other nodes.
 The goal of this algorithm is to keep the clock of all other nodes
synchronized with the clock time of the time server node.
 Depending the role of the server node, centralized algorithms are
again of two types,
 Passive time server
 Active time server
14

Passive Time server Algorithm
 Each node periodically sends a message (“ Time = ? “) to the time
server.
 Server quickly responds with a message (“Time = T”).
 T is the current time of the server node.
 When client node sends the request of time, its clock time is To .
 When client node receives the time from server, its clock time is T1 .
 Propagation time of the message from server to client node is
estimated to be (T1-To) / 2.
 Therefore, Clock of client node is readjusted to T+(T1-To)/2 .
 Due to unpredictable propagation time between two nodes , is not
very good estimation.
 Two methods are described below to solve this problem.
15

Passive Time server Algorithm cont..
 1. This method assumes the availability of some additional
information.
 Two things are known:
 Approximate time taken by the time server to handle the interrupt .
 Process time of request message of client (“ Time = ? “) .
 Sum up of both times is the I .
 Best estimate in this case would be (T1-To-I) / 2.
 So , Total time at the client node is readjusted to T+ (T1-To-I) / 2.
 2. This methods assumes the no additional information, several
measurements of T1-To are made, and threshold is set.
 If the (T1-To) exceeds threshold then values are discarded.
 The average of remaining measurements is calculated and half of this
value is added to T.
 Alternative way is, Measurements for which (T1-To) is minimum is
considered to be most accurate one. And half of this added to T.
16

Active Time Server
 In this approach , Time server periodically broadcast its clock time (“
Time = T” ) .
 Other nodes receive broadcast message and use the clock time in the
message for correcting their own clocks.
 Each node has a priori knowledge of the approximate time (Ta) .
 Ta is the time from the propagation server to client node.
 And Client node is readjusted to T + Ta .
 Major Faults:
 Broadcast message reaches too late at the client node due to some
communication fault, Clock of this node readjusted to incorrect value.
 Broadcast facility should be supported by network.
17

Active Time Server (Solutions)
 Berkeley Algorithm:
 Time server periodically sends a message (Time= “?”) to all nodes in a
group.
 Each node send its clock value to server node.
 Server has prior knowledge of propagation time from client to server
node.
 Base of prior knowledge it first readjust the clock values of reply
messages.
 Then takes fault tolerant average.
 Time server choses a subset of all clocks values that do not differ from
one another by more than specified amount.
 And average is taken only for clocks value for subset.
 And eliminates reading from the unreliable clocks.
 Calculated average is current time which all clocks should be readjusted.
18

Disadvantages of Centralized Algorithms
 Single point of failure , if time server node failed , clock
synchronization operation cannot be performed.
 From scalability point of view , adding more node will put more
burden on the single central server.
 Solutions, of these problem are coming next…
19

Distributed Algorithms
 Externally synchronized clocks are also internally synchronized
 Each node’s clock is independently synchronized with real time.
 All clocks of system remain mutually synchronized.
 Each node is equipped with real time receiver so that each node can
be independently synchronized.
 Theoretically internal synchronization of clock is not required.
 in practice, due to inherent inaccuracy of real time clocks, different
real time clocks produce different time.
 Internal synchronization is performed for better accuracy.
 Types of internal Synchronization:
• Global averaging
• Localized Averaging
20

Global Averaging
• Each node broadcasts its local clock time in the form of a special
“resync” message.
• After broadcasting the clock value , the clock process of a node waits
for time T ( T is calculated by algorithm).
• During this period, clock process collects the resync messages
broadcast by other nodes.
• Clock process estimates the skew of its clock with respect to other
nodes (when message received) .
• It then computes a fault-tolerant average of the estimated skews and
use it to correct the local clock.
• Two commonly algorithms use to calculate the fault-tolerant average.
21

Global Averaging cont..
• 1st simplest algorithm is to take the average of estimated skews and
use it as the correction for the local clock. And only below a
threshold are taken into account, and other are set to zero before
computing the average.
• 2nd Algorithm, each node limits the impact of faulty clocks by
discarding the highest and lowest skews. And then calculating the
average of the remaining skews. And use it to the correction for the
local clock.
22

Localized Averaging Algorithm
• Global algorithm was only Suitable for small networks due to
broadcast facility.
• Where node has direct communication to every other node (fully
connected topology) .
• This algorithm attempt to overcome the drawbacks of the global
averaging algorithm.
• Nodes of a distributed system are logically arranged in some kind of
pattern such as Ring.
• Periodically each node exchange its clock time with is neighbors in
the ring.
• And then sets its clock time by taking Average.
• Average is calculated by , its own clock time and clock times of its
neighbors.
23

Case Study: Distributed Time Service
• Two popular services for synchronizing clocks and for providing time are
Distributed time server(DTS) and Network Time Protocol(NTP)
• DTS is Component of Distributed Computing Environment(DCE).
• NTP is used in internet for clock synchronization.
• In DCE each node is configured as either DTS client or DTS server.
• On each DTS client node runs a daemon process called DTS Clerk.
• Each DTS clerk for synchronizing it’s local clerk requests Server on same
LAN(Local Area Network). DTS servers sends time information to clerks as
well as other servers.
• DTS does not provide single value rather provides interval of correct time.
Interval tells users how much they are for from time.
• Each clerk has information regarding drift rate from server clock and when it
exceeds limit, it resynchronizes with all DTS servers using RPC(Remote
Procedure Calls). Each server using it’s time replies with interval to the clerk
which should be adjusted.
• Using these replies clerk corrects it’s time.
24

Case Study: Distributed Time Service cont..
• Time intervals that do not intersect with majority of interval are
considered faulty and discarded.
• Largest intersection falling within remaining interval is computed.
• Mid point of that interval is used by clerk to correct it’s value.
• Resetting of clerk time is done gradually rather than at once.
• Method of intersection requires at least three servers for time info.
• DTS servers also communicate in the same manner for time.
• Method is used for same lan. For multiple LANS One server of each
lan is designated Global server.
• Global servers periodically to keep clocks synchronized.
• Global server is also DTS server so it automatically synchronizes
clocks of other nodes in LAN.
25

Case Study: Distributed Time Service cont..
26

Event Ordering
• Keeping the clock synchronized within 5,10 milisec is expensive task.
• Lamport observed, Its not necessary to keep the clocks synchronized
in distributed system.
• It is sufficient to keep the all event be totally ordered.
• For Partial ordering of the events, Lamport defined a new relation
called Happened-Before relation.

Happened Before Relation
• Happened Before Relation(Denoted by →) on a set of events
Satisfies Following Conditions.
• If a and b are two events in the same process and a occurs before b,
then a→b.
• If a is event of sending a message by one process and b is event of
receipt of same message by another process, then a→b. it follows
law of causality because receiver can not receive message until
sender sends it and propagation time from sender to receiver is
always positive.
• If a→b and b→c, then a→c. happened before relation follows
transitive relation
• a→a is not possible. Happened before relation is irrreflexive partial
ordering.

Happened Before relation cont..
• Event types;
• Causal events
• Concurrent Events:
• Causal Events:
• Two events a →b is true if path exists between a and b by moving
forward in time along process and message lines in the direction of
arrows. These events are related by happened before relation.
• Concurrent events: two events are concurrent if no path exists
between them and are not related by happened before relation.

Diagram
• Causal Events:
• e1o → e11 e20 →e24 e11 → e23 e21 →e13
• e30 → e24
• e11 → e32
• Concurrent Events:
• e12 and e20 e21 and e30 e10 and e30 e11 and e31 e12 and e32 e13 and e22

Logical Clocks Concept
• For determining the event a occurs before b, need common clock, or
set of perfectly synchronized clocks.
• Neither of these available, Lamport provided a solution of this
problem. Local clock concept.
• The logical clock concept is to associate a timestamp with each
system event.
• Each process Pi, has a clock Ci.
• And assigned a number Ci(a) to any event in that process.
• In fact, Logical clocks implemented by counters with no actual timing
mechanism.
• Happened-before relation should be ordered, using these clocks.
• So that Logical clocks must satisfy the following condition:
• For any two events a and b, if a b , then C(a) < C(b)
31

Implementation of Logical Clocks
• Happened Before algorithm with logical clocks must follows the
following conditions:
• C1: If a and b are two events within the same process Pi and a occurs
before b , then Ci(a) < Cj(b).
• C2: If a is the sending message by process Pi, and b is the receipt of
that message by process Pj, then Ci(a) < Cj(b)
• C3: A clock Ci associated with a process Pi, must always go forward ,
never backward, That is, corrections to time of a logical clock must
always be made by adding a positive value to the clock , never by
subtracting the value.
32

Implementation of Logical Clocks cont..
To meet conditions C1, C2, and C3 , Lamport used the following
implementation rules:
IR1(implementation Rule): Each process Pi increments Ci between two
successive events.
IR2(implementation Rule): If Pi sending a message m by an event a,
and the message m contains a timestamp Tm= Ci(a) , and other
process Pj receive this message Ci(a) . And if Ci(a) is greater than and
equal to its present value then Ci(a) value updated on it with +1
increment, otherwise Cj present value continue.
33

Implementation of Logical Clocks by Using
Counters
• Two processes P1 and P2 each have counters C1 and C2.
• C1 values increase C1=0,1,2,3,4,5…
• C2 values increase C2=0,1,2,3,4,5…
• Counters act like logical clocks.
• Message having the incremented value of counter, that is sent by P1.
• On the other side P2 receive this message, and instead of simple
increment of its counter, a check is made .
• Check is , If the incremented counter value of P2 is less than or equal
to the timestamp in the received message from P1 .
• if C2 <= C1 ,e.g 3 <= 4 , C2 value will be updated with +1.
34

Counters cont…
35

Physical Clocks
• Each process has a physical clock associated with it.
• Each clock run at a constant rate.
• However, The rates at which different clocks run are different.
• When clock of process P1 has ticked 10 times, The clock of process
P2 has ticked only 8 times.
• , If the incremented counter value of P2 is less than or equal to the
timestamp in the received message.
• if C2 <= C1 ,e.g 56<= 60 , C2 value will be updated with +1.
36

Physical Clocks cont..
37

Total Ordering of Events
• Happened-before has only partial ordering.
• Two events a or b not related by Happened-before , if same
timestamps are associated with them.
• P1 and P2 clocks are same for example 100 .
• Nothing can be said about the order.
• Additional information required.
• Lamport purposed Total ordering of processes.
• He used process identity numbers.
• Timestamp associated with them will be 100.001 and 100.002.
• Here , process identity numbers of processes P1 and P2 are 001 and
002.
38

Mutual Exclusion
• A file must not be simultaneously updated by multiple processes.
• Such as printer and tape drives must be restricted to a single process
at a time.
• Therefore , Exclusive access to such a shared resource by a process
must b ensured.
• This exclusiveness of access is called mutual exclusion between
processes.
39

Critical Section
• The sections of a program that need exclusive access to shared
resources are referred to as critical sections.
• For mutual exclusion , Ways are introduced, to prevent processes
from executing concurrently with their associated critical section.
• Following requirement must satisfy for mutual exclusion:
• 1. Mutual exclusion: At anytime only one process should access the
resource. A process can get another resource first releasing its own.
• 2. No starvation: if every process that is granted the resource
eventually release it, every request must be eventually granted.
40

Starvation of process
• Indefinite postponement of a process because it requires some
resource. but the resource is never allocated to this process. It is
sometimes called livelock.
[https://www.cs.auckland.ac.nz/~alan/courses/os/book/6.Mana.13.starvation.
pdf]
41

Three approaches to implement mutual
exclusion
• Centralized Approach
• Distributed Approach
• Token Ring
42

Centralized Approach
• One process in the system is selected as coordinator.
• That coordinates the entry to the critical sections.
• Each process that wants to enter a critical section must first seek
permission from the coordinator.
• If two processes simultaneously ask for permission to enter the
critical section , Coordinator grants permission according with some
scheduling algorithms.
• When process exits, it notify the coordinator so that the coordinator
can grant permission to another process.
• This algorithm (in centralized) ensures mutual exclusion, because at a
time , the coordinator allows only one process to enter in critical
section.
• This algorithm (in centralized) ensures no starvation, because use of
FCFS ( First come First served ) .
43

Centralized Approach cont..
44

Centralized Approach cont..
 Benefits:
• easy to implement
• Requires only three messages per critical section (request, reply, release ).
 Drawbacks:
• Single coordinator
• Single point of failure
• Performance down due to bottleneck in large systems.
45

Distributed Approach
 Decision making for mutual exclusion is distributed across entire system.
 All process that want to enter critical section co-operate with each other
before taking decision.
 Ricart and Agarwala’s algorithm is used, based upon Lamport’s event
ordering scheme to assign unique time stamp to each event.
 When a process wants to enter critical section it sends request message to
all process. Message contains
 Process identifier of process
 Name of critical section that process wants to enter.
 Unique time stamp generated by process for request message.
 On receiving request message a process immediately sends reply message
or defers reply based upon following rules.

Distributed Approach Cont..
 If receiver process is in critical section, it places request message in
queue and defers sending a reply.
 If receiver process is not in critical section and waiting to enter, it
compares it’s own time stamp with received time stamp. If received
time stamp is lower than it’ own, it means that process made request
earlier, than it sends reply to that process otherwise places it in
queue and defers sending reply.
 If receiver process is neither in critical section nor waiting, it simply
sends reply message.
 A process enters critical section if it receives message from all
process, executes in critical section and than sends reply message to
all processes in queue.

Drawbacks and solutions
 1)System having n processes is liable to n points of failure and blocks in case
of single process failure.
 Solution: receiver sends permission denied message when it is in critical
section, else it sends OK. if receiver did not receive reply it keeps on trying
after time out,until it gets reply, else it considers that process has crashed.
 2) Each process must know identity of process participating in group.
 When a process joins it must receive names of all other processes and name
of new process must be distributes to all members of group.
 suitable only for small group due to large no of updates of creation and
deletion.
 3) To much wait if there are large no of nodes. If there are n nodes and single
message travels through network then each process will wait for 2(n-1)
messages. Suitable for small group.
 Best solution: Majority consensus rather than consensus of all processes is
proposed in literature.

Token passing Approach
 Mutual Exclusion is achieved by circulating single token among processes.
 Token is special type of message that entitles its holder to enter critical
section. Process are arranged in logical ring structure.
 Token can be moved clockwise or anti-clockwise.
 When a process gets token it can enters critical section and after finishing
work, exits from critical section and passes token to neighbor process.
 Process can enter critical section one time in each turn with token.
 If process is not interested to enter in critical section, it simply passes token
to neighbor, if no one is interested token keeps on circulating in ring.
 Waiting time varies from 0 to n-1 messages depending upon receipt of
token and interested to enter in critical section or interested just after the
token passed to neighbor.

Drawbacks and Solutions:
 1) Process failure: Single process failure causes logical ring to break.
 Solution: exchange of Ack(acknowledgement) after message Receipt with
neighbor. If no Ack comes, means problem with process.
 Current ring information with each process, using this each process skips its
faulty neighbor process and when that process recovers, it informs it’s
previous neighbor or process.
 2) Lost Token: Token is lost, new token message must be generated.
 Solution: Designate one process as monitor process.
 Monitor periodically circulates "who has token” message. All the process
passes message to neighbor, except the process which has token. It send its
process identifier in special field with token to neighbor.
 When message returns to monitor after one circulation, if there is no entry
in that field means token has been lost, generates new token and circulates
in ring
 3) Monitor process and “who has token” message is lost.
 Solution: more than one monitor process. And if one fails election has to be
done for selection of next monitor who will generate token.

Deadlock
 A set of blocked processes each holding a resource and waiting to
acquire a resource held by another process in the set.
 Example:
 System has 2 tape drives.
 P1 requests for one tape drive and the system allocates tape drive 1.
 P2 request for one tape drive and the system allocates tape drive 2.
 P1 request for one more tape drive and enter in waiting state.
 P2 request for one more tape drive and it also enter in waiting state.
53

Deadlock example (Bridge Crossing)
55
 If a deadlock occurs. It can be resolved if one car back up.
 Called preempt resources and rollback.
 Several cars may have to be backed up if a deadlock occurs.
 Starvation is possible.
 Traffic only in one direction.
 Each section of bridge can be viewed as a resource.

Deadlock cont..
• Process use a resources in following sequence of events.
• Request: Process first makes a request for resources. If not available
must wait. When available , request satisfied. But number of
requests may not exceeded the total number of available units of
resources.
• Allocate: System allocate the resources . It maintain a table. Where
records of resources , and which resource is allocated to which
process. Also having queue for waiting process.
• Release: After the process finished using the allocated resource , it
release the resource to the system. System update the allocation.
56

Deadlock cont..
• If some of the processes entered in the waiting state, will never
change state. Because requested resources are held by other waiting
processes . This situation is called deadlock.
• Resource can be , physical objects ( Disk drive , tape, CPU, RAM) and
logical objects ( files, tables, database ) .
• Preemptable, meaning that the resource can be taken away from its
current owner (and given back later). An example is memory.
• Non-preemptable, meaning that the resource cannot be taken away.
An example is a printer.
57

Necessary Conditions for Deadlock
 Deadlock occurs if the following conditions hold simultaneously:
 Mutual exclusion condition
 Hold and wait condition
 No-Preemption condition
 Circular-wait condition
58

Necessary Conditions for Deadlock cont…
 Deadlock occurs if the following conditions hold simultaneously:
 Mutual exclusion: only one process can use a resource at a time.
 Hold and wait: Processes are allowed to request for new resources
without releasing the resources that they are currently holding.
 No-preemption: If a process has a resource , cannot be preempted.
 Circular-wait: Two or more processes from a circular chain.
59

Deadlock Modeling
61
b
a c
f d
e
 Directed graph (consists of node and edges)
 Path ( a to b )
 Cycle (first and last node same)
 Knot (A knot contain one or more cycles)
 This graphs consist of nodes
(a,b,c,d,e,f)
 Set of edges
{(a,b),(b,c),(c,d),(d,e),(e,f),(f,a),(e,b)}
 Two cycles
(a,b,c,d,e,f,a) and (b,c,d,e,b)
 One knot
(a,b,c,d,e,f) that contain two cycle.

Deadlock Modeling cont..
62
 Process nodes (circle)
P1,P2
 Resource nodes (rectangle)
R1,R2
 Units (bullets)
Resources have more than one units
 Assignment edges
resource node to process node
(R1,P1), (R1,P3) , (R2,P2)
 Request edges
Process node to a resource node
(P1,R1) and (P2,R2)

Necessary and Sufficient Conditions for
Deadlock
• A cycle is necessary condition for a deadlock.
63

Deadlock cont..
• A cycle is necessary condition for a deadlock.
• The presence of cycle is necessary condition for deadlock but not
sufficient.
• This diagram contains cycle but does not represent a deadlock.
64
 When P3 completes its
processing. It release R1.
R1 assigned to P2.
 P2 complete its job and
release R2,R1.
 R2 allocated to P1.

Deadlock cont..
• If processes forming a cycle , and one or more resources Ri have
more than one unit, and a knot will be there, deadlock occurs.
• P3 request for R2. (P3,R2) added to the graph.
• This graph has two cycles (P1,R2,P2,R1,P1) and (P3,R2,P2,R1,P3) in
knot (P1,R2,P3,R1,P1).
65

Deadlock cont..
• Necessary and sufficient condition for deadlock can be summarized
as follows:
• A cycle is necessary for deadlock.
• If there is a only single unit in one Resource in cycle.
• If more than one unit are there in cycle, then a knot is sufficient for a
deadlock.
66

Wait-for graph (WFG)
• When each resource has one unit , simplified form of graph is used.
• Conversion from allocation graph to a WFG, removing the resource nodes.
• This simplification based on , a resource can always be identified by its
current owner ( process holding it ).
67

Handling Deadlocks
• Prevention
• Avoidance
• Detection and recovery
68

Deadlock Prevention
 Designing the system in a way that deadlock become impossible.
 Prevention is different from avoidance because no runtime testing
(dynamically) of potential allocations need be performed.
 Prevent the one of the four necessary conditions:
 Mutual exclusion condition
 Hold and wait condition
 No-Preemption condition
 Circular-wait condition
69

Deadlock Prevention cont..
• Mutual Exclusion
• Unfortunately it is not possible to prevent deadlocks by denying
mutual-exclusion.
• Cannot be prevented for all resources. Some resources are
intrinsically non-sharable for example printer, and some are sharable
like CPU.
70

• Hold and wait ( Collective Requests )
• This method denies the hold-and-wait condition.
• We must guarantee that whenever a process requests a resource, it
does not hold any other resources.
• Following policies maybe used to ensure this:
• 1. A process must request all of its resources before it begins
execution. If all the needed resources are available , they are
allocated to it.
If one or more resources are not available , none will be allocated
and process would just wait.
71

• Problems in Hold and wait ( Collective Requests )
• Low resource utilization because a process may hold many resources
but all of them not used.
• It may cause starvation because whenever a process made a request ,
resources are not available.
72

 No-Preemption condition ( resources will be preempted)
 A preemptable resource is one whose state can be easily saved and
restored later.
 A resource temporarily taken away from the process without harm to
the computation performed by this process.
 CPU, Main Memory are preemptable resources.
 If the resources are preemptable, deadlocks can be prevented.
 Two policies:
 1. when a process requests for a resource, and resource is not
available. Its already held resources taken away from it. And the
process is blocked. The process is unblocked when the resources
(requested by it, and preempted from it) available and allocated to it.
73

 No-Preemption condition ( resources will be preempted)
 2.When a process requests a resource that is not currently available,
the system checks, if the requested resource is currently held by
another process that is already blocked and waiting for other
resources. If so , the requested resource is taken away from the
waiting process and give to the requesting process, otherwise
condition-1 applied.
74

 Circular wait condition (ordered requests)
 Each resource (type) is assigned a global number to impose total ordering.
 Impose a total ordering of all resource types , and require that each process
can only requests resources in an increasing order of enumeration.
 Process should not request a resource with a number lower than is already
held resource.
 If process request = j and process already held resource = I=i
then, j > I
 Single request will be enough for the same resource type.
 It has proven that with this ,graph can never have circular-wait.
 If tape drive =1 , disk drive = 5, printer = 12,
after getting tape drive process can request for the disk drive, after disk drive
process can request for the printer.
But it a process have the number =5, it cannot request for the number=1 for
tape drive.
75

Deadlock Avoidance
 The system dynamically considers every request and decides whether
it is safe to grant it at this point.
 Deadlock avoidance use some advance knowledge of the resource
usage of processes.
 Following steps are for deadlock avoidance:
 When a process request for resource, even if the resource is available
for allocation. It is not immediately allocated to that process.
 Advance knowledge used to perform analysis to decide whether
process’s request is safe or unsafe.
 When request is safe, resource allocated, otherwise deferred.
76

Deadlock Avoidance cont..
 Safe State:
 A system is considered in safe state , if there exists some ordering of
processes in which run all requests lead to completion .
 Safe Ordering (sequence):
 Any ordering of processes, that can guarantee the completion of all
the process is called safe sequence.
77

 In a system there are 8 units of particular resource type.
 Three processes P1,P2 and P3 are competing.
 Explanation in next diagram.
78

80
 If resource allocation is not done carefully , the system move
from a safe sate to unsafe state.

81
 It is important to note the following remarks about safe and unsafe
states:
 The initial state in which no resources are yet allocated is called safe
state.
 Safe state, the system can guarantee that all processes can be run to
completion.
 An unsafe state is not a deadlock state, but it may lead to a deadlock
state, the system cannot guarantee that all processes can be run to
completion.

82
 It is important to note the following remarks about safe and unsafe
states:
 The initial state in which no resources are yet allocated is called safe
state.
 Safe state, the system can guarantee that all processes can be run to
completion.
 An unsafe state is not a deadlock state, but it may lead to a deadlock
state, the system cannot guarantee that all processes can be run to
completion.

 Due to following reason , avoidance rarely used:
 Assumption of advance knowledge is available, however in practice,
processes rarely know in advance what their maximum resource
needs will be.
 Number of processes not known in advance, because dynamically
varies. ( user login , logout)
 Number of units change dynamically (machine crash).
 Restriction on resource allocation , cause degrades the system
performance.
83

Deadlock Detection
• Uses algorithm that keeps examing state of system to determine
weather a deadlock has occurred.
• When deadlock has occurred system takes action to recover.
• Algorithms are same for centralized as well as distributed.
• Uses resource allocation graph and searching for cycle or not
depending upon single or multiple units of resources.
Following steps are needed to construct Weight For Graph(WFG).
1) Construct separate Resource allocation graph for each site.
Resource node exists for all local resources and process node
exists for all processes that are either holding or waiting for
resource.
2) Construct WFG by removing resources and collapsing edges.
3) Take union of all WFG of all sites and construct single global WFG.

Deadlock Detection Cont…
• Two sites, site 1 with 2 resources and site 2 with 1 resource.
• P1 is holding R1 and requesting for R3.
• P2 is holding R2 and requesting for R1.
• P3 is holding R3 and requesting for R2
Union of WFG of two sites will show either deadlock exists or not.
Local WFG does not contain cycle while Global has.
Difficulties: Maintaining WFG of each site is difficult.
Most important feature of deadlock detection algorithm is
correctness which depends on these properties.
1) Progress Property:
Deadlocks must be detected in finite amount of time.
2) Safety Property:
Detected deadlock must exist. Message delays and out of date WFG
cause false cycles to be detected. It results in detection of
deadlocks that do not exist called phantom deadlocks.

Deadlock Detection Cont..
• Three commonly used techniques for organizing WFG in a distributes
system are..
• Centralized Algorithms.
• Distributed Algorithms
• Hierarchical Algorithms.

Centralized Approach
• Local coordinator at each site that maintains WFG of its local resources.
• Central coordinator that is responsible for constructing union of all WFG.
• Central coordinator constructs global EFG from information received form
local coordinator of all sites.
deadlock detection is performed as follows.
If cycle exists in local WFG of any site, it represents local deadlock. Such
deadlocks are detected and resolved by local coordinator.
Deadlocks involving resources at two or more sites get reflected as cycles in
global WFG. Such deadlocks are detected and handled by central
coordinator.
In centralized approach messages are sent form local to central coordinator
to transfer information as follows.

Centralized Approach Cont..
• Continuous Transfer: local coordinator send message whenever an
new edge is added or deleted
• Periodic Transfer: local coordinator sends message after fix time
when no of changes have occurred.(in order to reduce messages)
• Transfer on Request: on request of central coordinator. Central
coordinator invokes cycle detection algorithm periodically and
requests information from each site just before invoking algo.
• Drawbacks:
• Failure of central coordinator. Back up can resolve issue.
• Central coordinator will become performance bottle neck in large
system having to many sites.
• It may detect false deadlocks or phantom.

• 3 processes(p1,p2,p3) compete for 3 resources(R1,R2,R3)
• Step 1: p1 requests for R1 and R1 is allocated to it.
• Step 4: p2 requests for R1 and waits for it.
• Step 6: P1 releases R1 and R1 is allocated to P2.

• m1: from site S1 to add edge (R1,P1)
m2: from site S1 to add edge (R2,P2)
m3: from site S2 to add edge (R3,P3)
m4: from site S1 to add edge (P2,R1)
m6: from site S1 to delete edges (R1,P1) and (P2,R1) and edge (R1,P2)
If all these messages are in order than no problem.
If message 7 from site 2 comes earlier than message 6 from site 6 than
central coordinator will incorrectly conclude that deadlock has occurred
and will start to recover. In this example we followed continuous transfer
same problem will also be with other two methods.
Solution: assign unique global timestamp with message.
Central coordinator send message to each site if some one has time stamp
earlier than received message, site with minimum will reply and other site
with negative reply.

Hierarchical Approach
• Drawbacks:
• Most WFG cycles are very short.
• 90% of all deadlock cycles involve only two processes.
• So centralized approach seems less attractive because of time and
overhead involved in assembling local WFG at central coordinator.
• Deadlock should be detected by a site located as close as possible to
sites involved in cycle to minimize communication cost.
• Solution:
• Hierarchical approach solves this issue.

Hierarchical Approach Cont…
• Uses logical hierarchy(tree) of deadlock detectors.
• Deadlock detectors are called controllers.
• Each controller is responsible for deadlocks that involves sites falling
within its range.
• Unlike centralized approach instead of maintaining WFG at a single
site, it is distributed over no of controllers.
WFG is maintained on following rules.
• Each controller that forms a tree of hierarchy tree maintains local
WFG of single site.
• Each non-leaf controller maintains WFG that is union of WFGs of its
immediate children in hierarchy tree.

Fully Distributed Approaches for deadlock
detection
• Each site of system shares equal responsibility for deadlock detection.
• Types:
• WFG based Distributed algorithm for deadlock detection.
• Probe based Distributed algorithm for deadlock detection.

WFG based Distributed algorithm for deadlock
detection.
.
• Each site maintains its own WFG.
• Extra node Pex is added to local WFG of each site, and this node is
connected to WFG of corresponding site in following manner.
• 1) An edge(Pi, Pex) is added if processes Pi is waiting for resource in
another site held by by any other process.
• 2) An edge(Pex,Pj) is added if Pj is a process of another site that is
waiting for a resource currently held by process of this site.

WFG based Distributed algorithm for
deadlock detection cont...
• 1) in the WFG of site S1, edge (P1,Pex) is added because process P1 is
waiting for a resource in site S2, that is held by process P3, and
edge(Pex,P3) IS ADDED BECAUSE process P3 is process of site S2, that is
waiting to acquire a resource currently held by process P2 of site S1.
• 2) in the WFG of site S2, edge (P3,Pex) is added because process P3 is
waiting for a resource in site S1, that is held by process P2, and
edge(Pex,P1) IS Added Because process P3 is process of site S2, that is
waiting to acquire a resource currently held by process P2 of site S1.
• Deadlock Handling:
• If local WFG contains a cycle that does not involve node Pex, a deadlock
that involves only local process of that site has occurred. Such
deadlocks are handled locally.
• If local WFG contains a cycle that involves node Pex, there is possibility
of distributed deadlock that involves process of multiple sites. For
confirmation deadlock distribution algorithm is invoked by site whose
WFG contains a cycle involving node Pex.

Probe based Distributed algorithm for
deadlock detection
• Best algorithm for detecting global deadlocks in distributed system.
• Algorithm allows a process to request multiple resources at a time.
• When a process requests for a resource or resources fails to get
requested resource and times out, it generates special probe
message and sends it to process holding the requested resources.
Probe message contains following fields.
• The identifier of process just blocked.
• The identifier of process sending message.
• The identifier of process to whom the message is being sent.

deadlock detection cont…
• On receiving a probe message, receipt checks to see if it itself is waiting for
any resource or resources. If not this means that receipt is using the
resource requested by the process that sent probe message to it. Receiver
simply ignores probe message..
• On the other hand if receipt is waiting for nay resource it passes the probe
message to the process or processes holding the resource for which it is
waiting . However probe message is forwarded.
• Receipt modifies its field in following manner.
• The first field is left unchanged.
• The receipt changes the 2nd field to its own process identifier.
• 3rd field is changed to identifier of process that will be new receipt of this
message.
Every new receipt of probe message repeats this procedure. If probe
message returns back to its original sender a cycle exists and system is
deadlocked.

deadlock detection cont…
• Attractive Features:
• easy to implement, since message is of fix length and requires few
steps for computation.
• Low overhead
• No need of graph construction
• False deadlocks are not detected.
• No specific structure required among processes.

Ways for recovery from deadlock
• Asking for operator intervention
• Termination of process or processes.
• Rollback of processes.
1) Asking for operator intervention: system assist the operator in decision
making for recovery by providing him list of processes involved in
deadlock. It is handled manually. Console is used to continuously
monitor smooth running. Every site has an operator to handle deadlock.
Drawbacks:
Not used in modern systems.
Not suitable for distributed environment because each site operator will
take some action for recovery.
If operator of single site is informed. It may favor it’s own processes.
Operator of one site may not have rite to interfere with other

Ways for recovery from deadlock
2) Termination of process or processes:
Simplest way tom recover deadlock automatically by killing one or more
processes and reclaim the resources held by them
algorithms of this type analyze resource requirements and
interdependencies of processes involved in deadlock cycle and then select
a set of processes which if killed can break cycle.
3) Rollback of processes:
killing of processes restarting from start is expensive specially when the
process has already run for long time.
To reclaim a resource from process that were selected for being killed
rollback the process to point where resource was not allocated to the
process.
Processes are check pointed periodically. Process state memory image and
list of resources held by it are written to a file at regular interval. So in case
of deadlock process can be restarted from any of check points.

Issues In Recovery From Deadlock
• Selection of victim
• Minimization of recovery cost
• Prevention of starvation
• Use of transaction mechanism
• Selection of victim: Deadlock is broken by killing or rolling back one or more
processes. These process are called victims.
• Minimization of recovery cost:
• Processes whose termination/rollback will incur minimum recovery cost must
be selected.
• Unfortunately it is not possible to have universal cost function.
• Each system should determine its own cost function to select victim.
Factors:
Priority of processes.
Nature of processes( interactive or batch)
No and types of resources held by processes
Length of service already received and expected length of service further
needed by processes.
Total no of processes that will be affected.

Issues In Recovery From Deadlock cont…
• Prevention of starvation:
• Same processes may be repeatedly selected as victim on the basis
minimization of recovery cost and may never complete called starvation.
• Raise the priority of processes every time it is victimized.
• Include no of times a process is victimized as parameter to cost function.
• Use of Transaction mechanism:
• Rerunning a process from rollback state may not always be safe.
• Operations performed by that process may b non idempotent.
• It must be used with only those processes which will not cause ill effects.

Election Algorithms
• Election algorithms are meant for electing a coordinator process
from among the currently running processes in such a manner that at
any instant of time there is a single coordinator for all processes in
the system.
• Election algorithms are based on following assumptions
• Each process in system has unique priority no.
• Whenever an election is held, process having highest priority no
among the currently running processes is elected as coordinator.
• On recovery, a failed process can take appropriate actions to rejoin
the set of active process.
• Types:
• Bully Algorithm
• Ring Algorithm

Bully Algorithm
• When a process(say Pi) sends a request message to to coordinator and does
not receive a reply within a fixed time out period, it assumes that
coordinator has failed.
• It initiates election by sending an election message to every process with
higher priority no than itself.
• If Pi does not receive response in time out means it has highest priority.
• It will become coordinator and will inform all processes through message.
• If Pi receives reply means other processes with higher priority are available
and does not take any decision and waits for message of coordinator.
• When Process Pj receives an election message. It informs sender that is
alive and now Pj will do election and will become coordinator if it has
highest priority no.
• Else Pj will initiate message and this will continue.

Ring Algorithm
• Processes are arranged in logical ring.
• Every process in the system knows structure of ring.
• If successor of sender process is down, it can be skipped until active member is
achieved.
• When Pi requests coordinator and it is down it will wait for time out, it initiates
election by sending election message to successor.
• Message contains priority no of process Pi.
• Each successor will add its priority no on receipt.
• It will circulate and reaches Pi.
• Pi recognizes its own message due to first priority no.
• It selects the highest priority no processor.
• It then circulates coordinator message to all active processes to tell them.
• It deletes coordinator message after complete round when message comes.
• When pj comes after recovery it tells its neighbour its process identity and
message will circulate until it reaches coordinator and will receive reply to let it
know the coordinator.

Discussion of Two Election Algorithms
• Bully Algorithm:
• When lowest priority no process detects coordinator failure in a
system of n processes n-2 elections are performed, leaving failed
coordinator and sender.
• In worst case complexity is O(n^2).
• best case n-2 messages are required. Complexity O(n)
Ring Algorithm:
election requires 2(n-1) messages.
n-1 messages for one round rotation of election message.
n-1 messages for one round rotation of coordinator.

Synchronization Pradeep K Sinha

More Related Content

What's hot

Similar to Synchronization Pradeep K Sinha

Recently uploaded

In this document

Synchronization Pradeep K Sinha