added priority and round robin. code engineered by Ayush Kalaskar.

Codes/Group B/Assignment - 5/Priority (Non-Preemptive).cpp

@@ -0,0 +1,100 @@
+#include<iostream>
+#include<limits.h> // for INT_MAX
+using namespace std;
+
+struct sjf {
+    int burst, arrival, id, completion, waiting, turnaround, response, priority;
+    bool active;
+};
+
+sjf meh[30];
+
+class lesgo {
+public:
+    int n;
+
+    void priorityIn() {
+        cout << "\nEnter number of processes: ";
+        cin >> n;
+        for (int i = 1; i <= n; i++) {
+            cout << "\nEnter arrival time of P" << i << ": ";
+            cin >> meh[i].arrival;
+            cout << "\nEnter burst time of P" << i << ": ";
+            cin >> meh[i].burst;
+            cout << "\nEnter priority of P" << i << ": ";
+            cin >> meh[i].priority;
+            meh[i].id = i;
+            meh[i].active = false;
+        }
+        cout << "\n  | Arrival | Burst | Priority\n";
+        for (int j = 1; j <= n; j++) {
+            cout << "P" << j << " | " << meh[j].arrival << "       | " << meh[j].burst << " | " << meh[j].priority << "\n";
+        }
+    }
+
+    void priorityProcess() {
+        int k = 0; // Current time
+        int completed = 0; // Number of completed processes
+
+        while (completed < n) {
+            int highestPriority = INT_MAX;
+            int selectedProcess = -1;
+
+            // Find the process with the highest priority (smallest priority number) that has arrived and is not completed
+            for (int i = 1; i <= n; i++) {
+                if (meh[i].arrival <= k && !meh[i].active && meh[i].priority < highestPriority) {
+                    highestPriority = meh[i].priority;
+                    selectedProcess = i;
+                }
+            }
+
+            if (selectedProcess != -1) {
+                // Mark the process as active
+                meh[selectedProcess].active = true;
+
+                // If the process is starting now, calculate response time
+                if (meh[selectedProcess].response == 0) {
+                    meh[selectedProcess].response = k - meh[selectedProcess].arrival;
+                }
+
+                // Execute the process
+                k += meh[selectedProcess].burst;
+                meh[selectedProcess].completion = k;
+                meh[selectedProcess].turnaround = meh[selectedProcess].completion - meh[selectedProcess].arrival;
+                meh[selectedProcess].waiting = meh[selectedProcess].turnaround - meh[selectedProcess].burst;
+
+                completed++;
+            } else {
+                // If no process is ready to run, just increment time
+                k++;
+            }
+        }
+    }
+
+    void displayMetrics() {
+        double totalWaiting = 0, totalTurnaround = 0, totalCompletion = 0;
+
+        cout << "\n\n  | Completion time | Waiting time | Turnaround time | Response time\n";
+        for (int j = 1; j <= n; j++) {
+            totalWaiting += meh[j].waiting;
+            totalTurnaround += meh[j].turnaround;
+            totalCompletion += meh[j].completion;
+            cout << "P" << j << " | " << meh[j].completion
+                 << "             | " << meh[j].waiting
+                 << "             | " << meh[j].turnaround
+                 << "             | " << meh[j].response << "\n";
+        }
+
+        cout << "\nAverage completion time: " << totalCompletion / n;
+        cout << "\nAverage waiting time: " << totalWaiting / n;
+        cout << "\nAverage turnaround time: " << totalTurnaround / n;
+    }
+};
+
+int main() {
+    lesgo obj;
+    obj.priorityIn();
+    obj.priorityProcess();
+    obj.displayMetrics();
+    return 0;
+}

Codes/Group B/Assignment - 5/Round Robin (Preemptive)..cpp

