From b5c5f4904dee13ff96d263f386a47774a05cb4bd Mon Sep 17 00:00:00 2001
From: Zach S-B <zachsb@outlook.com>
Date: Sat, 28 Aug 2021 14:02:51 +1000
Subject: [PATCH] pre-unidispatch

---
 FCFS.java    | 46 ++++++++++++++++++++++++----------------------
 Process.java | 21 +++++++++++++--------
 2 files changed, 37 insertions(+), 30 deletions(-)

diff --git a/FCFS.java b/FCFS.java
index 0e6dcbc..8ca8937 100644
--- a/FCFS.java
+++ b/FCFS.java
@@ -11,18 +11,19 @@ public class FCFS {
 
     private static LinkedList<Process> processListFromFile;   //Original List of processes from the the file
     private LinkedList<Process> waitingQueue = new LinkedList<>();  //Processes officially added to the waiting queue.
-    private LinkedList<Process> newProcesses = new LinkedList<>();  //Processes that have arrived after each time point.
+    private LinkedList<Process> newProcesses = new LinkedList<>();  //Processes that have arrived since the last check
+    
     //Constructors
-
     public FCFS(int dispInput, LinkedList<Process> processListInput)
     {
         disp = dispInput;
         processListFromFile = processListInput;
     }
 
-
+    //Check for new processes that have arrived
     private void checkForArrivals()
     {
+        //Check each processe from the file, and if it has arrived between timeStep and whenever we last checked, add it.
         for(int i = 0; i< processListFromFile.size(); i++)
         {
             if((processListFromFile.get(i).getArrive()<=timeStep) && (processListFromFile.get(i).getArrive() > timeLastChecked))
@@ -55,13 +56,18 @@ public class FCFS {
         {
             waitingQueue.add(newProcesses.get(i));
         }
+
+        //Clear the processes list so it is ready to go for the next time
         newProcesses.clear();
     }
 
+    //Run the actual dispatch and running of programs
     public void runDispatch()
     {       
-        System.out.println("FCFS:");
-        int processesFinished = 0;
+        System.out.println("FCFS:"); //Currently using FCFS methodology
+       
+        int processesFinished = 0;  //Used to track if we've done all the processes from the file
+        
         Process currentProcess;
         Process lastRunProcess = new Process("temp", 0, 0, 0);  //temp process for comparing the first run
         
@@ -72,15 +78,20 @@ public class FCFS {
             //As long as there is something in the queue
             if(waitingQueue.size()>0)
             {
-                currentProcess = findShortestProcess();
+
+                currentProcess = findNextProcess();
                 
+                //If the next process to run is different than the last one run, we need to run the actual dispatcher, which takes time, to change process
                 if(!lastRunProcess.getId().equals(currentProcess.getId()))
                 {
-                    timeStep = timeStep+disp;
+                    timeStep += disp;
+
                     System.out.println("T"+timeStep+": "+currentProcess.getId());
+
+                    //Add the time waited to each of the currently waiting processes records
                     for(int i = 0; i<waitingQueue.size(); i++)
                     {
-                        waitingQueue.get(i).runForOneTick(false);
+                        waitingQueue.get(i).wait(disp);
                     }
                 }
 
@@ -88,6 +99,8 @@ public class FCFS {
                 
                 if(currentProcess.isDone())
                 {
+                    currentProcess.saveEndTime(timeStep);
+                    currentProcess.saveTurnTime();
                     waitingQueue.remove(currentProcess);
                     processesFinished++;
                 }
@@ -98,7 +111,7 @@ public class FCFS {
          }while(processesFinished!=processListFromFile.size());      
     }
 
-    private Process findShortestProcess()
+    private Process findNextProcess()
     {
         // int listPos = -1;
         // int remaining = waitingQueue.getFirst().getRemainingTime();
@@ -118,8 +131,8 @@ public class FCFS {
         // }
         // else
         // {
+        
         return waitingQueue.getFirst();
-    
     }
 
     private void runProcessTick(Process input)
@@ -136,21 +149,10 @@ public class FCFS {
                 waitingQueue.get(i).runForOneTick(true);
             }
         }
-
-        if(input.isDone())
-        {
-            input.saveEndTime(timeStep);
-            input.saveTurnTime();
-        }       
     }    
 
     public void printResults()
-    {
-        for (int i = 0; i < processListFromFile.size(); i++)
-        {
-            //System.out.println("T"+processListFromFile.get(i).getStartTime()+": "+processListFromFile.get(i).getId());
-        }
-        
+    {       
         System.out.println("\nProcess \tTurnaround Time \tWaiting Time");
         for (int i = 0; i < processListFromFile.size(); i++)
         {
diff --git a/Process.java b/Process.java
index a7a0972..6bb7400 100644
--- a/Process.java
+++ b/Process.java
@@ -110,16 +110,21 @@ public class Process {
         }
         else
         {
-            if(waitTime==-1)
-            {
-                waitTime=1;
-            }
-            else
-            {           
-                waitTime++;
-            }   
+            wait(1);
         }
     }
+
+    public void wait(int time)
+    {
+        if(waitTime==-1)
+        {
+            waitTime=time;
+        }
+        else
+        {           
+            waitTime+= time;
+        }   
+    }
     
     public boolean isDone()
     {