FCFS

Author: coderatul

cpu_sheduling.py

@@ -1,3 +1,4 @@
+import copy
 import prettytable
 at_prcs_mapping = {} # arrivaltime : processess mapping
 bt_at_mapping = {} # burst time : arrival time mapping
@@ -18,54 +19,95 @@ def __init__(self, name:list = [], arrival_time:list = [], burst_time:list = [],
         print(table)
         print()
 
+    def unique_at(self)->list:
+        unique_at = []
+        for at in self.arrival_time:
+            if at not in unique_at:
+                unique_at.append(at)
+        unique_at.sort()
+        return unique_at
+    
+    def at_mapping(self)-> dict:
+        for index, at in enumerate(self.arrival_time):
+            if at not in at_prcs_mapping:
+                at_prcs_mapping[at] = [self.process[index]]
+            else:
+                at_prcs_mapping[at].append(self.process[index])
+        return at_prcs_mapping
+    
+    def bt_mapping(self)->dict:
+        for index, at in enumerate(self.arrival_time):
+            if at not in bt_at_mapping:
+                bt_at_mapping[at] = [self.burst_time[index]]
+            else:
+                bt_at_mapping[at].append(self.burst_time[index])
+        return bt_at_mapping
+    
+    def final_data(self,mapping:dict)->list:
+        listed_data = []
+        for prcs in self.unique_at():
+            listed_data.append(mapping[prcs])
+        data = [process for sublist in listed_data for process in sublist]
+        return data
+    
+    def correction(self,arrival_time:list, ct:list)->list:
+        correction_index = 0
+        correction_value = 0
+
+        for at in range(len(ct)-1):
+            if arrival_time[at+1] > ct[at]:
+                correction_value = arrival_time[at+1] - ct[at]
+                correction_index = at+1            
+        return [correction_value, correction_index]
+            
     def fcfs(self):
         """
         first come first serve short term shdeuling
         """
-        for i in range(len(self.process)):
-            # creating arrival time : process & burst time : arrival time mapping
-            at_prcs_mapping.update({self.arrival_time[i]:self.process[i]})
-            bt_at_mapping.update({self.arrival_time[i]:self.burst_time[i]})
+        execution_order = self.final_data(self.at_mapping())
+        process_ord = copy.deepcopy(execution_order)
+        bt_ord = self.final_data(self.bt_mapping())
 
-        # sorted arriavl time 
-        self.arrival_time.sort()
-        
-        # burst time in order of process execution 
-        bt_ord = []
-
-        print("fcfs order: ",end="")
-        for k in self.arrival_time:
-            # printing keys(process) of arrival time(from sorted arrival time list(self.arrival_time))
-            if k == self.arrival_time[-1]:
-                print(f"{at_prcs_mapping.get(k)}",end="")
-            else:
-                print(f"{at_prcs_mapping.get(k)} -> ",end="")
-            
-            # appending burts time of process in the order of their execution
-            bt_ord.append(bt_at_mapping.get(k))
-        print()
-            
         # calculating completion time of each process 
         ct = []
         for j in bt_ord:
             if ct:
                 temp = ct[-1] + j
             else:
                 temp = j
-            ct.append(temp)
+            ct.append(temp)    
+        
+        at = sorted(self.arrival_time)
+        print(at, ct)
 
-        print()
-        print(30*"-","first come first serve shedule",30*"-")
-        print()
 
+        crrction_val, crrction_index = self.correction(at, ct)
+        print(crrction_val, crrction_index)
+        if crrction_val == 0:
+            pass
+        else:
+            process_ord.insert(crrction_index,f"halt for {crrction_val} sec(s)")
+
+        for correction in ct[crrction_index:]:
+            ct[crrction_index] += crrction_val
+            crrction_index += 1
+            
+        print("fcfs order: ",end="")
+        for process in process_ord:
+            if process == process_ord[-1]:
+                print(f"{process}",end="")
+            else:
+                print(f"{process} -> ",end="")
+        print();print()
+
         # list of turn around time for everyprocess
-        tat_list = [a-b for a,b in zip(ct,at)]
+        tat_list = [a-b for a,b in zip(ct,sorted(self.arrival_time))]
 
         # average turn around time
         tat = sum(tat_list) / len(tat_list)
 
         # list of waiting time for each process
-        wt_list = [a-b for a,b in zip(tat_list,bt)]
+        wt_list = [a-b for a,b in zip(tat_list,bt_ord)]
 
         # average waiting time
         wt = sum(wt_list) / len(wt_list)
@@ -74,11 +116,12 @@ def fcfs(self):
         table = prettytable.PrettyTable()
         table.field_names = ["Process", "Arrival Time", "Burst Time", "Completion Time", "Turn around time", "waiting time"]
         for i in range(len(self.process)):
-            table.add_row([at_prcs_mapping.get(i), self.arrival_time[i], self.burst_time[i],ct[i],tat_list[i],wt_list[i]])
+            table.add_row([execution_order[i], at[i], bt_ord[i],ct[i],tat_list[i],wt_list[i]])
         print(table)
         print(f"turn around time -> {tat}")
         print(f"average waiting time was -> {wt}")
-    
+        
+        
     def sjf(self):
         """
         shortest job first: non-preemtive
@@ -96,17 +139,12 @@ def rr(self):
         round robbin 
         """
         ...
-                       
+                     
 if __name__ == "__main__":
-    prcs = ["P1","P2","P3","P4","P5"] #process
-    at = [0,1,2,3,4] # arrival time
-    bt = [8,1,3,2,6] # burst time
+    prcs =["P1","P2","P3","P4"] #process
+    at = [0,1,5,6] # arrival time
+    bt = [2,2,3,4] # burst time
     shedule = CpuSheduling(prcs,at,bt) 
     shedule.fcfs()
-    
-
-    
-    
-
-
+