Banker's Algorithm

Deadlock avoidance algorithm/Banker's Algorithm.c

@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+#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;
+}

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.