From 796983a81702f5b4657f5fb6b302fbe6fa9ea198 Mon Sep 17 00:00:00 2001
From: Pratyush219 <sspratyush7@gmail.com>
Date: Wed, 6 Oct 2021 19:31:14 +0530
Subject: [PATCH] FCFS scheduling algorithm in operating system Added C++
 implementation of FCFS scheduling algorithm in a new directory
 Operating-System/Scheduing-Algorithms

---
 .../Scheduling-Algorithms/FCFS_Scheduling.cpp | 138 ++++++++++++++++++
 1 file changed, 138 insertions(+)
 create mode 100644 Operating-System/Scheduling-Algorithms/FCFS_Scheduling.cpp

diff --git a/Operating-System/Scheduling-Algorithms/FCFS_Scheduling.cpp b/Operating-System/Scheduling-Algorithms/FCFS_Scheduling.cpp
new file mode 100644
index 000000000..ac208087f
--- /dev/null
+++ b/Operating-System/Scheduling-Algorithms/FCFS_Scheduling.cpp
@@ -0,0 +1,138 @@
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+#include <queue>
+#include <cmath>
+#include <cstdio>
+using namespace std;
+
+/** 
+ * @brief Comparator class for Priority queue
+ *  S: Data type of Process id
+ *  T: Data type of Arrival time
+ *  E: Data type of Burst time 
+*/ 
+template<typename S, typename T, typename E>
+class Compare{
+    public:
+    /**
+     * @param t1 = first tuple
+     * @param t2 = second tuple 
+     * @brief checks whether to swap two tuples or not
+    */
+    bool operator () (tuple<S, T, E, double, double, double>& t1, tuple<S, T, E, double, double, double>& t2){
+        if(get<1>(t2) < get<1>(t1)){
+            return true;
+        }
+        else if(get<1>(t2) == get<1>(t1)){
+            return get<0>(t2) < get<0>(t1);
+        }
+        return false;
+    }
+};
+
+// Where the magic happens. This is where I compute the status of all the processes post their completion
+/**
+ * @brief Class which implements the FCFS scheduling algorithm
+ *  S: Data type of Process id
+ *  T: Data type of Arrival time
+ *  E: Data type of Burst time 
+*/ 
+template<typename S, typename T, typename E>
+class FCFS{
+    /**
+     * In each tuple
+     * 1st element: Process id
+     * 2nd element: Arrival Time
+     * 3rd element: Burst time
+     * 4th element: Completion time
+     * 5th element: Turnaround time
+     * 6th element: Waiting time
+    */
+    priority_queue<tuple<S, T, E, double, double, double>, vector<tuple<S, T, E, double, double, double>>, Compare<S, T, E>> schedule;
+    vector<tuple<S, T, E, double, double, double>> result;
+    unordered_set<S> idList;
+    public:
+    void addProcess(S id, T arrival, E burst){
+        if(idList.find(id) == idList.end()) {
+            tuple<S, T, E, double, double, double> t = make_tuple(id, arrival, burst, 0, 0, 0);
+            schedule.push(t);
+            idList.insert(id);
+        }
+        
+    }
+
+    /**
+     * @brief Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm.
+     * 
+     * @description FCFS is a non -preemptive algorithm in which the process which arrives first gets executed first. If two or 
+     * more processes arrive together then the process with smaller process id runs first (each process has a unique proces id).
+     * 
+     * I used a min priority queue of tuples to accomplish this task. The processes are ordered by their arrival times. If arrival
+     * times of some processes are equal, then they are ordered by their process id.
+    */ 
+    void scheduleForFcfs(){
+        // Variable to keep track of time elepsed so far
+        double timeElapsed = 0;
+
+        while(!schedule.empty()){
+            tuple<S, T, E, double, double, double> cur = schedule.top();
+            
+            // If the next process arrived at time t2, the last process completed its execution at time t1, and t2 > t1.
+            if(get<1>(cur) > timeElapsed){
+                timeElapsed += get<1>(cur) - timeElapsed;
+            }
+
+            // Add Burst time to time elapsed
+            timeElapsed += get<2>(cur);
+            
+            get<3>(cur) = timeElapsed;
+            
+            // Turnaround time = Completion time - Arrival time
+            get<4>(cur) = get<3>(cur) - get<1>(cur);
+
+            //Waiting time = Turnaround time - Burst time
+            get<5>(cur) = get<4>(cur) - get<2>(cur);
+
+            result.push_back(cur);
+            schedule.pop();
+        }
+        printResult();
+    }
+
+    // Utility function for printing the status of each process after execution
+    void printResult(){
+        cout << "Status of all the proceses post completion is as follows:" << endl;
+
+        printf("%-17s%-17s%-17s%-17s%-17s%-17s\n", "Process Id", "Arrival Time", "Burst Time", 
+                    "Completion Time", "Turnaround Time", "Waiting Time"
+                );
+        for(size_t i{}; i < result.size(); i++){
+            printf("%-17d%-17d%-17d%-17.2lf%-17.2lf%-17.2lf\n", get<0>(result[i]), get<1>(result[i]), get<2>(result[i]), 
+                get<3>(result[i]), get<4>(result[i]), get<5>(result[i])
+                );
+        }
+    }
+    
+
+};
+
+int main(){
+    FCFS<int ,int, int> readyQueue;
+
+    //Sample test case
+    int n = 3;
+    tuple<int, int, int> input[n] = {
+        make_tuple(1, 0, 30),
+        make_tuple(2, 0, 5),
+        make_tuple(3, 0, 5)
+    };
+
+    for(int i{}; i < n; i++){
+        int id, arrival, burst;
+        readyQueue.addProcess(get<0>(input[i]), get<1>(input[i]), get<2>(input[i]));
+    }
+
+    readyQueue.scheduleForFcfs();
+    return 0;
+}
\ No newline at end of file