Chapter 7 Deadlocks

1. Chapter 7Deadlocks

2. Deadlock • A state of indefinite waiting of a process • May occur when processes are competing for resources or when attempting to interact with one another. • Processes that are executing concurrently in a multiprogramming environment may often reach a state of starvation or deadlock. • Resources are not shared

3. Deadlock will occur when, four condition’s below becomes true. Mutual exclusion- Each resource is either currently allocated to exactly one process or it is available. (Two processes cannot simultaneously control the same resource or be in their critical section). Hold and Wait- processes currently holding resources can request new resources. No preemption- Once a process holds a resource, it cannot be taken away by another process or the kernel. Circular wait- Each process is waiting to obtain a resource which is held by another process.

4. Resource Allocation and Deadlock • System consists of resources • Resource types R1, R2, . . ., Rm CPU cycles, memory space, I/O devices • Each process utilizes a resource as follows: • Request a number of resource instances. If the resources requested are not available, then process must wait • Acquire resource(s), the OS allocates resources • Usethe resource(s) for a finite interval. • Release the resource(s).

5. Resource Allocation Graph with a Cycle • Two types of nodes represent a set of processes and resources • P = {P1, P2, …, Pn}, the set consisting of all the processes in the system • R = {R1, R2, …, Rm}, the set consisting of all resource types in the system • Two types of edges • request edge– directed edge From Pi  to Rj • assignment edge– directed edge From Rj to  Pi Suspended Processes that are either requesting or acquiring resources Suspended Suspended

6. Deadlock Problem • A set of blocked (suspended) processes • Each process holding one or more resources • Processes waiting to acquire one or more resources held by other processes

7. Multiple Resource Allocation Problem • Several processes may compete for multiple resources • If the allocation of multiple resources to processes is not done with proper synchronization, deadlock might occur • This waiting state is much more involved than starvation

8. Deadlock – General Definition • A set of processes is in a deadlock state when every processes in the set is waiting for an event that can only be caused by another process in the set. • The events of interest are: • allocations of resources • release of resources • The resources are: CPU cycles, memory spaces, files, I/O devices in the computer system.

9. Disadvantage Of Deadlock • Deadlocked processes can never completeexecution because they are waiting indefinitely • System resources are tiedup because they are held by deadlocked processes. • Deadlocks are undesirable because they normally slow downa system

10. Directed Edges • A request edge (Pi, Rj) from process Pi to resource Rj. Thus, Pi is waiting for an instance of resource type Rj. • An assignment edge (Rj, Pi) from resource Rj to process Pi. It indicates that an instance of Rj has been allocated to process Pi.

11. A Resource Allocation Graph These conditions are necessary but not sufficient for deadlock to occur. His means that even if the four conditions are present, deadlock may not actually occur. The present of process conditions implies that there is potential for deadlock. P2 is waiting request from R3 P1 is waiting request from R2 P2 has acquired an instance of resource type R2; So P1 holds a unit of resources R1. P1 has acquired an instance of resource type R1; So P1 holds a unit of resources R1.

12. Another Resource Allocation Graph • P3 requesting resource R1 and there are two instances of resources R1 and assume one instance is immediately allocated to P3, since the system has two instances of resources R1. • Now, P2 is also requesting an instance of resources R1, and P2 must wait for availability of resource R1. • The following cycle can be identified in the graph that there is no deadlock.

