1. Practical Session 12 Deadlocks
Operating Systems
Practical Session 12
Deadlocks

2. Deadlocks
The ultimate form of starvation. A set of processes is deadlocked if each process in the set is waiting for an event that only another process in the set can cause.

3. Essential Conditions for Deadlock
Mutual exclusion – resources may be used by only one process
Hold and wait – a process can request a resource while holding one
No preemption - only the process holding a resource can release it
Circular wait - two or more processes each waiting for a resource held by the other

4. Solving the Deadlock Problem
The Ostrich ‘Algorithm’ – Ignore the problem
Deadlock Detection & Recovery – Detect a deadlock by finding a cyclic graph of processes and resources, and recover
Deadlock Avoidance – Detect safe and unsafe states; Banker’s algorithm
Deadlock Prevention – Ensure that at least one of the four conditions for a deadlock is never satisfied

5. Question 1
Assume resources are ordered as: R1, R2,...Rn Prove formally that if processes always request resources by order (i.e. if a process requests Rk after Rj then k>j) then a deadlock will not occur. For simplicity assume resources are unique. That is, there is a single unit of each resource.

6. Question 1 – a simple example
There are 2 processes P1 ,P2 and resource R1 ,R2. P1 has R1 and P2 has R2. P1 requests R2 and is now waiting for P2 to release it. For a deadlock to occur P2 needs to request R1. However, this is in contrast to the assumption that resources can only be requested in ascending order. That is, condition 4 (Circular wait) is prevented if resources are requested in ascending order.

7. Question 1 – a more formal proof
Let P1,...,Pn denote the processes in the system and R1,…Rk the resources. Falsely assume that a deadlock may occur in this system. Specifically, for a deadlock to occur a subset Pi1,...,Pim of {P1,...,Pn} which satisfies the following condition must exist: Pi1 -> (Rj,1)->Pi2 - (Rj,2)->...-> (Rj,m-1)->Pim -> (Rj,m)->Pi1 (*) Where Pi -> Rk->Pj is used to describe the following relation: Pi requests a resource Rk held by Pj.

8. Question 1 – a more formal proof
Each process Pi,s , (s≠1) holds resource Rj,s-1 and requests resource Rj,s. This means that j,s-1<j,s for any s (since the resources are numbered, and are requested in an ascending order).
We receive the following inequality which defines the resource ordering: j,1<j,2<...<j,m.
In a deadlock, eq. (*) must hold.
Thus we conclude that j,m<j,1 and j,1<j,m.
That is, a circular wait is not possible and the system is deadlock- free.
We use j,s to provide an index to some unknown resource.

9. Question 1 – Simple Explanation
Lets assume we have a deadlock. A circular wait must therefore exist:
Pi1 - (Rj,1)->Pi2 - (Rj,2)->Pi3 - (Rj,3)->...- (Rj,m-1)->Pim - (Rj,m)->Pi1    (*)
One of these resources’ index is the largest of all resources indices listed. It doesn’t matter which one. Lets assume its Rj,2 (since we deal with a circle it doesn’t matter which one we pick).
Pi2 -> (Rj,2)->Pi3 -> (Rj,3)->… (*)
This resource is held by process Pi3, process Pi2 is asking for it, and Pi3 requires Rj3 at the same time.
Lets look at Rj3:
If j3 > j2 : this contradicts Rj2 being the largest index resource.
If j3 = j2 : it makes no sense Pi3 is asking for a resource it already has? It breaks the waiting circle.
If j3 < j2 : this contradicts the fact that processes ask for resources only in ascending order.
Contradictions in every scenario means that our initial assumption of deadlock is false!
This explanation holds because (*) is a circular wait. This means that following the largest index resource must be another process that holds another resource. Observing these two resources contradicts the initial deadlock assumption.

10. The Dining Philosophers Problem
Philosophers think and eat every now and then
2 forks are required for eating
There aren’t enough forks

11. Dining Philosophers: a possible implementation
Semaphore fork[N]; procedure pick_sticks(i) down(fork[LEFT]); down(fork[RIGHT]); procedure put_sticks(i) up(fork[RIGHT]); up(fork[LEFT]);

12. Dining Philosophers: deadlock-free implementation
 test(int i)
    {
        if (state[Left] != eating
            && state[Right] != eating
            && state[i] == hungry) {
            // indicate that I’m eating
            state[i] = eating;
            // signal() has no effect during Pickup(),
            // but is important to wake up waiting
            // hungry philosophers during Putdown()
            self[i].signal();
        }
    }
Pickup(int i)
    {
        // indicate that I’m hungry
        state[i] = hungry;
        // set state to eating in test()
        // only if my left and right neighbors
        // are not eating
        test(i);
        // if unable to eat, wait to be signaled
        if (state[i] != eating)
            self[i].wait;
    }
    
Putdown(int i)
    {
        // indicate that I’m thinking
        state[i] = thinking;
        // if right neighbor R=(i+1)%5 is hungry and
        // both of R’s neighbors are not eating,
        // set R’s state to eating and wake it up by
        // signaling R’s CV
        test(Left);
        test(Right);
    }

13. Banker’s Algorithm Safe – a state is said to be safe if
It is not deadlocked.
There is some scheduling order in which every process can run to completion even if all of them suddenly request their maximum number of resources immediately.

