Bankers algorithm

                                       The Broker's calculation is an asset distribution and stop evasion calculation utilized in working frameworks. It is intended to forestall halt circumstances by deciding if dispensing assets to a cycle will bring about a protected state.


The Broker's calculation works by considering the ongoing asset designation, the most extreme asset needs of cycles, and the accessible assets. It plays out a progression of checks to guarantee that designating assets won't prompt stop. Here is a bit by bit clarification of the calculation:


1. Instate:


   - Accessible: A variety of length m addressing the quantity of accessible cases of every asset type.


   - Max: A framework of size n x m addressing the greatest asset need of each interaction. Passage Max[i][j] addresses the most extreme number of cases of asset type j that cycle I might require.


   - Portion: A lattice of size n x m addressing the ongoing designation of assets to processes. Section Allocation[i][j] addresses the quantity of occurrences of asset type j right now allotted to handle I.


   - Need: A framework of size n x m addressing the excess need of assets for each interaction. Section Need[i][j] addresses the quantity of cases of asset type j that cycle I actually needs.


2. Compute the Need framework:


   - For each cycle I, Need[i][j] = Max[i][j] - Allocation[i][j].


3. Perform security checks:


   - Work: A variety of length m addressing the quantity of accessible occurrences of every asset type. Instate it with the upsides of the Accessible cluster.


   - Finish: A variety of length n addressing whether an interaction can finish its execution. Instate all sections to misleading.


4. Check in the event that there is a cycle that can fulfill its asset needs:


   - For each cycle I:


     - On the off chance that Finish[i] is misleading and Need[i] <= Work, the framework can apportion assets to handle I.


       - Update the Work cluster by adding the assets dispensed to handle I: Work = Work + Allocation[i].


       - Mark the interaction as wrapped up: Finish[i] = valid.


       - Rehash the above strides until any longer cycles can't be set apart as wrapped up.


5. Decide whether the framework is in a protected state:


   - On the off chance that all cycles can be set apart as gotten done, then, at that point, the framework is in a protected state.


   - In any case, the framework is in a dangerous state, and stop evasion measures ought to be taken.


The Broker's calculation guarantees that the framework won't enter a hazardous state by going with asset designation choices in view of the greatest asset needs of cycles and the accessible assets. By following this calculation, the working framework can try not to dispense assets in a manner that might actually prompt gridlock circumstances.

 

 

 

 Program

 

//Banker's Algorithm

#include <stdio.h>

 

int main()

{

 

    // P0, P1, P2, P3, P4 are the Process names here

 

 

    int n, m, i, j, k,s;

    printf("enter the  no of process");

    scanf("%d",&n);

    printf("enter the no of resources");

    scanf("%d",&m);

 

    //n = 5;  //Number of processes

 

    //m = 3; // Number of resources

 

    int alloc[n][m];/* = { { 0, 1, 0 }, // P0    // Allocation Matrix

 

                        { 2, 0, 0 }, // P1

 

                        { 3, 0, 2 }, // P2

 

                        { 2, 1, 1 }, // P3

 

                        { 0, 0, 2 } }; // P4*/

    for(int i=0;i<n;i++){

            printf("enter the allocaton for process %d",i);

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

        {

 

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

        }

    }

 

 

    int max[n][m]; /*=  { { 7, 5, 3 }, // P0    // MAX Matrix

 

                      { 3, 2, 2 }, // P1

 

                      { 9, 0, 2 }, // P2

 

                      { 2, 2, 2 }, // P3

 

                      { 4, 3, 3 } }; // P4*/

    for(int i=0;i<n;i++){

        printf("enter the max need for process %d",i);

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

        {

 

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

        }

    }

    printf("enter the available resources");

    // scanf("%d",&s);

 

    int avail[m];// = { 3, 3, 2 }; // Available Resources

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

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

 

 

    int f[n], ans[n], ind = 0;

 

    for (k = 0; k < n; k++) {

 

        f[k] = 0;

 

    }

 

    int need[n][m];

 

    for (i = 0; i < n; i++) {

 

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

 

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

 

    }

 

    int y = 0;

 

    for (k = 0; k < n; k++) {

 

        for (i = 0; i < n; i++) {

 

            if (f[i] == 0) {

 

 

                int flag = 0;

 

                for (j = 0; j < m; j++) {

 

                    if (need[i][j] > avail[j]){

 

                        flag = 1;

 

                         break;

 

                    }

 

                }

 

 

                if (flag == 0) {

 

                    ans[ind++] = i;

 

                    for (y = 0; y < m; y++)

 

                        avail[y] += alloc[i][y];

 

                    f[i] = 1;

 

                }

 

            }

 

        }

 

    }

    int flag = 1;

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

    {

      if(f[i]==0)

      {

        flag=0;

         printf("The following system is not safe");

        break;

      }

    }

      if(flag==1)

    {

      printf("Following is the SAFE Sequence\n");

      for (i = 0; i < n - 1; i++)

        printf(" P%d ->", ans[i]);

      printf(" P%d", ans[n - 1]);

    }

    return 0;

}

// Output