13. Solution to Deadlock • There are several ways to address the problem of deadlock in an operating system. (Just ignore it and hope it doesn't happen) • Detection and recovery - if it happens, take action • Dynamic avoidance by careful resource allocation. • Check to see if a resource can be granted, and if granting it will cause deadlock, don't grant it. • Prevention - change the rules

14. Dining Philosophers • Illustrates processes that are competing for exclusive access to more than one resource, such as tape drives or I/O devices. • A monastery’s dining table • Circular table • Five plates • Five forks (critical) • Plate of noodles at center of table (endless supply) • Philosophers can only reach forks adjacent to their plate (left and right forks)

15. Life of a Philosopher • Spends some time thinking • Gets hungry • Sits at the table • Attempts to get the left fork • Attempts to get the right fork • Starts eating, this activity takes a finite time • Releases the left and right forks • Returns to the initial state (thinking)

16. Dining philosopher: example of Deadlock problem When all philosopher are hungry, they will sit down at the same time. • At this point every philosopher will pick up the fork on the left side and reach out for the fork on the right, which not available. • The four condition for deadlock are now met and deadlock occurs.

17. Dining Table Two basic activates carried out by every philosopher: Thinking and eating. • 3. When a philosopher wants to eat, he/she attempts to pick up the two forks that are on either side of him/her and starts to eat. • After eating, the philosopher puts down (releases) the two forks and rerun to thinking. • The resources are Forks that is necessary for eating and only resources in the unit. • The other units are not relevance (Plates, table, chairs, center bowl of food, etc.)

18. Why Synchronize? • When a philosopher is hungry • obtains 2 forks (1 at a time) • Proceeds to eat • When a philosopher has satisfied hunger returns both forks and goes back to think • Problem: There are 5 competing philosopher processes • Using semaphores as before, is not sufficient for solving the problem

19. Dining Philosophers 1st Attempt • Suppose all philosophers want to eat at the same time • Each one will pick up the left fork first then block trying to pickup the right fork • All processes will now block indefinitely - deadlock

20. Dining Philosophers 2nd Attempt • After taking the left fork, if the right fork is not available, philosopher puts back the left fork and waits for a while. • Problem: Suppose all philosophers want to eat at the same time: • Each will pick up the left fork first and then try to pick up the right fork. • The right fork is not available, so all philosophers put back left forks and wait. • After some time, philosophers pick up the left fork and try again - the cycle repeats.

21. Dining Philosophers 3rd Attempt • Use a mutex semaphore to make eating mutually exclusive. • A philosopher is guaranteed to get both forks in this case. • Problem: Only one philosopher can be eating at any given time.

22. 4th Attempt to a Solution • A philosopher’s neighbors are defined by macros LEFT & RIGHT. • A philosopher may move only into eating state if neither neighbor is eating. • Use an array, state, to keep track of whether a philosopher is eating, thinking or hungry (trying to acquire forks). • Use an array of semaphores, one per philosopher, so hungry philosophers can block if the needed forks are busy.

23. Informal Solution to Deadlock Dinning Philosophers • Deadlock will not occur when the Philosophers donot sit at the table at the same time, therefore, if the Philosophers start thinking before eating deadlock will not always occur. • Because time interval to think is randomly generated so that the Philosophers will not normally start to eat at the same time and deadlock will not always occur.

24. Methods For Dealing With Deadlocks • Deadlock prevention: • disallow the existence of one of the four necessary conditions for deadlocks to occur. • Deadlock avoidance: • for each resources request which can be satisfied, determine whether the request should be delayed in order to avoid a possible deadlock in the future. • Deadlock detection and recovery: • detect the existence of deadlock; if it has occurred, take actions to remove it.

25. Deadlock avoidance • When detected a deadlock had occurred and tried to fix the problem after the fact. • Another solution is to avoid deadlock by only granting resources if granting them cannot result in a deadlock situation later. • The text describes the bankers algorithm but then points out that it is essentially impossible to implement because of this assumption.

26. Deadlock Prevention (1) Non-existence of hold and wait. • Allocation only if all resources requested are available • Allocation of resources only when there is no previous allocation. • Low resource utilization • Starvation possible

27. Deadlock Prevention (2) • Non-existence of circular wait. Impose a linearordering of resource types. Processes must request resources in an increasing order of enumeration.

28. Disallow Circular Wait • Impose a total ordering of all resource types, R = {R1, R2, …, Rm}. • Define a one to one function, F: R  N • Require that each process requests resources in an increasing order of enumeration. • Process P can request resources of type Ri, then resources of type Rj, only if: F( Rj) > F( Ri)

29. General Cycle • A technique for disallowing (Preventing) the circular wait condition is to assign a total ordering to al the resource types in the system. • Each resource type can be assigned a unique integer number, or an index number.

30. Dining Philosophers • Each Philosopher object will repeatedly execute its sequence of activities until the simulation period ends. The following sequence will be carried out by a Philosophers: • Check if the index value of the left fork is less then the index value of the right fork, then carry out the Step 2, other wise, carry out the Step 3, then Step 2. • Attempt to acquire the left fork • Attempt to acquire the right fork • Each for a time interval of eatPeriodtime units. • Think or a time interval of thinklPeriod time units.

31. Dining-Philosophers Problem Every philosopher needs two forks (or forks) and these must be accessed in a mutual exclusive manner // Shared data Semaphore fork[] = new Semaphore[5];

32. Output Listing of a Simulation Run Project: Dining Philosophers - Deadlock Run at: Sat Oct 01 17:15:39 EDT 2006 by jgarrido on Windows XP ----------------------------------------------------- Input Parameters Simulation Period: 740 Activity Stop: 400 Mean Think Time: 17.5 Mean Eat Time: 12.75 Project: Dining Philosophers - Deadlock Run at: Sat Oct 01 17:15:40 EDT 2005 Start Simulation Time 0000.000 Philosopher0 starts Time 0000.000 Philosopher1 starts Time 0000.000 Philosopher2 starts Time 0000.000 Philosopher3 starts Time 0000.000 Philosopher4 starts

33. Informal definition of Safe State • Banker’s algorithm • A state is safe if the system can allocate resources to each process (up to its maximum) in some order and still avoid a deadlock • A system is in a safe state only if there exits a safe sequence of allocations

34. Unsafe State • If a system is in an unsafe state, then some sequence of requests may lead “unavoidably” to a deadlock (i.e., the deadlock cannot be avoided by delaying the requests from the processes). • An unsafe state is not necessarily a deadlock state and does not necessarily lead to deadlock state.

35. Banker’s Algorithm • There exist multiple instances of each resource type • Each process must a priori claim maximum use of resources • 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 period of time.

36. Banker’s Algorithm (2) When a request for resources is made by process Pi: • If Requesti<Needi then goto step 2. Otherwise there is an error since Pi has exceeded it maximum claim • If Requesti< available then goto step3, otherwise Pi must wait • The OS pretends to have allocated the requested resources to Pi by modifying the state as follows: AVAILABLE := AVAILABLE - Request Allocationi := Allocationi + Request ti Need = Need – Request • If the resulting state is safe, Pi is allocated the resources. However, if the new state is unsafe, then Pi must wait and the state is restored

37. Example of Banker’s Algorithm 5 processes P0 through P4; 3 resource types A (10 instances), B (5 instances), and C (7 instances) Snapshot at time T0: AllocationMaxAvailable A B CA B C A B C 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 https://www.youtube.com/watch?v=5WMxEnWNmho Need A B C 7 4 3 1 2 2 6 0 0 0 1 1 4 3 1

38. Example (Cont.) Available 3 3 2 P0 can not be completed since is greater than available time P1 [1] Allocated P1(2+0+0)+(3+3+2)=5 3 2 P2can not be completed since is greater than available time P3 [3] Allocated P1(2+1+1)+(5+3+2)=7 4 3 P4 [4] Allocated P1(0+0+2)+(7+4+3)=7 4 5 P0 [0] Allocated P1(0+1+0)+(7+4+5)=7 5 5 P2 [2] Allocated P1(3+0+2)+(7+5+5)=10 5 7 • The content of the matrix Need is defined to be Max – Allocation Need A B C P0 7 4 3 P1 1 2 2 P2 6 0 0 P3 0 1 1 P4 4 3 1 Safe Sequence < P1, P3, P4, P0, P2 > https://www.youtube.com/watch?v=5WMxEnWNmho

39. Example: P1 Request (1,0,2) • Check that Request  Available (that is, (1,0,2)  (3,3,2)  true AllocationNeedAvailable A B C A B C A B C P0 0 1 0 7 4 3 2 3 0 P1 3 0 2 0 2 0 P2 3 0 2 6 0 0 P3 2 1 1 0 1 1 P4 0 0 2 4 3 1 • Executing safety algorithm shows that sequence < P1, P3, P4, P0, P2> satisfies safety requirement • Can request for (3,3,0) by P4 be granted? • Can request for (0,2,0) by P0 be granted?

40. Example-4 of Banker’s Algorithm Suppose P1 requests (1,0,2). The OS needs to check if (1,0,2) < (3,3,2), which is true. The OS then pretends to grant this request, and determine if the new state is a safe state. The sequence <P1, P3, P4, P0, P2> is a safe sequence. Can request for (3,3,0) by P4 be granted? Can request for (0,2,0) by P0 be granted?

41. Deadlock Detection • Allow system to enter deadlock state • Run detection algorithm • Recovery Scheme

42. Detection and Recovery A detection and recovery scheme requires overhead that includes: • Maintaining information and running the detection algorithm • The potential losses inherent in recovering from deadlock

43. Deadlock Detection A detection algorithm is invoked periodically to determine whether a deadlock has occurred. • A system has a deadlock if and only if it is impossible to satisfy the resource requests of some processes • Formally, a system is in a deadlock-free state if three exists a deadlock-free sequence for the current resource allocation state.

44. System Recovery • Abort all deadlocked processes • Abort processes one at a time • Preempt resources one at a time • Rollback

45. Recovery: Process Termination • Abort all deadlocked processes. • Abort one process at a time until the deadlock cycle is eliminated. • In which order should processes be aborted? • Priority of the process. • How long process has computed, and how much longer to completion. • Resources the process has used. • Resources process needs to complete. • How many processes will need to be terminated. • Is process interactive or batch?

46. Chapter 8File Management

47. Purpose of File Management • The purpose of file management is to identify the concepts of file management and how to use it effectively. • Data should be organized in some convenient and efficient manner. In particular, users should be able to: • Put data into files • Find and use files that have previously been created

48. File System • Set of OS Services that provides Files and Directories for user applications. • File management, as you have no doubt guessed, involves a lot more than simply moving files around from one place to another on the computer and changing names. • The operating system also automates other complicated activities that are indispensable to managing files and information on the computer.

49. Files • A file is simply a sequence of bytes that have been stored in some device (storage) on the computer • While the procedures for managing files differ from operating system to operating system, many of the concepts and commands behind the procedures are the same. These essential commands are examined below. • Creating Files/Folders • File naming • Save As • Copy, Paste, etc. • Searching • Viewing Options • Etc..

50. Permanent (non-volatile) Storage Devices • Disk Drives • Flash Memory (Memory stick) • CDs and DVDs • Magnetic tape drives