死锁避免的调度算法之银行家算法的C++实现

EuniceKwong
316 阅读2分钟

Refer to Banker's Algorithm in Operating System - GeeksforGeeks

The banker’s algorithm is a resource allocationand deadlock avoidance algorithm that tests for safety by simulating the allocation for predetermined maximum possible amounts of all resources, then makes an “s - state” check to test for possible activities, before deciding whether allocation should be allowed to continue.

Let n be the number of processes in the systemand m be the number of resources types.

  • Available :

    • It is a 1-d array of size m indicating the number of available resources of each type.
    • Available[j] = k means there are k instances of resource type Rj

  • Max :

    • It is a 2-d array of size n*m that defines the maximum demand of each process in a system.
    • Max[i, j] = k means process Pi may request at most k instances of resource type Rj.

  • Allocation :

    • It is a 2-d array of size n*m that defines the number of resources of each type currently allocated to each process.
    • Allocation[i, j] = k means process Pi is currently allocated k instances of resource type Rj

  • Need :

    • It is a 2-d array of size n*m that indicates the remaining resource need of each process.
    • Need[i, j] = k means process Pi currently need k instances of resource type Rj for its execution.
    • Need[i, j] = Max[i, j] – Allocation[i, j]

    Banker’s algorithm consists of Safety algorithm and Resource request algorithm.

    Safety Algorithm

    1. Let Work and Finish be vectors of length m and n respectively.
      Initialize: Work = Available
      Finish[i] = false; for i=1, 2, 3, 4….n
    1. Find an i such that both
    • a) Finish[i] = false
    • b) Needi <= Work
      if no such i exists goto step (4)
    1. Work = Work + Allocation[i]
      Finish[i] = true
      goto step (2)
    1. if Finish [i] = true for all i
      then the system is in a safe state

Resource-Request Algorithm

Request_i[j] = k means process Pi wants k instances of resource type Rj.

    1. If Requesti <= Needi
      Goto step (2) ; otherwise, raise an error condition, since the process has exceeded its maximum claim.
    1. If Requesti <= Available
      Goto step (3); otherwise, Pi must wait, since the resources are not available.
    1. Have the system pretend to have allocated the requested resources to process Pi by modifying the state as follows:
      Available = Available – Requesti
      Allocationi = Allocationi + Requesti
      Needi = Needi– Requesti

Implementation in C++

// Banker's Algorithm 
#include <stdio.h> 
int main()
{
	// P0, P1, P2, P3, P4 are the Process names here 
	int i, j, k;
	const int n = 5; // Number of processes 
	const int m = 3; // Number of resources 
	int alloc[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 max[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 avail[3] = { 3, 3, 2 }; // Available Resources 

	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 < 5; 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;
				}
			}
		}
	}

	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:

Following is the SAFE Sequence
 P1 -> P3 -> P4 -> P0 -> P2

银行家算法

// C++ program to illustrate Banker's Algorithm 
#include<iostream> 
using namespace std;

// Number of processes 
const int P = 5;

// Number of resources 
const int R = 3;

// Function to find the need of each process 
void calculateNeed(int need[P][R], int maxm[P][R],
	int allot[P][R])
{
	// Calculating Need of each P 
	for (int i = 0; i < P; i++)
		for (int j = 0; j < R; j++)

			// Need of instance = maxm instance - 
			//                    allocated instance 
			need[i][j] = maxm[i][j] - allot[i][j];
}

// Function to find the system is in safe state or not 
bool isSafe(int processes[], int avail[], int maxm[][R],
	int allot[][R])
{
	int need[P][R];

	// Function to calculate need matrix 
	calculateNeed(need, maxm, allot);

	// Mark all processes as infinish 
	bool finish[P] = { 0 };

	// To store safe sequence 
	int safeSeq[P];

	// Make a copy of available resources 
	int work[R];
	for (int i = 0; i < R; i++)
		work[i] = avail[i];

	// While all processes are not finished 
	// or system is not in safe state. 
	int count = 0;
	while (count < P)
	{
		// Find a process which is not finish and 
		// whose needs can be satisfied with current 
		// work[] resources. 
		bool found = false;
		for (int p = 0; p < P; p++)
		{
			// First check if a process is finished, 
			// if no, go for next condition 
			if (finish[p] == 0)
			{
				// Check if for all resources of 
				// current P need is less 
				// than work 
				int j;
				for (j = 0; j < R; j++)
					if (need[p][j] > work[j])
						break;

				// If all needs of p were satisfied. 
				if (j == R)
				{
					// Add the allocated resources of 
					// current P to the available/work 
					// resources i.e.free the resources 
					for (int k = 0; k < R; k++)
						work[k] += allot[p][k];

					// Add this process to safe sequence. 
					safeSeq[count++] = p;

					// Mark this p as finished 
					finish[p] = 1;

					found = true;
				}
			}
		}

		// If we could not find a next process in safe 
		// sequence. 
		if (found == false)
		{
			cout << "System is not in safe state";
			return false;
		}
	}

	// If system is in safe state then 
	// safe sequence will be as below 
	cout << "System is in safe state.\nSafe"
		" sequence is: ";
	for (int i = 0; i < P; i++)
		cout << safeSeq[i] << " ";

	return true;
}

// Driver code 
int main()
{
	int processes[] = { 0, 1, 2, 3, 4 };

	// Available instances of resources 
	int avail[] = { 3, 3, 2 };

	// Maximum R that can be allocated 
	// to processes 
	int maxm[][R] = { {7, 5, 3},
					 {3, 2, 2},
					 {9, 0, 2},
					 {2, 2, 2},
					 {4, 3, 3} };

	// Resources allocated to processes 
	int allot[][R] = { {0, 1, 0},
					  {2, 0, 0},
					  {3, 0, 2},
					  {2, 1, 1},
					  {0, 0, 2} };

	// Check system is in safe state or not 
	isSafe(processes, avail, maxm, allot);

	return 0;
}

Output:

System is in safe state.
Safe sequence is: 1 3 4 0 2
avatar
文章
阅读
粉丝