Deadlock Detection Algorithm in Operating System

If a system does not employ either a deadlock prevention or deadlock avoidance algorithm then a deadlock situation may occur. In this case-

- Apply an algorithm to examine state of system to determine whether deadlock has occurred or not.
- Apply an algorithm to recover from the deadlock. For more refer- Deadlock Recovery

**Deadlock Avoidance Algorithm/ ****Bankers Algorithm****:**

The algorithm employs several times varying data structures:

**Available –**

A vector of length m indicates the number of available resources of each type.**Allocation –**

An n*m matrix defines the number of resources of each type currently allocated to a process. Column represents resource and resource represent process.**Request –**

An n*m matrix indicates the current request of each process. If request[i][j] equals k then process P_{i}is requesting k more instances of resource type R_{j}.

**This algorithm has already been discussed ****here **

Now, Bankers algorithm includes a **Safety Algorithm / Deadlock Detection Algorithm **

The algorithm for finding out whether a system is in a safe state can be described as follows:

**Steps of Algorithm:**

- Let
*Work*and*Finish*be vectors of length m and n respectively. Initialize*Work= Available*. For*i=0, 1, …., n-1*, if*Request*= 0, then_{i}*Finish[i]*= true; otherwise,*Finish[i]*= false. - Find an index i such that both

a)*Finish[i] == false*

b)*Request*_{i}<= Work

If no such*i*exists go to step 4. *Work= Work+ Allocation*_{i}*Finish[i]= true*

Go to Step 2.- If
*Finish[i]== false*for some i, 0<=i<n, then the system is in a deadlocked state. Moreover, if*Finish[i]==false*the process P_{i}is deadlocked.

For example,

- In this, Work = [0, 0, 0] &

Finish = [false, false, false, false, false]

*i=0*is selected as both Finish[0] = false and [0, 0, 0]<=[0, 0, 0].

- Work =[0, 0, 0]+[0, 1, 0] =>[0, 1, 0] &

Finish = [true, false, false, false, false].

*i=2*is selected as both Finish[2] = false and [0, 0, 0]<=[0, 1, 0].- Work =[0, 1, 0]+[3, 0, 3] =>[3, 1, 3] &

Finish = [true, false, true, false, false].

*i=1*is selected as both Finish[1] = false and [2, 0, 2]<=[3, 1, 3].- Work =[3, 1, 3]+[2, 0, 0] =>[5, 1, 3] &

Finish = [true, true, true, false, false].

*i=3*is selected as both Finish[3] = false and [1, 0, 0]<=[5, 1, 3].- Work =[5, 1, 3]+[2, 1, 1] =>[7, 2, 4] &

Finish = [true, true, true, true, false].

*i=4*is selected as both Finish[4] = false and [0, 0, 2]<=[7, 2, 4].

- Work =[7, 2, 4]+[0, 0, 2] =>[7, 2, 6] &

Finish = [true, true, true, true, true].

- Since Finish is a vector of all true it means
**there is no deadlock**in this example.