Deadlock Prevention Using Banker’s Algorithm In C Program

#include< stdio.h>
#include< conio.h>
void main()
{

 int allocated[15][15],max[15][15],need[15][15],avail[15],tres[15],work[15],flag[15];
 int pno,rno,i,j,prc,count,t,total;
 count=0;
 clrscr();

 printf("\n Enter number of process:");
 scanf("%d",&pno);
 printf("\n Enter number of resources:");
 scanf("%d",&rno);
 for(i=1;i< =pno;i++)
 {
  flag[i]=0;
 }
 printf("\n Enter total numbers of each resources:");
 for(i=1;i<= rno;i++)
  scanf("%d",&tres[i]);


 printf("\n Enter Max resources for each process:");
 for(i=1;i<= pno;i++)
 {
  printf("\n for process %d:",i);
  for(j=1;j<= rno;j++)
   scanf("%d",&max[i][j]);
 }


 printf("\n Enter allocated resources for each process:");
 for(i=1;i<= pno;i++)
 {
  printf("\n for process %d:",i);
  for(j=1;j<= rno;j++)
   scanf("%d",&allocated[i][j]);


 }

 printf("\n available resources:\n");
 for(j=1;j<= rno;j++)
 {
  avail[j]=0;
  total=0;
  for(i=1;i<= pno;i++)
  {
   total+=allocated[i][j];
  }
  avail[j]=tres[j]-total;
  work[j]=avail[j];
  printf("     %d \t",work[j]);
 }


 do
 {



 for(i=1;i<= pno;i++)
 {
  for(j=1;j<= rno;j++)
  {
   need[i][j]=max[i][j]-allocated[i][j];
  }
 }

 printf("\n Allocated matrix        Max      need");
 for(i=1;i<= pno;i++)
 {
  printf("\n");
  for(j=1;j<= rno;j++)
  {
   printf("%4d",allocated[i][j]);
  }
  printf("|");
  for(j=1;j<= rno;j++)
  {
   printf("%4d",max[i][j]);
  }
   printf("|");
  for(j=1;j<= rno;j++)
  {
   printf("%4d",need[i][j]);
  }
 }




  prc=0;

  for(i=1;i<= pno;i++)
  {
   if(flag[i]==0)
   {
    prc=i;

    for(j=1;j<= rno;j++)
    {
     if(work[j]< need[i][j])
     {
       prc=0;
       break;
     }
    }
   }

   if(prc!=0)
   break;
  }

  if(prc!=0)
  {
   printf("\n Process %d completed",i);
   count++;
   printf("\n Available matrix:");
   for(j=1;j<= rno;j++)
   {
    work[j]+=allocated[prc][j];
    allocated[prc][j]=0;
    max[prc][j]=0;
    flag[prc]=1;
    printf("   %d",work[j]);
   }
  }

 }while(count!=pno&&prc!=0);

 if(count==pno)
  printf("\nThe system is in a safe state!!");
 else
  printf("\nThe system is in an unsafe state!!");
 
getch();
}




OUTPUT




Enter number of process:5

 Enter number of resources:3

 Enter total numbers of each resources:10 5 7

 Enter Max resources for each process:
 for process 1:7 5 3

 for process 2:3 2 2

 for process 3:9 0 2

 for process 4:2 2 2

 for process 5:4 3 3

 Enter allocated resources for each process:
 for process 1:0 1 0

 for process 2:3 0 2


 for process 3:3 0 2

 for process 4:2 1 1

 for process 5:0 0 2

 available resources:
     2       3       0


 Allocated matrix        Max      need
   0   1   0|   7   5   3|   7   4   3
   3   0   2|   3   2   2|   0   2   0
   3   0   2|   9   0   2|   6   0   0
   2   1   1|   2   2   2|   0   1   1
   0   0   2|   4   3   3|   4   3   1
 Process 2 completed
 Available matrix:   5   3   2
 Allocated matrix        Max      need
   0   1   0|   7   5   3|   7   4   3
   0   0   0|   0   0   0|   0   0   0
   3   0   2|   9   0   2|   6   0   0
   2   1   1|   2   2   2|   0   1   1
   0   0   2|   4   3   3|   4   3   1
 Process 4 completed
 Available matrix:   7   4   3
 Allocated matrix        Max      need
   0   1   0|   7   5   3|   7   4   3
   0   0   0|   0   0   0|   0   0   0
   3   0   2|   9   0   2|   6   0   0
   0   0   0|   0   0   0|   0   0   0
   0   0   2|   4   3   3|   4   3   1
 Process 1 completed
 Available matrix:   7   5   3
 Allocated matrix        Max      need
   0   0   0|   0   0   0|   0   0   0
   0   0   0|   0   0   0|   0   0   0
   3   0   2|   9   0   2|   6   0   0
   0   0   0|   0   0   0|   0   0   0
   0   0   2|   4   3   3|   4   3   1
 Process 3 completed
 Available matrix:   10   5   5
 Allocated matrix        Max      need
   0   0   0|   0   0   0|   0   0   0
   0   0   0|   0   0   0|   0   0   0
   0   0   0|   0   0   0|   0   0   0
   0   0   0|   0   0   0|   0   0   0
   0   0   2|   4   3   3|   4   3   1
 Process 5 completed
 Available matrix:   10   5   7
