Deadlocks (part II) Deadlock avoidance – (not reasonable) Deadlock detection Resource Allocation Graphs Resource Pool and Counting Semaphores Dining Philosophers Problem Condition Variables

Resource Tables

Deadlock Definition A deadlock is a situation in which two or more competing actions are each waiting for the other to finish, and thus neither ever does. P1 P2 P(R1) P(R2) P(R2) P(R1) CS CS V(R2) V(R1) V(R1) V(R2)

Deadlock 4 necessary conditions Mutual Exclusion – Processes claim exclusive control of the resources they require Wait For – processes hold resources already allocated to them while waiting for additional resources No Pre-emption – resources cannot be removed from the process using them until it is used to completion Circular Wait – A circular chain of processes exist in which each process holds one or more resources that are requested by the next process in the chain.

Deadlock Avoidance (reasonable?) Designing an Operating System (Linux, Windows, iOS, Android etc.) that avoids deadlocks would require removing at least 1 of the 4 necessary conditions of deadlock. Many systems programmers would argue that the removal of any one of these 4 would limit the system too much and the gain of having a deadlock-free system would not be worth it. Just like driving a car, which can on (hopefully rare) occasions get a flat tire, it is popular to design systems that may on rare occasions go into deadlock and the system detects and deals with the problem at that time.

Deadlock Detection We need a way to detect that 2 or more processes are in a deadlock. Allow the system to run normally and occasionally have the Operating System check for deadlocks. If a deadlock is detected, the Operation System should attempt to fix the situation as best as it can which includes asking the users of a deadlocked process to volunteer it killing their process which will return resources to the system, which will then end the deadlock.

Asking the user to end Deadlock

Review of Data Structures and Algorithms Graphs can be recorded in memory Algorithms can be run on graphs that answer questions: What is the shortest path from point A to point B? Is a graph fully connected (yes or no)? Does a graph contain a cycle (yes or no)? If an existing graph which doesn’t currently have a cycle, was to have an edge added to it, would the graph now have a cycle?

Representing Graphs in Memory Adjacency matrix

Representing Graphs in Memory Adjacency lists

Deadlock (DAG with a cycle) A deadlock is a situation in which two or more competing actions are each waiting for the other to finish, and thus neither ever does. P1 P2 P(R1) P(R2) P(R2) P(R1) CS CS V(R2) V(R1) V(R1) V(R2)

Resource Pool A collection of identical resources Ex) A room full of printers Computer Storage (on the stack or heap)

Counting Semaphores When a system has multiple identical copies of a resource, a Counting Semaphore can be used to allow mutual access to that pool of identical resources. S=8 P(S) { if (S > 0) { S = S - 1; } else OS moves the process to the queue waiting for S Update resource tables and the Resource Allocation Graph

Counting Semaphores And the V function for counting semaphores is V(S) { if (a process is waiting for an S) OS moves the process to the ready queue } else S = S + 1; Update the resource tables and the RAG )

RAG – Resource Allocation Graph (with counting Semaphores)

Dijkstra’s Banker’s Algorithm – Safe State Total common resources is 8

Bankers Algorithm - 2 Resource Pools (not in a Safe State)

P(S) using Dijkstra’s Banker’s Algorithm { if (System would stay in a Safe State) { S = S - 1; } else OS moves the process to the queue waiting for S Update resource tables and the Resource Allocation Graph

Dining Philosophers Problem It was originally formulated in 1965 by Edsger Dijkstra as a student exam exercise, presented in terms of computers competing for access to tape drive peripherals. Soon after, Tony Hoare gave the problem its present formulation.

Dining philosophers solution??? while(1) { P(chopstick i); P(chopstick ((i + 1) %n); EAT V(chopstick i); V(chopstick ((i + 1) %n); THINK } In order to deadlock, - all 5 philosophers must be involved. - all 5 just have the right chopstick and want the left

Avoid Deadlock – Dining philosophers Only allow 4 (n-1) philosophers to sit at the table (only 5-way cycles an happen…add variable to count Eaters) Only allow a philosopher to get both or none of the chopsticks (don’t allow hold and wait) Odd philosophers get right chopstick first left second and even get left first and right second. Add a 6th emergency chopstick. The point is Deadlocks for some apps may be avoided on a case by case basis

Ex: Second Cashier for long lines A market has a full-time cashier than handles customers. If the line get too long, a second part-time cashier snaps into action and start serving customers. We need the full-time cashier (that always runs) to wake up the part-time cashier when the line get too long (let’s say 5 customers) Part-time cashier will wait for a signal from the full-time cashier.

Condition Variables The value of a variable will determine if your process can proceed or must wait. Ex) full-time cashier always runs and part-time cashier only runs if the condition (customerCount >= 5) if true. This variable (i.e. customerCount) is referred to as a condition variable. You need obtain a mutex to access a condition variable. Based on that variable’s current value, part-time cashier should continue or wait.

Waiting while releasing condition variable Question: You access the mutex for the condition variable, based on it’s value, you may determine that you should wait…how do you release the mutex and make yourself wait? Full-time Cashier process while(1) { P(cc) if (customerCount >= 5) V(c5); } V(cc) // Handle customers P(cc); customerCount–; V(cc); Part-time cashier process while(1) { P(cc) if (customerCount < 5) { P(c5); } V(cc); // Handle Customers P(cc); customerCount–; V(cc);

Condition Variables Question: You access the mutex for the condition variable, based on it’s value, you determine that you should wait…how do you release the mutex and make yourself wait? Part-time cashier process while(1) { P(cc) if (customerCount < 5) CP(cc,c5); // release CC and wait on C5 atomically } V(cc); // Handle Customers

CP(S,C) Conditional Atomic Operation void CP(S,C) { V(S); // release the binary semaphore P(C); // wait on the conditional variable }