deadlock for any system, Lecture notes of Operating Systems

Download deadlock for any system and more Lecture notes Operating Systems in PDF only on Docsity!

Operating System Concepts – 9th^ Edition Silberschatz, Galvin and Gagne^ ©^2013

Chapter 7: Deadlocks

Chapter 7: Deadlocks

 (^) System Model  (^) Deadlock Characterization  (^) Methods for Handling Deadlocks  (^) Deadlock Prevention  (^) Deadlock Avoidance  (^) Deadlock Detection  (^) Recovery from Deadlock

System Model

 (^) System consists of resources  (^) Resource types R 1 , R 2 ,.. ., Rm CPU cycles, memory space, I/O devices  (^) Each resource type Ri has Wi instances.  (^) Each process utilizes a resource as follows:  (^) request  (^) use  (^) release

Deadlock Characterization

 (^) Mutual exclusion: only one process at a time can use a resource  (^) Hold and wait: a process holding at least one resource is waiting to acquire additional resources held by other processes  (^) No preemption: a resource can be released only voluntarily by the process holding it, after that process has completed its task  (^) Circular wait: there exists a set {P 0 , P 1 , …, Pn} of waiting processes such that P 0 is waiting for a resource that is held by P 1 , P 1 is waiting for a resource that is held by P 2 , …, Pn– is waiting for a resource that is held by Pn, and Pn is waiting for a resource that is held by P 0. Deadlock can arise if four conditions hold simultaneously.

Resource-Allocation Graph

 (^) V is partitioned into two types:  (^) P = {P 1 , P 2 , …, Pn}, the set consisting of all the processes in the system  (^) R = {R 1 , R 2 , …, Rm}, the set consisting of all resource types in the system  (^) request edge – directed edge Pi  Rj  (^) assignment edge – directed edge Rj  Pi

A set of vertices V and a set of edges E.

Resource-Allocation Graph (Cont.)

 (^) Process  (^) Resource Type with 4 instances  (^) Pi requests instance of Rj  (^) Pi is holding an instance of Rj Pi Pi Rj Rj

Resource Allocation Graph With A Deadlock

Graph With A Cycle But No Deadlock

Methods for Handling Deadlocks

 (^) Ensure that the system will never enter a deadlock state:  (^) Deadlock prevention  (^) Deadlock avoidence  (^) Allow the system to enter a deadlock state and then recover  (^) Ignore the problem and pretend that deadlocks never occur in the system; used by most operating systems, including UNIX

Deadlock Prevention

 (^) Mutual Exclusion – not required for sharable resources (e.g., readonly files); must hold for nonsharable resources  (^) 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 allocated to it.  (^) Low resource utilization; starvation possible Restrain the ways request can be made

Deadlock Example

/* thread one runs in this function */ void do_work_one(void param) { pthread_mutex_lock(&first_mutex); pthread_mutex_lock(&second_mutex); / * Do some work / pthread_mutex_unlock(&second_mutex); pthread_mutex_unlock(&first_mutex); pthread_exit(0); } / thread two runs in this function */ void do_work_two(void param) { pthread_mutex_lock(&second_mutex); pthread_mutex_lock(&first_mutex); / * Do some work */ pthread_mutex_unlock(&first_mutex); pthread_mutex_unlock(&second_mutex); pthread_exit(0); }

Deadlock Example with Lock Ordering void transaction(Account from, Account to, double amount) { mutex lock1, lock2; lock1 = get_lock(from); lock2 = get_lock(to); acquire(lock1); acquire(lock2); withdraw(from, amount); deposit(to, amount); release(lock2); release(lock1); } Transactions 1 and 2 execute concurrently. Transaction 1 transfers $ from account A to account B, and Transaction 2 transfers $50 from account B to account A

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 <P 1 , P 2 , …, Pn> of ALL the processes in the systems such that for each Pi, 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

Basic Facts

 (^) If a system is in safe state  no deadlocks  (^) If a system is in unsafe state  possibility of deadlock  (^) Avoidance  ensure that a system will never enter an unsafe state.