Please enable JavaScript.

Coggle requires JavaScript to display documents.

Deadlocks (Methods (Recovery (Resource preemption (Select a victim…

- - - - abort all deadlocked process
      - abort one process till no deadlock
      - ways to abort
        
        Priority
        
        time for completion
        
        resource process hs used and need
        
        how many process will b teriminated
    - - Select a victim
        
        minimise cost
      - Rollback
        
        return to safe state n restart process
      - Starvation
        
        some process may always be picked as victim
      - successively preempt some source until deadlock is broken
  - - - Mutual exclusion
        
        must hold for non-sharable resource,so cannt b used for prevention
      - Hold and wait
        
        when one process request a resource,it doest not hold any other resource
        
        low resource utilization n starvation possible
      - Circular wait
        
        impose a total ordering of all resource and require each process to request resources
      - No preemption
        
        if a process is holding some resources requests another resource,then all resource held r released
  - - - a system is safe if the syst can allocate resource to each process to avoid deadlock
      - if process resource needs r not available then waits fr previous process to execute n release its resource,so it can obtain
      - no deadlock
      - unsafe state-has deadlock(need>avaialble) ,request delayed if deadlock occur
    - - claim edges -so when process request resource and converts to request edge and request edge convert to assg edge wen resource is allocated to process..
      - when resource release,jadi claim edge balik
    - - each process can claim maximum use and when process request,it will wait.It must return in a finite amount time
      - Safety algorithm
        
        2.need(i)<=work
        
        3.next process<=work
        
        1.work=available=3
        
        work=work+allocation(p)
        
        Resource-Request algorithm
        
        request<=need
        
        request<=available
        
        request vector for process
        
        modify the rest available=available-request allocation=allocation+request need=need-request
        
        safety algorithm on a new state
        
        available->available-request,
        allocation->allocation+request,
        need=need-request
      - Structure
        
        Max
        
        max demand request
        
        Need
        
        how many more needed
        
        Available
        
        avaialble resource
        
        Allocation
        
        currently hw many allocation
  - - - wait-for graph
    - - Allocation
      - Request
      - Available
      - 1.work=available ; finish(i)=false
        2.find process finish[i]=false&request<=work (no such exists the syst bcomes deadlocked state)
        
        work=work+Allocation finish[i]=true;
        if false means deadlock
- - - - Assignment
        
        Resource holds process
      - Request
        
        Process hold resource
    - - When u can connect the resource with process
      - no cycles=no deadlock
      - if got cycle
        
        if only one instance per resource type,then deadlock exists
        
        several instances per resource type,then there might b deadlock