Deadlock (PDF)

Document Sample
Deadlock (PDF) Powered By Docstoc
					                        Deadlock

                COMP346 - Operating Systems
                          Tutorial 5
                  Edition 1.1, June 15, 2002

June 11, 2002              Serguei A. Mokhov,     1
                         mokhov@cs.concordia.ca
                        Topics
• Deadlock Debrief
      –   Simplest Example
      –   Necessary Deadlock Conditions
      –   Resource Allocation Graph
      –   Deadlock Handling
• Deadlock and Starvation with Semaphores
• Examples

June 11, 2002            Serguei A. Mokhov,     2
                       mokhov@cs.concordia.ca
                                                        R2

                         Deadlock                  P1        P2

                                                        R1
• Simplest example:
      – Two processes require two resources to
        complete (and release the resources)
      – There are only two instances of these resources
      – If they acquire one resource each, they block
        indefinitely waiting for each other to release the
        other resource =>
            • DEADLOCK, one of the biggest problems in
              multiprogramming.

June 11, 2002               Serguei A. Mokhov,                3
                          mokhov@cs.concordia.ca
  Necessary Deadlock Conditions
• Recall which conditions must hold (p. 245):
      – ME: at least one process exclusively uses a
        resource
      – Hold and wait: a process possesses at least one
        resources and requires more, which are held by
        others
      – No preemption: resources are released only in
        voluntary manner by processes holding them
      – Circular wait: P1→P2 → P3 → … → PN → P1
June 11, 2002           Serguei A. Mokhov,            4
                      mokhov@cs.concordia.ca
          Resource-Allocation Graph
• An easy way to illustrate resource allocation and
  visually detect the deadlock situation(s)
• Example:                               • • • •
      –   N+1 resources
      –   N processes                                         ?
      –   Every process needs 2 resources     P1 P2 P3
      –   Upon acquiring 2 resources, a process releases them
      –   Is there a deadlock?


June 11, 2002               Serguei A. Mokhov,                    5
                          mokhov@cs.concordia.ca
                   More Examples
• Example from Salsa Theory Review
• Resource Allocation Graph
• Is the following true or false?
      – Deadlock cannot happen in a system with two
        processes.
            • One CPU
            • Two CPUs


June 11, 2002              Serguei A. Mokhov,         6
                         mokhov@cs.concordia.ca
                Handling Deadlocks
•   Deadlock Ignorance
•   Deadlock Prevention
•   Deadlock Avoidance
•   Deadlock Detection and Recovery




June 11, 2002          Serguei A. Mokhov,     7
                     mokhov@cs.concordia.ca
                Deadlock Ignorance
• As system designers we may pretend that
  deadlocks don’t happen :-).
• If they do happen, they don’t happen very often.
• Most common approach because it’s cheap (in
  terms of human labor, complexity of the system
  and system’s performance).
• Highest resource utilization.
• Sysadmin can simply kill deadlocked processes or
  restart the system if it’s not responding.
June 11, 2002          Serguei A. Mokhov,            8
                     mokhov@cs.concordia.ca
                Deadlock Prevention
• Recall necessarily deadlock conditions
• Deadlock prevention algorithms assure at
  least one these conditions do not hold, thus
  preventing occurrence of the deadlock.
• Possible Disadvantages:
      – Low device utilization
      – Reduced system’s throughput
• [1] p. 250
June 11, 2002          Serguei A. Mokhov,        9
                     mokhov@cs.concordia.ca
                Deadlock Avoidance
• Unlike in deadlock prevention, deadlock
  avoidance algorithms do not watch for necessary
  deadlock conditions, but use additional a priori
  info about future resource requests.
• This info will help the system to avoid entering
  the unsafe state.
• Disadvantages: again, lower resource utilization
  (because resources may not be granted sometimes
  even if they are unused).
• [1] P. 253
June 11, 2002          Serguei A. Mokhov,        10
                     mokhov@cs.concordia.ca
                Deadlock Detection and
                      Recovery
