Operating Systems

Deadlock

Ahmad Yoosofan

Spring 2023

University of Kashan

yoosofan@mail.com

Deadlock in real situations

Resource-Allocation Graph

The set of Processes: P = {P₀, P₁, P₂}
The set of Resources: R = {R₀, R₁, R₂, R₃}
The set of Edges: E = {
- R₀ → P₀,

Resource-Allocation Graph

The set of Processes: P = {P₀, P₁, P₂}
The set of Resources: R = {R₀, R₁, R₂, R₃}
The set of Edges: E = {
- R₀ → P₀,
- R₁ → P₀,
}

Request

The set of Processes: P = {P₀, P₁, P₂}
The set of Resources: R = {R₀, R₁, R₂, R₃}
The set of Edges: E = {
- R₀ → P₀,
- R₁ → P₀,
- P₁ → R₁,
}

Resource-Allocation Graph

The set of Processes: P = {P₀, P₁, P₂}
The set of Resources: R = {R₀, R₁, R₂, R₃}
The set of Edges: E = {
- R₀ → P₀,
- R₁ → P₀,
- P₁ → R₁,
- R₂ → P₁,
- R₃ → P₂
}

Deadlock Example

Wait-For Graph

Resource-Allocation Graph	Wait-For Graph

Multiple Instances

The set of Processes; P = {P₀, P₁, P₂}
The set of Resources; R = {R₀, R₁, R₂, R₃}
The set of Edges ; E = {
- R₀ → P₀,
- R₁ → P₀,
- P₁ → R₁,
- R₂ → P₁,
- R₃ → P₂
- }
One instances of resource type R0
Two instances of resource type R1
One instances of resource type R2
Three instances of resource type R3

Deadlock

Non deadlock	Deadlock

Deadlock

Non deadlock	Deadlock

Necessary Conditions of deadlock

Mutual exclusion
Hold and wait
No preemption
Circular wait
- R0 < R1 < R2 < ... < Rm

Deadlock Detection

Single Instance of Each Resource Type
- Finding loop in a graph
Several Instances of a Resource Type
- Available. A vector of length m indicates the number of available resources of each type.
  - Avail = [ R₀, R₁, ... , R_m ]
- Allocation. An (n * m) matrix defines the number of resources of each type currently allocated to each 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.

Example of Resource-Allocation

Resources =

R₀	R₁	R₂	R₃
2	1	2	2

Avaiable =

R₀	R₁	R₂	R₃
0	0	0	1

Allocation =

	R₀	R₁	R₂	R₃
P₀	1	0	0	0
P₁	1	1	0	0
P₂	0	0	1	0
P₃	0	0	1	1

Request =

	R₀	R₁	R₂
P₀	0	1	0
P₁	0	0	1
P₂	1	0	0
P₃	0	0	0

Example of Resource-Allocation

Resources =

R₀	R₁	R₂	R₃
2	1	2	2

Avaiable =

R₀	R₁	R₂	R₃
0	0	0	1

Allocation =

	R₀	R₁	R₂	R₃
P₀	1	0	0	0
P₁	1	1	0	0
P₂	0	0	1	0
P₃	0	0	1	1

Request =

	R₀	R₁	R₂
P₀	0	1	0
P₁	0	0	1
P₂	1	0	0
P₃	0	0	0

Process 3
- finish[3] == false and Request[3] ≤ work
- finish[3] = true; work += Allocatin[3];
- work = { 0, 0, 1, 2 }

Example of Resource-Allocation

Resources =

R₀	R₁	R₂	R₃
2	1	2	3

Avaiable =

R₀	R₁	R₂	R₃
0	0	0	1

Allocation =

	R₀	R₁	R₂	R₃
P₀	1	0	0	0
P₁	1	1	0	0
P₂	0	0	1	0
P₃	0	0	1	1

Request =

	R₀	R₁	R₂
P₀	0	1	0
P₁	0	0	1
P₂	1	0	0
P₃	0	0	0

Process 3
- finish[3] == false and Request[3] ≤ work
- finish[3] = true; work += Allocation[3];
- work = { 0, 0, 1, 2 }
Process 1
- finish[1] == false and Request[1] ≤ work
- finish[1] = true; work += Allocation[1];
- work = { 1, 1, 1, 2 }

Example of Resource-Allocation

Resources =

R₀	R₁	R₂	R₃
2	1	2	3

Avaiable =

R₀	R₁	R₂	R₃
0	0	0	1

Allocation =

	R₀	R₁	R₂	R₃
P₀	1	0	0	0
P₁	1	1	0	0
P₂	0	0	1	0
P₃	0	0	1	1

Request =

	R₀	R₁	R₂
P₀	0	1	0
P₁	0	0	1
P₂	1	0	0
P₃	0	0	0

Process 3
- finish[3] == false and Request[3] ≤ work
- finish[3] = true; work += Allocation[3];
- work = { 0, 0, 1, 2 }
Process 1
- finish[1] == false and Request[1] ≤ work
- finish[1] = true; work += Allocation[1];
- work = { 1, 1, 1, 2 }
Process 2
- finish[2] == false and Request[2] ≤ work
- finish[2] = true; work += Allocation[2];
- work = { 1, 1, 2, 2 }

Example of Resource-Allocation

Resources =

R₀	R₁	R₂	R₃
2	1	2	2

Avaiable =

R₀	R₁	R₂	R₃
0	0	0	1

Allocation =

	R₀	R₁	R₂	R₃
P₀	1	0	0	0
P₁	1	1	0	0
P₂	0	0	1	0
P₃	0	0	1	1

Request =

	R₀	R₁	R₂
P₀	0	1	0
P₁	0	0	1
P₂	1	0	0
P₃	0	0	0

Process 3
- finish[3] == false and Request[3] ≤ work
- finish[3] = true; work += Allocation[3];
- work = { 0, 0, 1, 2 }
Process 1
- finish[1] == false and Request[1] ≤ work
- finish[1] = true; work += Allocation[1];
- work = { 1, 1, 1, 2 }
Process 2
- finish[2] == false and Request[2] ≤ work
- finish[2] = true; work += Allocation[2];
- work = { 1, 1, 2, 2 }
Process 0
- finish[0] == false and Request[0] ≤ work
- finish[0] = true; work += Allocation[0];
- work = { 2, 1, 2, 2 }
Sequence of execution: 3, 1, 2, 0
Sequence of execution: 3, 1, 0, 2

Deadlock Example 1

Resources

R₀	R₁	R₂	R₃
2	1	2	2

Avaiable

R₀	R₁	R₂	R₃
0	0	0	1

Allocation

	R₀	R₁	R₂	R₃
P₀	1	0	0	0
P₁	1	1	0	0
P₂	0	0	1	0
P₃	0	0	1	1

Request

	R₀	R₁	R₂
P₀	0	1	0
P₁	0	0	1
P₂	1	0	0
P₃	0	1	0

There is no process which its Request[i] ≤ work

Deadlock Example 2

Resources

R₀	R₁	R₂	R₃
2	1	2	2

Avaiable

R₀	R₁	R₂	R₃
0	0	0	2

Allocation

	R₀	R₁	R₂
P₀	1	0	0
P₁	1	1	0
P₂	0	0	2
P₃	0	0	0

Request

	R₀	R₁	R₂	R₃
P₀	0	1	0	0
P₁	0	0	1	0
P₂	1	0	0	0
P₃	0	0	0	1

Process P3: Request[3] ≤ work ⇒ work = { 0 , 0 , 0 , 2 }
There is not another process which satisfy in this conditoin. P₀, P₁, and P₂ are in deadlock

Deadlock

Initialize Work = Available.

     for i in range(0, n): 
       if Allocation[i] <> 0:  Finish[i] = false. 
       else: Finish[i] = true.

Find an index i such that: (a) Finish[i] == false (b) Request[i] ≤ Work
If no such i exists, go to step 4.
Work += Allocation[i] and Finish[i] = true
Go to step 2.
If Finish[i] == false for some i, 0 ≤ i < n, then the system is in a deadlock

Deadlock detection (Psudo C++ code)

/* ********************* 1   ************************** */
bool finish[N]; int work[M];  int i,j; bool flag=true;
work = Available
for(i=0; i<N; i++)
  if(Allocation[i]!=0)    finish[i]=false;
  else                    finish[i]=true;
/* ********************* 2   ************************** */
flag=true;
while(flag==true){
  flag=false;
  for(i=0;i<N;i++)
    if( (finish[i] == false) && (Request[i] <= work){
          finish[i]=true;
          work += Allocation[i];
          flag=true;
        }
    }
}/* ********************* 3   ************************** */
flag = false;
for(i=0;i<N; i++)
  if(finish[i] == false){ flag=true;    cout<<"process "<<i<<" is deadlocked."<<endl;  }
if(flag==true)  cout<<"The system is deadlocked"<<endl;
else cout<<"The system is not deadlocked"<<endl;

Deadlock detection (Python code)

N = 100 # number of Processes
M = 200 # number of Resources
Available = [0] * M # array(M)
Allocation = [[0] * M] * N # array(N,M)
Request = [[0] * M] * N # array(N,M)
################################################
finish  = [False] * N #array(N)
work = Available.copy()
flag = True
for i in range(0, N):
  if all(k == 0 for k in Allocation[i]):
    finish[i] = True
################################################
while flag == True:
  flag = False
  for i in range(0, N):
    if finish[i] == False and all(k<=m for k, m in zip(Request[i], work)):
      finish[i] = True
      work = [x+y for x, y in zip(work, Allocation[i])]
      flag = True
################################################
deadlocked = [i for i in range(0, N) if finish[i] == False]
if len(deadlocked) !=0:
  print("The system is deadlocked")
else:
  print("The system is not deadlocked")

Recovery from Deadlock

Process Termination
1. Abort all deadlocked processes.
2. Abort one process at a time until the deadlock cycle is eliminated.
  1. What the priority of the process is
  2. How long the process has computed and how much longer the process will compute before completing its designated task
  3. How many and what types of resources the process has used (for example, whether the resources are simple to preempt)
  4. How many more resources the process needs in order to complete
  5. How many processes will need to be terminated
  6. Whether the process is interactive or batch
Resource Preemption
1. Selecting a victim.
2. Rollback.
3. Starvation.

Other Considerations about Dead Lock Detection

When do we run Deadlock Detection Algorithm?
Types of Schedular:
1. Long term Schedular
2. Mid term Schedular
3. Short term Schedular (CPU Schedular)
This Algorithm is Time Consuming
All well-known Operating Systems does not use it
Deadlock Ignorance

Deadlock Avoidance(Banker's Algorithm) 1

MAX =

	R₀	R₁	R₂
P₀	1	1	0
P₁	0	1	1
P₂	1	0	1

Claim edge

Deadlock Avoidance(Banker's Algorithm) 2

MAX =

	R₀	R₁	R₂
P₀	1	1	0
P₁	0	1	1
P₂	1	0	1

Need = MAX - Allocation

Need =

	R₀	R₁	R₂
P₀	0	1	0
P₁	0	0	1
P₂	1	0	0

Avaiable=[ 0 , 0 , 0 ]

Need =

	R₀	R₁	R₂
P₀	0	1	0
P₁	0	0	1
P₂	1	0	1

Avaiable=[ 0 , 0 , 1 ]
Safe Sequence P1 , P0 , P2

Safety Algorithm

Variables
1. int work[m] = Avaiable
2. bool Finish[n]={false}
3. int Need[n][m] = MAX - Allocation
while exists i such that ( (Finish[i] == false) and ( Need[i] ≤ Work) )
1. Work = Work + Allocation[i]
2. Finish[i] = true
If Finish[i] ==true for all i, then the system is in a safe state.

Resource-Request Algorithm

If Request_i ≤ Need_i;, go to step 2. Otherwise, raise an error condition, since the process has exceeded its maximum claim.
If Request_i ≤ Available, go to step 3. Otherwise, P; must wait, since the resources are not available.
Have the system pretend to have allocated the requested resources to process P; by modifying the state as follows:
- Available= Available- Request_i
- Allocation_i =Allocation_i +Request_i
- Need_i =Need_i - Request_i
If the resulting resource-allocation state is safe, the transaction is completed, and process P; is allocated its resources. However, if the new state is unsafe, then P; must wait for Request;, and the old resource-allocation state is restored

END

\Gamma(t) = \lim_{n \to \infty} \frac{n! \; n^t}{t \; (t+1)\cdots(t+n)}= \frac{1}{t} \prod_{n=1}^\infty \frac{\left(1+\frac{1}{n}\right)^t}{1+\frac{t}{n}} = \frac{e^{-\gamma t}}{t} \prod_{n=1}^\infty \left(1 + \frac{t}{n}\right)^{-1} e^{\frac{t}{n}}

\begin{matrix} R_{0} & R_{1} & R_{2} & R_{3} \\ P_{0} & \begin{matrix} 1 & 0 & 1 \\ 1 & 2 & 3 \\ 1 & 0 & 1 \end{matrix} \\ P_{1} \\ P_{2} \end{matrix}

الگوریتم تخصیص منابع

اگر Need ≤ Request آن‌گاه خطایی را ایجاد کن زیرا فرایند بیشتر از مقدار حداکثری که گفته است منبع می‌خواهد دریافت کند وگرنه به گام ۲ برو
اگر فرایندی با شمارهٔ i یافت شد که Request_i ≤ Available, باشد آن‌گاه به گام ۳ برو وگرنه فرایند i ام باید منتظر بماند زیرا منبع درخواستی‌اش در دسترس نیست.
فرض می‌کنیم که منابع مورد نیاز فرایند را در اختیارش بگذاریم یعنی کارهای زیر را انجام دهیم
- Available= Available- Request_i
- Allocation_i =Allocation_i +Request_i
- Need_i =Need_i - Request_i
الگوریتم امن بودن را روی وضعیت شبیه‌سازی شدهٔ کنونی اجرا می‌کنیم
اگر وضعیت امن بود تخصیص واقعی را انجام می‌دهیم وگرنه تخصیص را انجام نمی‌دهیم و وضعیت آرایه‌ها و ماتریس‌ها را به حالت پیش از تغییر در گام ۳ برمی‌گردانیم