diff --git a/Deadlock avoidance algorithm/Banker's Algorithm.c b/Deadlock avoidance algorithm/Banker's Algorithm.c new file mode 100644 index 00000000..aed7da6c --- /dev/null +++ b/Deadlock avoidance algorithm/Banker's Algorithm.c @@ -0,0 +1,100 @@ +#include +#include + +#define MAX_PROCESSES 10 +#define MAX_RESOURCES 10 + +// Function to check if the system is in a safe state +bool isSafe(int processes, int resources, int max[MAX_PROCESSES][MAX_RESOURCES], + int allocation[MAX_PROCESSES][MAX_RESOURCES], int available[MAX_RESOURCES]) { + + int work[MAX_RESOURCES]; + bool finish[MAX_PROCESSES] = {false}; + int safeSequence[MAX_PROCESSES]; + int count = 0; + + // Initialize work to available resources + for (int i = 0; i < resources; i++) { + work[i] = available[i]; + } + + // Find a safe sequence + while (count < processes) { + bool found = false; + for (int p = 0; p < processes; p++) { + if (!finish[p]) { + bool canAllocate = true; + for (int r = 0; r < resources; r++) { + if (max[p][r] - allocation[p][r] > work[r]) { + canAllocate = false; + break; + } + } + + // If a process can be allocated + if (canAllocate) { + for (int r = 0; r < resources; r++) { + work[r] += allocation[p][r]; + } + safeSequence[count++] = p; + finish[p] = true; + found = true; + } + } + } + + // If no process can be allocated, then system is not in a safe state + if (!found) { + printf("System is not in a safe state.\n"); + return false; + } + } + + // Print safe sequence + printf("System is in a safe state.\nSafe sequence: "); + for (int i = 0; i < processes; i++) { + printf("%d ", safeSequence[i]); + } + printf("\n"); + return true; +} + +int main() { + int processes, resources; + int max[MAX_PROCESSES][MAX_RESOURCES]; + int allocation[MAX_PROCESSES][MAX_RESOURCES]; + int available[MAX_RESOURCES]; + + // Input the number of processes and resources + printf("Enter number of processes: "); + scanf("%d", &processes); + printf("Enter number of resources: "); + scanf("%d", &resources); + + // Input the Max matrix + printf("Enter the Max matrix:\n"); + for (int i = 0; i < processes; i++) { + for (int j = 0; j < resources; j++) { + scanf("%d", &max[i][j]); + } + } + + // Input the Allocation matrix + printf("Enter the Allocation matrix:\n"); + for (int i = 0; i < processes; i++) { + for (int j = 0; j < resources; j++) { + scanf("%d", &allocation[i][j]); + } + } + + // Input the Available resources + printf("Enter the Available resources:\n"); + for (int i = 0; i < resources; i++) { + scanf("%d", &available[i]); + } + + // Check if the system is in a safe state + isSafe(processes, resources, max, allocation, available); + + return 0; +} diff --git a/Deadlock avoidance algorithm/Readme.md b/Deadlock avoidance algorithm/Readme.md new file mode 100644 index 00000000..9b9ee927 --- /dev/null +++ b/Deadlock avoidance algorithm/Readme.md @@ -0,0 +1,64 @@ +# Banker's Algorithm in C + +This project implements the **Banker's Algorithm** in C, a classic deadlock avoidance algorithm used in operating systems. The algorithm checks if resource allocation requests can be safely granted without causing deadlock by ensuring that the system remains in a "safe state" after each allocation. + +## Table of Contents +- [Introduction](#introduction) +- [Algorithm Overview](#algorithm-overview) +- [Features](#features) +- [Example](#example) +- [Limitations](#limitations) + +## Introduction + +The Banker's Algorithm, designed by Edsger Dijkstra, is a deadlock avoidance algorithm that allocates resources to processes only if the system can remain in a safe state. A "safe state" is one where a sequence of processes can complete without running into resource contention issues that would lead to deadlock. + +## Algorithm Overview + +The Banker's Algorithm operates based on three main matrices: +- **Max Matrix**: Indicates the maximum resources each process may require. +- **Allocation Matrix**: Shows the resources currently allocated to each process. +- **Available Vector**: Tracks the currently available resources in the system. + +When a process requests resources, the algorithm calculates if fulfilling the request will keep the system in a safe state. If so, the resources are allocated; otherwise, the request is denied. + +## Features + +- Deadlock avoidance for resource allocation. +- Identification of a safe sequence for process execution. +- Simple implementation using arrays and loops, compatible with standard C libraries. + +## Example + +### Example 1 + +#### Sample Input + +Enter number of processes: 3 +Enter number of resources: 3 + +Enter the Max matrix: +7 5 3 +3 2 2 +9 0 2 + +Enter the Allocation matrix: +0 1 0 +2 0 0 +3 0 2 + +Enter the Available resources: +3 3 2 + +#### Sample Input + +System is in a safe state. +Safe sequence: 1 0 2 + +## Limitations + +- **Fixed Resource and Process Count**: This implementation sets maximum limits for the number of processes and resources. Modifying these limits requires changing the code and recompiling. +- **Static Resource Allocation**: The algorithm only supports a static allocation based on the initial request. Dynamic resource changes or multiple resource requests are not handled. +- **Non-Preemptive**: Once allocated, resources cannot be preempted or re-assigned from one process to another, limiting flexibility. +- **Single Resource Type Per Process**: The current implementation assumes that each process only requests one type of resource at a time. For complex requests, code adjustments are needed. +- **Sequential Execution**: The algorithm performs sequential checks to find a safe sequence, which can be inefficient for systems with a large number of processes and resources.