• Instead of preventing or avoiding deadlocks
  we allow them to happen and also provide
  mechanisms to recover.
• Problems:
      – How often do we run detection algorithms?
      – How do we recover?
      – What is the cost of detection and recovery?
• [1] P. 260, p. 264
June 11, 2002            Serguei A. Mokhov,           11
                       mokhov@cs.concordia.ca
    Deadlocks and Starvation with
            Semaphores
• Semaphores act like resources in this case,
  which can be acquired and (never) released.
• One example as book suggests:
      P1                    P2
      wait(sem1)            wait(sem2)
      wait(sem2)            wait(sem1)
      …                     …
      signal(sem1)          signal(sem2)
      signal(sem2)          signal(sem1)

• [1] P. 204
June 11, 2002          Serguei A. Mokhov,     12
                     mokhov@cs.concordia.ca
    Deadlocks and Starvation with
          Semaphores (2)
• Starvation, or indefinite blocking, is when a
  process is waiting on a semaphore where nobody
  is ever going to release it.
• Another example of both deadlock and starvation:
 For this case assume:     process A {             process B {
                             wait(mutex)             wait(mutex)
    mutex = 1                ...                     ...
    synch = 0                wait(synch)             signal(synch)
                             ...                     ...
 Try starting processes      wait(synch)             ...
 in any order and see        ...                     ...
 where they block.           signal(mutex)           signal (mutex)
                           }                       }

June 11, 2002               Serguei A. Mokhov,                    13
                          mokhov@cs.concordia.ca
    Deadlocks and Starvation with
          Semaphores (3)
• Yet another example :-)
 a)        semaphore S = -2;
 P1 {                        P2 {                     P3 {
    <phase1>                   <phase1>                 <phase1>
    V(S)                       V(S)                     V(S)
    P(S)                       P(S)                     P(S)
    <phase2>                   <phase2>                 <phase2>
 }                           }                       }

 b)        semaphore S = -2, S1 = 0, S2 = 0;
 P1 {                       P2 {                     P3 {
    <phase1>                  <phase1>                 <phase1>
    V(S)                      V(S)                     V(S)
    P(S)                      P(S)                     P(S)
    V(S1)                     P(S1)                    P(S2)
    <phase2>                  V(S2)                    <phase2>
 }                            <phase2>               }
                            }
June 11, 2002                 Serguei A. Mokhov,                   14
                            mokhov@cs.concordia.ca
    Deadlocks and Starvation with
          Semaphores (4)
• Things to note:
      – Assume the P2, P3, P1 order in the starvation
        example;
      – Assume the P1, P3, P2 order in the deadlock
        example;
      – Blocking means getting out from the running state to
        the waiting state, so a context switch to the next
        process in the queue happens;
      – In these example there are no multiple instances of
        these processes.
June 11, 2002             Serguei A. Mokhov,               15
                        mokhov@cs.concordia.ca
      Deadlocks and Starvation with
            Semaphores (5)
Starvation scenario (in b):               Deadlock Scenario:
1) P2: <phase1>
2)     V(S) (S = -1)                      1) P1: <phase1>
3)     P(S) (blocked->switch to P3)       2)     V(S) (S = -1)
                                          3)     P(S) (blocked->switch to P3)
4) P3: <phase1>
5)     V(S) (S = 0)                       4) P3: <phase1>
6)     P(S) (blocked->switch to P1)       5)     V(S) (S = 0)
                                          6)     P(S) (blocked->switch to P2)
7) P1:   <phase1>
8)       V(S) (S = 1)                     7) P2: <phase1>
9)       P(S) (S = 0)                     8)     V(S) (S = 1)
10)      V(S1) (S1 = 1)                   9)     P(S1) (blocked)
11)      <phase2>
12)      terminates                       10) ???

13)      ???

June 11, 2002                  Serguei A. Mokhov,                               16
                             mokhov@cs.concordia.ca

				
DOCUMENT INFO