From 83ed551b448a64e9159444ccc44d01072bfa3430 Mon Sep 17 00:00:00 2001
From: Zach S-B <zachsb@outlook.com>
Date: Sat, 28 Aug 2021 12:58:47 +1000
Subject: [PATCH] Moving FCFS to SRT style

---
 FCFS.java    | 91 +++++++++++++++++++++++++++++++++++-----------------
 Process.java |  3 --
 SRT.java     | 31 +++++++++---------
 3 files changed, 77 insertions(+), 48 deletions(-)

diff --git a/FCFS.java b/FCFS.java
index c3ce857..0e6dcbc 100644
--- a/FCFS.java
+++ b/FCFS.java
@@ -1,7 +1,7 @@
 import java.util.LinkedList;
 
 /**
- * First Come First Serve Algorithm
+ * Shortest Remaining Time
  */
 public class FCFS {
 
@@ -55,61 +55,92 @@ public class FCFS {
         {
             waitingQueue.add(newProcesses.get(i));
         }
-        
         newProcesses.clear();
     }
 
     public void runDispatch()
-    {
+    {       
         System.out.println("FCFS:");
         int processesFinished = 0;
-        boolean startNew = true;
-        //timeStep++;
+        Process currentProcess;
+        Process lastRunProcess = new Process("temp", 0, 0, 0);  //temp process for comparing the first run
         
         do
          {
-            if(startNew)
-            {
-                timeStep = timeStep+disp;
-                startNew = false; 
-            }
-            else
-            {
-                ;
-            }
-            
-            checkForArrivals();
-             
+            checkForArrivals(); //Check for any new processes since timestep            
+
+            //As long as there is something in the queue
             if(waitingQueue.size()>0)
             {
-                if(waitingQueue.getFirst().isDone())
+                currentProcess = findShortestProcess();
+                
+                if(!lastRunProcess.getId().equals(currentProcess.getId()))
                 {
-                    waitingQueue.removeFirst();
+                    timeStep = timeStep+disp;
+                    System.out.println("T"+timeStep+": "+currentProcess.getId());
+                    for(int i = 0; i<waitingQueue.size(); i++)
+                    {
+                        waitingQueue.get(i).runForOneTick(false);
+                    }
+                }
+
+                runProcessTick(currentProcess);
+                
+                if(currentProcess.isDone())
+                {
+                    waitingQueue.remove(currentProcess);
                     processesFinished++;
-                    startNew = true;
-                }
-                else
-                {
-                    runProcessTick(waitingQueue.getFirst());
                 }
+
+                lastRunProcess = currentProcess;
             }
             
          }while(processesFinished!=processListFromFile.size());      
     }
 
+    private Process findShortestProcess()
+    {
+        // int listPos = -1;
+        // int remaining = waitingQueue.getFirst().getRemainingTime();
+
+        // for(int i = 0; i<waitingQueue.size(); i++)
+        // {
+        //     if(waitingQueue.get(i).getRemainingTime()<remaining)
+        //     {
+        //         listPos = i;
+        //         remaining = waitingQueue.get(i).getRemainingTime();
+        //     }
+        // }
+
+        // if(listPos==-1)
+        // {
+        //     return waitingQueue.getFirst();
+        // }
+        // else
+        // {
+        return waitingQueue.getFirst();
+    
+    }
+
     private void runProcessTick(Process input)
     {   
-        input.saveStartTime(timeStep);
-        
         timeStep++;
-
-        input.runForOneTick(true);
+        for(int i = 0; i< waitingQueue.size(); i++)
+        {
+            if(!input.getId().equals(waitingQueue.get(i).getId()))
+            {
+                waitingQueue.get(i).runForOneTick(false);
+            }
+            else
+            {
+                waitingQueue.get(i).runForOneTick(true);
+            }
+        }
 
         if(input.isDone())
         {
             input.saveEndTime(timeStep);
             input.saveTurnTime();
-            input.saveWaitTime();
         }       
     }    
 
@@ -117,7 +148,7 @@ public class FCFS {
     {
         for (int i = 0; i < processListFromFile.size(); i++)
         {
-            System.out.println("T"+processListFromFile.get(i).getStartTime()+": "+processListFromFile.get(i).getId());
+            //System.out.println("T"+processListFromFile.get(i).getStartTime()+": "+processListFromFile.get(i).getId());
         }
         
         System.out.println("\nProcess \tTurnaround Time \tWaiting Time");
diff --git a/Process.java b/Process.java
index 913a051..a7a0972 100644
--- a/Process.java
+++ b/Process.java
@@ -12,9 +12,6 @@ public class Process {
     private int endTime= -1;
 
     private int remainingTime;
-
-    public int hold = -1;
-    public int unhold = -1;
      
 
     //Constructors
diff --git a/SRT.java b/SRT.java
index 2953c10..b5c6fe1 100644
--- a/SRT.java
+++ b/SRT.java
@@ -67,13 +67,13 @@ public class SRT {
         
         do
          {
-            checkForArrivals(); //Check for any new processes since timestep
+            checkForArrivals(); //Check for any new processes since timestep            
 
-            currentProcess = findShortestProcess(); //get the shortest one out of that
-            
             //As long as there is something in the queue
             if(waitingQueue.size()>0)
             {
+                currentProcess = findShortestProcess();
+                
                 if(!lastRunProcess.getId().equals(currentProcess.getId()))
                 {
                     timeStep = timeStep+disp;
@@ -85,8 +85,7 @@ public class SRT {
                 }
 
                 runProcessTick(currentProcess);
-
-                //convert to all be process driven instead of index driven
+                
                 if(currentProcess.isDone())
                 {
                     waitingQueue.remove(currentProcess);
@@ -101,10 +100,10 @@ public class SRT {
 
     private Process findShortestProcess()
     {
-        int listPos = 0;
-        int remaining = waitingQueue.get(0).getRemainingTime();
+        int listPos = -1;
+        int remaining = waitingQueue.getFirst().getRemainingTime();
 
-        for(int i = 1; i<waitingQueue.size(); i++)
+        for(int i = 0; i<waitingQueue.size(); i++)
         {
             if(waitingQueue.get(i).getRemainingTime()<remaining)
             {
@@ -113,15 +112,19 @@ public class SRT {
             }
         }
 
-        return waitingQueue.get(listPos);
+        if(listPos==-1)
+        {
+            return waitingQueue.getFirst();
+        }
+        else
+        {
+            return waitingQueue.get(listPos);
+        }
     }
 
     private void runProcessTick(Process input)
     {   
-        input.saveStartTime(timeStep);
-        
-        
-
+        timeStep++;
         for(int i = 0; i< waitingQueue.size(); i++)
         {
             if(!input.getId().equals(waitingQueue.get(i).getId()))
@@ -134,8 +137,6 @@ public class SRT {
             }
         }
 
-        timeStep++;
-
         if(input.isDone())
         {
             input.saveEndTime(timeStep);