The system is in a safe state!!

SECOND METHOD

#include <stdio.h>

#define MAX_PROCESSES 10

#define MAX_RESOURCES 10

int available[MAX_RESOURCES];

int max[MAX_PROCESSES][MAX_RESOURCES];

int allocation[MAX_PROCESSES][MAX_RESOURCES];

int need[MAX_PROCESSES][MAX_RESOURCES];

int main()

{

    int num_processes, num_resources;

    printf("Enter the number of processes: ");

    scanf("%d", &num_processes);

    printf("Enter the number of resources: ");

    scanf("%d", &num_resources);

    printf("Enter the number of available resources:\n");

    for (int i = 0; i < num_resources; i++)

    {

        scanf("%d", &available[i]);

    }

    printf("Enter the maximum resources required for each process:\n");

    for (int i = 0; i < num_processes; i++)

    {

        printf("Process %d: ", i);

        for (int j = 0; j < num_resources; j++)

        {

            scanf("%d", &max[i][j]);

        }

    }

    printf("Enter the current allocation of resources for each process:\n");

    for (int i = 0; i < num_processes; i++)

    {

        printf("Process %d: ", i);

        for (int j = 0; j < num_resources; j++)

        {

            scanf("%d", &allocation[i][j]);

            need[i][j] = max[i][j] - allocation[i][j];

        }

    }

    int safe_sequence[MAX_PROCESSES];

    int work[MAX_RESOURCES];

    int finish[MAX_PROCESSES];

    int num_finished = 0;

    for (int i = 0; i < num_resources; i++)

    {

        work[i] = available[i];

    }

    while (num_finished < num_processes)

    {

        int found = 0;

        for (int i = 0; i < num_processes; i++)

        {

            if (!finish[i])

            {

                int j;

                for (j = 0; j < num_resources; j++)

                {

                    if (need[i][j] > work[j])

                    {

                        break;

                    }

                }

                if (j == num_resources)

                {

                    found = 1;

                    for (int k = 0; k < num_resources; k++)

                    {

                        work[k] += allocation[i][k];

                    }

                    safe_sequence[num_finished] = i;

                    finish[i] = 1;

                    num_finished++;

                }

            }

        }

        if (!found)

        {

            printf("Unsafe state detected! System cannot proceed.\n");

            return 1;

        }

    }

    printf("Safe sequence: ");

    for (int i = 0; i < num_processes; i++)

    {

        printf("%d ", safe_sequence[i]);

    }

    printf("\n");

    return 0;

}

Explanation:

1. The program starts by asking the user to enter the number of processes and the number of resources.

2. It then asks the user to enter the number of available resources, the maximum resources required for each process, and the current allocation of resources for each process.

3. It then initializes some arrays that will be used in the algorithm, such as need, which is the difference between the maximum resources required and the current allocation.

4. It then sets up some variables to keep track of the state of the algorithm, such as work, which is the current amount of available resources, and finish, which is a boolean array indicating whether a process

EXAMPLE OUTPUT

Enter the number of processes: 5

Enter the number of resources: 3

Enter the number of available resources:

3 3 2

Enter the maximum resources required for each process:

Process 0: 7 5 3

Process 1: 3 2 2

Process 2: 9 0 2

Process 3: 2 2 2

Process 4: 4 3 3

Enter the current allocation of resources for each process:

Process 0: 0 1 0

Process 1: 2 0 0

Process 2: 3 0 2

Process 3: 2 1 1

Process 4: 0 0 2

Safe sequence: 1 3 4 0 2

In this example, we have 5 processes and 3 resources. The available resources are initially 3, 3, and 2. The maximum resources required and current allocation for each process are entered by the user.

The program then outputs the safe sequence, which is 1 3 4 0 2. This means that the processes can be executed in this order without causing a deadlock.