processscheduling/banker's algorithm.cpp at master · SINISTER-code/processscheduling · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
// Banker's Algorithm
#include <iostream>
using namespace std;

int main()
{

    int numberOfProcesses, numberOfResources, i, j, k;
    numberOfProcesses = 5;                    // Number of processes
    numberOfResources = 3;                    // Number of resources
    int allocationMatrix[5][3] = {{0, 1, 0},  // P0 // Allocation Matrix
                                  {2, 0, 0},  // P1
                                  {3, 0, 2},  // P2
                                  {2, 1, 1},  // P3
                                  {0, 0, 2}}; // P4

    int maximumMatrix[5][3] = {{7, 5, 3},  // P0 // MAX Matrix
                               {3, 2, 2},  // P1
                               {9, 0, 2},  // P2
                               {2, 2, 2},  // P3
                               {4, 3, 3}}; // P4

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

    int f[numberOfProcesses] = {0}, ans[numberOfProcesses], ind = 0;
    int needMatrix[numberOfProcesses][numberOfResources];
    for (i = 0; i < numberOfProcesses; i++)
    {
        for (j = 0; j < numberOfResources; j++)
            needMatrix[i][j] = maximumMatrix[i][j] - allocationMatrix[i][j];
    }
    int y = 0;
    for (k = 0; k < numberOfProcesses; k++)
    {
        for (i = 0; i < numberOfProcesses; i++)
        {
            if (f[i] == 0)
            {

                int flag = 0;
                for (j = 0; j < numberOfResources; j++)
                {
                    if (needMatrix[i][j] > availableMatrix[j])
                    {
                        flag = 1;
                        break;
                    }
                }

                if (flag == 0)
                {
                    ans[ind++] = i;
                    for (y = 0; y < numberOfResources; y++)
                        availableMatrix[y] += allocationMatrix[i][y];
                    f[i] = 1;
                }
            }
        }
    }

    int flag = 1;

    // To check if sequence is safe or not
    for (int i = 0; i < numberOfProcesses; i++)
    {
        if (f[i] == 0)
        {
            flag = 0;
            cout << "NOT SAFE!";
            break;
        }
    }

    if (flag == 1)
    {
        cout << "SAFE!" << endl;
        for (i = 0; i < numberOfProcesses - 1; i++)
            cout << " P" << ans[i] << " ->";
        cout << " P" << ans[numberOfProcesses - 1] << endl;
    }

    return 0;
}