14. Banker’s Algorithm Resources: Vectors:
E - Number of Existing resources of each type.
P – Number of resources of each type in Possession by the processes.
A – Number of Available resources of each type.
Matrices: (rows are processes and columns are resources)
C – Current allocation matrix
R – Request matrix

15. Banker’s Algorithm
Look for a row in matrix R whose unmet resource needs are all smaller than or equal to A. If no such row exists, the system may eventually deadlock.
Assume the process of the row chosen finishes (which is possible). Mark that process as terminated and add all its resources to the A vector
Repeat steps 1 and 2 until either all processes are marked terminated, which means safe, or until a deadlock occurs, which means unsafe.

16. Question 4
Consider the following snapshot of a system with five processes (p1, ... p5) and four resources (r1, ... r4). r1 r2 r3 r4 2 1
currently Available resources
current allocation
max demand
still needs
Process r1 r2 r3 r4 p1 1 2 p2 7 5 p3 3 4 6 p4 p5

17. Question 4
a. Compute what each process still might request and fill in the “still needs” columns. b. Is this system currently deadlocked, or will any process become deadlocked? Use the baker’s algorithm to support your answer

18. Question 4 a) current allocation max demand still needs r1 r2 r3 r4 p1
Process r1 r2 r3 r4 p1 1 2 p2 7 5 p3 3 4 6 p4 p5 a)

19. Question 4 a) Not deadlocked and will not become deadlocked.
current allocation
max demand
still needs
Process r1 r2 r3 r4 p1 1 2 p2 7 5 p3 3 4 6 p4 p5 a)
Not deadlocked and will not become deadlocked.
Using the Banker’s algorithm, we determine the process execution order:
p1, p4, p5, p2, p3. b) r1 r2 r3 r4 2 1
currently available resources

20. Question 4
c. If a request from p3 arrives for (0, 1, 0, 0), can that request be safely granted immediately? In what state (deadlocked, safe, unsafe) would immediately granting the request leave the system? Which processes, if any, are or may become deadlocked if this whole request is granted immediately?

21. Question 4 current allocation max demand still needs r1 r2 r3 r4 p1 1
Process r1 r2 r3 r4 p1 1 2 p2 7 5 p3 3 4 6 p4 p5 r1 r2 r3 r4 2
currently available resources

22. Question 4
c) Change available to (2, 0, 0, 0) and p3’s row of “still needs” to (6, 5, 2, 2). Now p1, p4, and p5 can finish. Available will now be (4, 6, 9, 8) meaning that neither p2 nor p3’s “still needs” can be satisfied. So, it is not safe to grant p3’s request. Correct answer NO. Processes p2 and p3 may deadlock.

23. Question 5 (7.6 from Silberschats)
If deadlocks are controlled (avoided) by applying the banker‘s algorithm, which of the following changes can be made safely and under what circumstances:
Increase Available (add new resources)
Decrease Available (remove resources)
Increase Max for one process
Increase the number of processes

24. Question 5
Increasing the number of resources available can't create a deadlock since it can only decrease the number of processes that have to wait for resources.
Decreasing the number of resources can cause a deadlock.

25. Question 5
From the Banker’s algorithm point of view, increasing the maximum claim of a process may turn a safe state into unsafe.
If the number of processes is increased, the state remains safe, since we can first run the “old”  processes, until they terminate, and release all their resources. Now , when all the system’s resources are free, we can choose a “new” process and give it all its demands. It will finish and again all the system’s resources will be free. Again, we choose a new process and give it all its demands , etc.

26. Question 6 (7.9 from Silberschats)
Consider a system consisting of m resources of the same type, being shared by n processes. Resources can be requested and released by processes only one at a time. Show that the system is deadlock free if the following two conditions hold: 1. Each process needs between 1 and m resources. 2. The sum of maximum needs is less than m+n.

27. Question 6
By contradiction, assume that the 4 conditions for deadlock exist in the system and thus there is a group of processes involved in a circular wait. Let these processes be P1,...,Pk, k≤n, their current demands be D1,...,Dk and the number of resources each of them holds be H1,...,Hk. The circular wait condition should look like: P1->P2->...->Pk->P1, but in fact it is simpler: Let M1,...,Mn be total (maximum) demands of processes P1,...,Pn. Then a circular wait can occur only if all resources are in use and every process hasn't acquired all its resources: H1+...+Hk=m and Di>=1 for 1≤ i≤k.

28. Question 6
Since Mi=Hi+Di, the sum of maximum demands of the processes involved in a circular wait is: M1+..+Mk≥m+k.
Note that the remaining processes’ Pk+1,...,Pn maximum demands
are at least 1:
Mi ≥ 1, k+1 ≤ i ≤ n and thus Mk Mn ≥ n-k .
The total sum of maximum demands is thus:
M1+...+Mn = M1+...+Mk+Mk Mn ≥ m+k+(n-k)=m+n.
It is defined that sum of all maximal needs is strictly less than m+n, thus we have a contradiction.

29. Question 6 – Intuitive Explanation
If we have a deadlock all resources are held by the various processes, otherwise some process can take a resource and “advance” and we are not in a deadlock . Therefore:
Every process needs at least 1 resource more, or else we don’t have a deadlock (it is free to “advance”). Therefore:
Total sum of maximum demands is:
This contradicts the assumption total sum of maximum demands is less than m+n.