1 / 21

Deadlock 2

Deadlock 2. 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 a safe state if there exists a safe sequence of all processes

joyce
Download Presentation

Deadlock 2

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Deadlock 2

  2. 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 a safe state if there exists a safe sequence of all processes • Sequence <P0, P1, …, Pn> is safe if for eachPi, the resources that Pi can still request can be satisfied by currently available resources + resources held by all the Pj with j < i • If Pi‘sresource needs are not immediately available, thenPi can wait until all Pjhave finished • When Pjfinishes, Pi can obtain needed resources, execute, return allocated resources, and terminate • When Pi terminates, Pi+1 can obtain its needed resources, and so on

  3. Basic Facts • If system is in safe state no deadlock • If system is in unsafe state  possibility of deadlock • Avoidance  ensure that system will never enter an unsafe state

  4. Safe, Unsafe, Deadlock State

  5. Example AllocationMax P0 5 10 P1 2 4 P2 2 9 • Assume the system has 12 instances of the particular resource • Is the system currently in a safe or in an unsafe state?

  6. Example • Suppose that P2 requests and is allocated one more instance of the resource, still assume the system has 12 instances of the resource AllocationMax P0 5 10 P1 2 4 P2 3 9 • Is the system currently in a safe or in an unsafe state?

  7. Deadlock Avoidance • Requires that the system has some additional a prioriinformation available: • Simplest and most useful model requires that each process declare the maximum number of resources of each type that it may need • The deadlock-avoidance algorithm dynamically examines the resource-allocation state to ensure that there can never be a circular-wait condition • Resource-allocation state is defined by the number of available and allocated resources, and the maximum demands of the processes

  8. Avoidance algorithms • Single instance of a resource type • Use a resource-allocation graph • Multiple instances of a resource type • Use the banker’s algorithm

  9. Resource-Allocation Graph Algorithm • Can be used if we have a resource-allocation system with only one instance of each resource type. We just need ensure that no cycle exists • Claim edge Pi Rjindicates that processPi may request resource Rj; represented by a dashed line • Claim edge converts to request edge when a process requests a resource • Resources must be claimed a priori in the system

  10. Resource-Allocation Graph For Deadlock Avoidance Suppose P2 requests R2, can this request be granted?

  11. Resource-Allocation Graph For Deadlock Avoidance

  12. Resource-Allocation Graph Algorithm • Suppose that process Pi requests a resource Rj • The request can be granted only if converting the request edge to an assignment edge does not result in the formation of a cycle in the resource allocation graph

  13. Banker’s Algorithm • Multiple instances • Each process must a priori claim maximum use • When a process requests a resource it may have to wait • When a process gets all its resources it must return them in a finite amount of time

  14. Banker’s Algorithm • Toward right idea: • State maximum resource needs in advance • Allow particular process to proceed if: (available resources - #requested)  max remaining that might be needed by any process • Banker’s algorithm (less conservative): • Allocate resources dynamically • Evaluate each request and grant if some ordering of processes is still deadlock free afterward • Technique: pretend request is granted, and check to see if resulting state would be a SAFE state. Grant request if result is deadlock free (conservative!) • Keeps system in a SAFE state (i.e., there is always a safe sequence) • Algorithm allows the sum of maximum resource needs of all current processes to be greater than total resources

  15. Banker’s Algorithm: Example • 5 processes P0 through P4; 3 resource types R0 (10 instances), R1 (5 instances), and R2 (7 instances) • Snapshot at initial time: AllocationMax AvailableR0 R1 R2 R0 R1 R2 R0 R1 R2 P0 0 1 0 7 5 3 3 3 2 P1 2 0 0 3 2 2 P2 3 0 2 9 0 2 P3 2 1 1 2 2 2 P4 0 0 2 4 3 3 • Is the system in a safe state? • The system is in a safe state since the sequence <P1,P3,P4,P2,P0> satisfies safety criteria Need R0 R1 R2 7 4 3 1 2 2 6 0 0 0 1 1 4 3 1

  16. Banker’s Algorithm: Example • Suppose that P1 requests (1, 0, 2). Is it safe to honor this request? AllocationMax AvailableR0 R1 R2 R0 R1 R2 R0 R1 R2 P0 0 1 0 7 5 3 3 3 2 P1 2 0 0 3 2 2 P2 3 0 2 9 0 2 P3 2 1 1 2 2 2 P4 0 0 2 4 3 3 • Find the new state that the system would be in if this request is granted. If the new state is safe, then it is safe to grant this request. Otherwise, it is not safe to honor this request (safety algorithm)

  17. Banker’s Algorithm: Example • This is the new state that the system would be in if P1’s request is honored AllocationMaxAvailableR0 R1 R2 R0 R1 R2 R0 R1 R2 P0 0 1 0 7 5 3 2 3 0 P1 3 0 2 3 2 2 P2 3 0 2 9 0 2 P3 2 1 1 2 2 2 P4 0 0 2 4 3 3 • The sequence <P1,P3,P4,P0,P2> satisfies safety requirement, so it is safe to honor P1’s request • Can request for (3,3,0) by P4 be granted? • Can request for (0,2,0) by P0 be granted?

  18. Data Structures for the Banker’s Algorithm • Let n be the number of processes, and mbe the number of resource types • Available: Vector of length m. If Available[j]= k, there arek instances of resource type Rjavailable • Max:nxm matrix. If Max[i,j]= k, then process Pi may request at mostkinstances of resource type Rj • Allocation:nxm matrix. If Allocation[i,j]= k thenPi is currently allocated k instances of Rj • Need:nxm matrix. If Need[i,j]=k, thenPimay need k more instances ofRjto complete its task Need[i, j] = Max[i, j] – Allocation[i,j]

  19. Resource-Request Algorithm for Process Pi • Let Request be the request vector for process Pi. If Requesti[j] = k then process Pi wants k instances of resource type Rj 1. If Requesti Needigo to step 2. Otherwise, raise error condition, since process has exceeded its maximum claim 2. If Requesti Available, go to step 3. Otherwise Pimust wait, since resources are not available • Pretend to allocate requested resources to Pi by modifying the state as follows: Available = Available- Requesti Allocationi= Allocationi + Requesti Needi=Needi – Requesti • If safe  the resources are allocated toPi • If unsafe Pimust wait, and the old resource-allocation state is restored

  20. Safety Algorithm 1. Let Workand Finish be vectors of lengthm andn, respectively. Initialize: Work= Available Finish[i] = false fori = 0, 1, …, n 2. Find an isuch that Finish[i] = false AND Needi Work If no such iexists, go to step 4 3. Work = Work+ Allocationi Finish[i] = truego to step 2 4. If Finish[i] == true for all i, then the system is in a safe state

  21. Example Consider a computer system having 4 serially-reusable resource classes R0 (4 instances), R1 (3 instances), R2 (11 instances), and R3 (2 instances). There are 4 processes in the system P0 through P3. Assume that the maximum claim approach to deadlock avoidance is used. The current state is given by: AllocationMax R0 R1 R2 R3 R0 R1 R2 R3 P0 2 1 2 0 3 1 5 1 P1 1 0 4 1 2 2 6 2 P2 0 1 1 0 1 2 1 0 P3 0 0 3 0 1 1 7 1 Which of the following outstanding requests can be safely satisfied? Request R0 R1 R2 R3 P0 1 0 2 1 P1 0 1 0 1 P2 1 0 0 0 P3 0 0 1 1

More Related