Deadlock Prevention

NECESSARY CONDITIONS

ALL of these four must happen simultaneously for a deadlock to occur:

Mutual exclusion

One or more than one resource must be held by a process in a non-sharable (exclusive) mode.

Hold and Wait

A process holds a resource while waiting for another resource.

No Preemption

There is only voluntary release of a resource - nobody else can make a process give up a resource.

Circular Wait

Process A waits for Process B waits for Process C .... waits for Process A.

 

There are three overall ways to handling deadlocks:

Prevent or avoid deadlocks, so that we don’t get there in the first place

Recover from deadlocks after they happen; of course, this means that we can detect them in the first place

Do nothing…just hope they don’t happen when you need to get something important done!

 

No to Mutual exclusion

• Make resources sharable. Example: share resource by Read only.
• Not a general solution, but useful nevertheless

No to Hold and Wait

1) Only request resources when have none

• • Release resource before requesting next one

2) Atomically acquire all resources at once

• • Single lock to protect all variable

No to No Preemption

• A waiting for something held by B, then take resource away from B and give to A

 

No to Circular Wait

• Impose ordering on resources Give all resources a ranking; must acquire highest ranked first

 

 

Replace Switch-Statement with function pointer EX:-2

#include <iostream>

 

enum{TYPE1,TYPE2,TYPE3,TYPE4,MAX};

 

float Plus (float a, float b) { return a+b; }

float Minus (float a, float b) { return a-b; }

float Multiply(float a, float b) { return a*b; }

float Divide (float a, float b) { return a/b; }

 

float Switch(float a, float b, char opCode)

{

    float result;

    // execute operation

    switch(opCode)

    {

    case '+' : result = Plus (a, b); break;

    case '-' : result = Minus (a, b); break;

    case '*' : result = Multiply (a, b); break;

    case '/' : result = Divide (a, b); break;

    }

    return result;

}

 

 

float (*PFUNC[MAX])(float, float) = { Plus, Minus, Multiply, Divide};

 

float NoSwitch( float a, float b, int type )

{

    float result = PFUNC[ type ] ( a, b );

    return result;

}

 

int main()

{

    std::cout << Switch(2,3,'+') << std::endl;

    std::cout << NoSwitch(2,3,TYPE1) << std::endl;

}

Replace Switch-Statement with function pointer EX:-1

#include <iostream>

float Plus (float a, float b) { return a+b; }

float Minus (float a, float b) { return a-b; }

float Multiply(float a, float b) { return a*b; }

float Divide (float a, float b) { return a/b; }

 

float Switch(float a, float b, char opCode)

{

    float result;

    // execute operation

    switch(opCode)

    {

    case '+' : result = Plus (a, b); break;

    case '-' : result = Minus (a, b); break;

    case '*' : result = Multiply (a, b); break;

    case '/' : result = Divide (a, b); break;

    }

    return result;

}

 

float with_Function_Pointer(float a, float b,float (*pt2Func)(float, float))

{

    float result;

    result = pt2Func(a, b); // call using function pointer

    return result;

}

 

int main()

{

    std::cout << Switch(2,3,'+') << std::endl;

    std::cout << with_Function_Pointer(2,3,Plus) << std::endl;

}