Seminar Report on DEADLOCK

“Deadlock” A SEMINAR REPORT Submitted by Mahipal Singh (Roll No:-1305020116) In partial fulfilment for the award of the degree Of MASTER OF COMPUTER APPLICATION

2015

1

DEPARTMENT OF INFORMATION TECHNOLOGY ` CERTIFICATE This is to certify that the Seminar titled “Deadlock” was prepared and presented by Mahipal Singh Roll No. 1305020116 of V – Semester in partial fulfilment of requirement for the award of Degree of Masters in Computer Application under Sikkim Manipal University –Directorate of Distance Education

SEMINAR GUIDE

2

Acknowledgement

The enduring of the work is the cumulative sequence of extensive guidance & arduous work. We wish to acknowledge and express our personal gratitude to all those without whom this work could not have been reality. I am greatly indebted to Mr. Navin Purohit & Mr. Richard Kumar gave me an opportunity to work in such a professional & inspiring environment. I feel very delighted to get this rare opportunity to show my profound senses of reverence & indebtedness to our esteemed teachers to Mr.Navin Purohit & Mr. Richard Kumar for their keen & sustained interest, valuable advice. For this type of consideration I behold there in a special manner & no words can fully convey our regards for them. I want to acknowledge all those who have directly or indirectly helped & cooperated in accomplishing this seminar.

3

Abstract

Deadlock has been widely studied in many fields of computer science, notably in communications, database, and operating systems. Perhaps because (at least one state called) deadlock is tractable, there exists extensive literature on the subject. Deadlock was apparently decisively defined over thirty years ago, with its characteristics and handlers. Yet, much of the literature remains inconsistent in its treatment of this anomaly. A more precise definition is clearly needed to distinguish between the different states that are termed deadlock. A classification of dead states is required to distinguish the causes and appropriate handlers for each.

4

Table of Contents

CHAPTER 1

INTRODUCTION

CHAPTER 2 CHAPTER 3 CHAPTER 4 CHAPTER 5 CHAPTER 6 REFERENCES

DEADLOCK CHARACTERIZATION RESOURCE ALLOCATION GRAPH METHODS OF HANDLING DEADLOCK RECOVERY FROM DEADLOCK CONCLUSION

1: INTRODUCTION

5

In a multiprogramming environment, several processes may compete for a finite number of resources. A process requests resources; if the resources are not available at that time, the process enters a waiting state. Sometimes, a waiting process is never again able to change state, because the resources it has requested are held by other waiting processes. This situation is called a deadlock. Perhaps the best illustration of a deadlock can be drawn from a law passed by the Kansas legislature early in the 20th century. It said, in part: "When two trains approach each other at a crossing, both shall come to a full stop and neither shall start up again until the other has gone." Some applications can identify programs that may deadlock, operating systems typically do not provide deadlock-prevention facilities, and it remains the responsibility of programmers to ensure that they design deadlock-free programs. Deadlock problems can only become more common, given current trends, including larger numbers of processes, multithreaded programs, many more resources within a system, and an emphasis on long-lived file and database servers rather than batch systems.

Dead-lock is a condition that may involve two or more processes in a state such that each is waiting for release of a resource currently held by some other process.

Examples:•

Two cars crossing a single-lane bridge from opposite directions. 6

•

A person going down a ladder while another person is climbing up the ladder.

•

Two trains travelling toward each other on the same track.

Deadlock can be defined as the permanent blocking of a set of processes that either compete for system resources or communicate with each other. A set of processes is deadlocked when each process in the set is blocked awaiting an event (typically the freeing up of some requested resource) that can only be triggered by another blocked process in the set. Deadlock is permanent because none of the events is ever triggered.

7

A process must request a resource before using it and must release the resource after using it. A process may request as many resources as it requires to carry out its designated task. Obviously, the number of resources requested may not exceed the total number of resources available in the system. In other words, a process cannot request three printers if the system has only two. Under the normal mode of operation, a process may utilize a resource in only the following sequence: 1. Request- If the request cannot be granted immediately (for example, if the resource is being used by another process), then the requesting process must wait until it can acquire the resource. 2. Use-The process can operate on the resource (for example, if the resource is a printer, the process can print on the printer). 3. Release-The process releases the resource.

2. DEADLOCK CHARACTERIZATION A deadlock situation can arise if the following four conditions hold simultaneously in a system:

8

1. Mutual exclusion- At least one resource must be held in a non-sharable mode; that is, only one process at a time can use the resource. 2. Hold and wait-A process must be holding at least one resource and waiting to acquire additional resources that are currently being held by other processes. 3. No pre-emption-Resources cannot be pre-empted; that is, a resource can be released only voluntarily by the process holding it, after that process has completed its task. 4.Circular wait- A set { P0 , P1, ... , Pn } of waiting processes must exist such that Po is waiting for a resource held by P1, P1 is waiting for a resource held by P2, ... , Pn-1 is waiting for a resource held by Pn and P0 is waiting for a resource held by Pn.

3. RESOURCE ALLOCATION GRAPH Deadlocks can be described more precisely in terms of a directed graph called System resource allocation graph. This graph consists of a set of vertices V and a set of edges E. The set of vertices V is partitioned into two different types of nodes: P == { P1, P2, ... , Pn}, the 9

set consisting of all the active processes in the system, and R == {R1 , R2 , ... , Rm} the set consisting of all resource types in the system.

A directed edge P-> Rj is called a request edge, A directed edge R1 -> P; is called an assignment edge.

Without a deadlock

with a deadlock

4. METHODS OF HANDLING DEADLOCK We can deal with the deadlock problem in one of three ways:

10

 



Prevention-We can use a protocol to prevent or avoid deadlocks, ensuring that the system will never enter a deadlocked state. Detection-We can allow the system to enter a deadlocked state, detect it, and recover.

Avoidance-We can ignore the problem altogether and pretend that deadlocks never occur in the system.

Deadlock prevention 1. Mutual Exclusion – not required for sharable resources; must hold for non-sharable

resources

2. Hold and Wait – must guarantee that whenever a process requests a resource, it does not hold any other resources •

•

Require process to request and be allocated all its resources before it begins execution, or allow process to request resources only when the process has none Low resource utilization; starvation possible

3. No Pre-emption –

•

If a process that is holding some resources requests another resource that cannot be immediately allocated to it, then all resources currently being held are released

•

Pre-empted resources are added to the list of resources for which the process is waiting

•

Process will be restarted only when it can regain its old resources, as well as the new ones that it is requesting.

4. Circular Wait – impose a total ordering of all resource types, and require that each process Requests resources in an increasing order of enumeration.

Deadlock avoidance 

Simplest and most useful model requires that each process declare the maximum number of resources of each type that it may need 11

 

The deadlock-avoidance algorithm dynamically examines the resource-allocation state to ensure that there can never be a circular-wait condition Resource-allocation state is defined by the number of available and allocated resources, and the maximum demands of the processes

Safe state 

 

When a process requests an available resource, system must decide if immediate allocation leaves the system in a safe state

System is in safe state if there exists a sequence of ALL the processes is the systems such that for each P i, the resources that Pi can still request can be satisfied by currently available resources + resources held by all the Pj, with j < i That is: •

If Pi resource needs are not immediately available, then Pi can wait until all Pj have finished

When Pj is finished, Pi can obtain needed resources, execute, return allocated resources, and terminate

•

When Pi terminates, Pi +1 can obtain its needed resources, and so on

Customer

A

Used

1

Max need

6

Current need

5 12

B

1

5

4

C

2

4

2

D

4

7

3

Available units = 2 (Safe state)

Customer

Used

Max need

Current need

A

1

6

5

B

2

5

3

C

2

4

2

D

4

7

3

Available units = 1 (Unsafe state) One process should releases resources at that time

Resource allocation graph in safe and unsafe state 1. Safe state

13

2. Unsafe state

Safe, unsafe and deadlocked state spaces:-

 If a system is in safe state no deadlocks

 



If a system is in unsafe state possibility of deadlock Avoidance sure that a system will never enter an unsafe state.

14

Resource allocation graph algorithms:Single instance of a resource type -

Use a resource-allocation graph algorithm

Multiple instances of a resource type -

Use the banker’s algorithm

2. Resource allocation graph algorithm

 

Suppose that process Pi requests a resource Rj The request can be granted only if converting the request edge to an assignment edge does not result in the formation of a cycle in the resource allocation graph

3. banker’s algorithm This algorithm can be used in a banking system to ensure that the bank never allocates its available cash such that it can no longer satisfy the needs of its customers.

   

Multiple instances When a process requests a resource it may have to wait When a process gets all its resources it must return them in a finite amount of time Banker’s algorithm uses two tests whenever a process makes a request:

Feasibility test: a request is feasible if no. of requested units is less then no. of free units at that time.

Safety test: a request is safe if after granting the request, there exist at least one sequence of resource allocation.

Data structures used for banker’s algorithm Let n=number of process and m=number of resources types 1. Available: Vector of length m. If available [j] = k, there are k instances of resource type Rj available 2. Max: n x m matrix. If Max [i,j] = k, then process Pi may request at most k instances of resource type Rj 15

3. Allocation: n x m matrix. If Allocation[i,j] = k then Pi is currently allocated k instances of Rj 4. Need: n x m matrix. If Need[i,j] = k, then Pi may need k more instances of Rj to complete its task Need [i,j] = Max[i,j] – Allocation [i,j]

Resource-request algorithm for process pi Request = request vector for process Pi. If Requesti [j] = k then process Pi wants k instances of resource type Rj 1. If Requesti Needi go to step 2. Otherwise, raise error condition, since process has exceeded its maximum claim 2. If Requesti Available, go to step 3. Otherwise Pi must wait, since resources are not available 3. Pretend to allocate requested resources to Pi by modifying the state as follows: Available = Available – Request; Allocationi = Allocationi + Requesti; Needi = Needi – Requesti; If safe If unsafe

the resources are allocated to Pi

Pi must wait, and the old resource-allocation state is restored.

Example of banker’s algorithm 5 processes P0 through P4; 3 resource types: A (10 instances), B (5instances), and C (7 instances) Snapshot at time T0: Allocation

Max

Available 16



ABC

ABC

ABC

P0

010

753

332

P1

200

322

P2

302

902

P3

211

222

P4

002

433

The content of the matrix Need is defined to be Max – Allocation Need ABC



P0

743

P1

122

P2

600

P3

011

P4

431

The system is in a safe state since the sequence < P1, P3, P4, P2, P0> satisfies safety criteria

When p1 request(1,0,2) Check that Request Available (that is, (1, 0, 2) (3, 3, 2) true

P0

Allocation

Need

Available

ABC

ABC

ABC

010

743

230 17

P1

302

020

P2

301

600

P3

211

011 4

P4

002

3 1

 Executing safety algorithm shows that sequence < P1, P3, P4, P0, P2> satisfies safety requirement

Deadlock detection Allow system to enter deadlock state Detection algorithm Recovery scheme

Single instance of each resource type:-

 







Maintain wait-for graph Nodes are processes PiPj if Pi is waiting for Pj

Periodically invoke an algorithm that searches for a cycle in the graph. If there is a  cycle, there exists a deadlock 2

An algorithm to detect a cycle in a graph requires an order of n operations, where n is the number of vertices in the graph

Resource allocation graph and wait for graph

Wait for graph (WAG) can be obtained from RAG by removing resource nodes and 18

adding the appropriate edge.

Resource allocation graph

Wait for graph

Several instances of a resource type:1. Available: A vector of length m indicates the number of available resources of each type. 2. Allocation: An n x m matrix defines the number of resources of each type currently allocated to each process. 3. Request: An n x m matrix indicates the current request of each process. If Request [ij] = k, then process Pi is requesting k more instances of resource type. Rj.

Detection algorithm 1. Let Work and Finish be vectors of length m and n, respectively. Initialize Work= Available. For i= 0, 1, ... n, if Allocation 0, then Finish[i] =false; otherwise, Finish[i] = true. 2. Find an index i such that both a. Finish[i] ==false b. Request i Work If no such i exists, go to step 4.

19

3. Work= Work+ Allocation; Finish[i] = true, Go to step 2.

4. If Finish[i] ==false for some i, 1 i n, then the system is in a deadlocked state. Moreover, if Finish[i] ==false, then process P; is deadlocked. This algorithm requires an order of m x n2 operations to detect whether the system is in a deadlocked state. If detection algorithm is invoked arbitrarily, there may be many cycles in the resource graph and so we would not be able to tell which of the many deadlocked processes “caused” the deadlock

Example of deadlock detection Five

P4; processes P0 through three resource A (7 instances), B (2 instances), and C (6 instances)

types

Snapshot at time T0:

P0 P1 P2

Allocation

Request

Available

ABC

ABC

ABC

010

000

000

200 303

202 000

P3

211

100

P4

002

002

Sequence will result in Finish[i] = true for all i

P2 requests an additional instance of type C

20

Request ABC P0

000

P1

201

P2

001

P3

100

P4

002

State of system o Can reclaim resources held by process P0, but insufficient resources to fulfil other processes; requests o Deadlock exists, consisting of processes P1, P2, P3, and P4

5. RECOVERY FROM DEADLOCK 21

When a detection algorithm determines that a deadlock exists, several alternatives are available. One possibility is to inform the operator that a deadlock has occurred and to let the operator deal with the deadlock manually. Another possibility is to let the system recover from the deadlock automatically. There are two options for breaking a deadlock one is simply to abort one or more processes to break the circular wait. The other is to pre-empt some resources from one or more of the deadlocked processes. 1. Process Termination-To eliminate deadlocks by aborting a process, we use one of two methods. In both methods, the system reclaims all resources allocated to the terminated processes.  Abort all deadlocked processes-This method clearly will break the deadlock cycle, but at great expense; the deadlocked processes may have computed for a long time, and the results of these partial computations must be discarded and probably will have to be recomputed later.  Abort one process at a time until the deadlock cycle is eliminated. This method incurs considerable overhead, since after each process is aborted, a deadlock-detection algorithm must be invoked to determine whether any processes are still deadlocked. In which order should we choose to abort? o Priority of the process o How long process has computed, and how much longer to completion o Resources the process has used o Resources process needs to complete o how many processes will need to be terminated o Is process interactive or batch? 2. Resource pre emption To eliminate deadlocks using resource pre-emption, we successively pre-empt some resources from processes and give these resources to other processes until the deadlock cycle is broken. If pre-emption is required to deal with deadlocks, then three issues need to be addressed: Selecting a victim- Which resources and which processes are to be pre-empted? As in process termination, we must determine the order of pre-emption to minimize cost. Cost factors may include such parameters as the number of resources a deadlocked process is holding and the amount of time the process has thus far consumed during its execution. 22

Rollback- If we pre-empt a resource from a process, what should be done with that process? Clearly, it cannot continue with its normal execution; it is missing some needed resource. We must roll back the process to some safe state and restart it from that state. Since, in general, it is difficult to determine what a safe state is, the simplest solution is a total rollback: abort the process and then restart it. Although it is more effective to roll back the process only as far as necessary to break the deadlock, this method requires the system to keep more information about the state of all running processes. Starvation- How do we ensure that starvation will not occur? That is, how can we guarantee that resources will not always be pre-empted from the same process?

5. CONCLUSION 23

 Deadlock is occurring due to non-preemptable resources.  We may be able to break a dead-lock by having a few additional copies of a resource. When one copy is taken, there is always another copy of that resource.  A deadlocked state occurs when two or more processes are waiting indefinitely for an event that can be caused only by one of the waiting processes.  A method for avoiding deadlocks, rather than preventing them, requires that the operating system have a priori information about how each process will utilize system resources.  Researchers have argued that none of the basic approaches alone is appropriate for the entire spectrum of resource-allocation problems in operating systems. The basic approaches can be combined, however, allowing us to select an optimal approach for each class of resources in a system.

REFERENCES 24

Silberschatz, Galvin, Gagne Operating System Concepts, 8th Edition OS_William_Stalling_Sandy http://codex.cs.yale.edu/avi/os-book/OS8/os8c/deadlock.html http://highered.mcgraw-hill.com/sites/0070702039/student_view0/index.html

25