@@ -0,0 +1,116 @@
+#include <iostream>
+#include <queue>
+#include <vector>
+#include <iomanip> // For formatting output
+using namespace std;
+
+struct process {
+    int burst, arrival, id, completion, priority, waiting, turnaround, response, remainingBurst;
+    bool active;
+};
+
+process meh[30];
+
+class RoundRobin {
+public:
+    int n;
+    int timeQuantum;
+
+    void inputProcesses() {
+        cout << "\nEnter number of processes: ";
+        cin >> n;
+        for (int i = 1; i <= n; i++) {
+            cout << "\nEnter arrival time of P" << i << ": ";
+            cin >> meh[i].arrival;
+            cout << "\nEnter burst time of P" << i << ": ";
+            cin >> meh[i].burst;
+            cout << "\nEnter priority of P" << i << ": ";
+            cin >> meh[i].priority; // Priority is not used in RR, but kept here for completeness.
+            meh[i].id = i;
+            meh[i].remainingBurst = meh[i].burst;
+            meh[i].active = false;
+        }
+        cout << "\nEnter time quantum: ";
+        cin >> timeQuantum;
+        cout << "\n  | Arrival | Burst | Priority\n";
+        for (int j = 1; j <= n; j++) {
+            cout << "P" << j << " | " << meh[j].arrival << "       | " << meh[j].burst << " | " << meh[j].priority << "\n";
+        }
+    }
+
+    void roundRobinProcess() {
+        int k = 0; // Current time
+        int completed = 0; // Number of completed processes
+        queue<int> readyQueue;
+
+        vector<bool> isProcessed(n + 1, false); // Track whether a process has been added to the ready queue
+
+        while (completed < n) {
+            // Add processes that have arrived to the ready queue
+            for (int i = 1; i <= n; i++) {
+                if (meh[i].arrival <= k && !isProcessed[i]) {
+                    readyQueue.push(i);
+                    isProcessed[i] = true;
+                }
+            }
+
+            if (readyQueue.empty()) {
+                // If no process is in the queue, increment time
+                k++;
+                continue;
+            }
+
+            int currentProcess = readyQueue.front();
+            readyQueue.pop();
+
+            // Calculate response time for the process if it starts now
+            if (!meh[currentProcess].active) {
+                meh[currentProcess].response = k - meh[currentProcess].arrival;
+                meh[currentProcess].active = true;
+            }
+
+            int timeSlice = min(timeQuantum, meh[currentProcess].remainingBurst);
+
+            // Process the current process
+            meh[currentProcess].remainingBurst -= timeSlice;
+            k += timeSlice;
+
+            if (meh[currentProcess].remainingBurst == 0) {
+                meh[currentProcess].completion = k;
+                meh[currentProcess].turnaround = meh[currentProcess].completion - meh[currentProcess].arrival;
+                meh[currentProcess].waiting = meh[currentProcess].turnaround - meh[currentProcess].burst;
+                completed++;
+            } else {
+                // If the process is not finished, re-add it to the queue
+                readyQueue.push(currentProcess);
+            }
+        }
+    }
+
+    void displayMetrics() {
+        double totalWaiting = 0, totalTurnaround = 0, totalCompletion = 0;
+
+        cout << "\n\n  | Completion time | Waiting time | Turnaround time | Response time\n";
+        for (int j = 1; j <= n; j++) {
+            totalWaiting += meh[j].waiting;
+            totalTurnaround += meh[j].turnaround;
+            totalCompletion += meh[j].completion;
+            cout << "P" << j << " | " << setw(15) << meh[j].completion
+                 << " | " << setw(12) << meh[j].waiting
+                 << " | " << setw(15) << meh[j].turnaround
+                 << " | " << setw(12) << meh[j].response << "\n";
+        }
+
+        cout << "\nAverage completion time: " << totalCompletion / n;
+        cout << "\nAverage waiting time: " << totalWaiting / n;
+        cout << "\nAverage turnaround time: " << totalTurnaround / n;
+    }
+};
+
+int main() {
+    RoundRobin obj;
+    obj.inputProcesses();
+    obj.roundRobinProcess();
+    obj.displayMetrics();
+    return 0;
+}