Round Robin Scheduling Algorithm with Different Arrival Time

//JAVA Program for implementing
//Round Robin Algorithm
// code by Sparsh_cbs
import java.util.*;

public class RoundRobin{
    private static Scanner inp = new Scanner(System.in);
    //Driver Code
    public static void main(String[] args){
        int n,tq, timer = 0, maxProccessIndex = 0;
        float avgWait = 0, avgTT = 0;
        System.out.print("\nEnter the time quanta : ");
        tq = inp.nextInt();
        System.out.print("\nEnter the number of processes : ");
        n = inp.nextInt();
        int arrival[] = new int[n];
        int burst[] = new int[n];
        int wait[] = new int[n];
        int turn[] = new int[n];
        int queue[] = new int[n];
        int temp_burst[] = new int[n];
        boolean complete[] = new boolean[n];

        System.out.print("\nEnter the arrival time of the processes : ");
        for(int i = 0; i < n; i++)
            arrival[i] = inp.nextInt();

        System.out.print("\nEnter the burst time of the processes : ");
        for(int i = 0; i < n; i++){
            burst[i] = inp.nextInt();
            temp_burst[i] = burst[i];
        }

        for(int i = 0; i < n; i++){    //Initializing the queue and complete array
            complete[i] = false;
            queue[i] = 0;
        }
        while(timer < arrival[0])    //Incrementing Timer until the first process arrives
            timer++; 
        queue[0] = 1;
        
        while(true){
            boolean flag = true;
            for(int i = 0; i < n; i++){
                if(temp_burst[i] != 0){
                    flag = false;
                    break;
                }
            }
            if(flag)
                break;

            for(int i = 0; (i < n) && (queue[i] != 0); i++){
                int ctr = 0;
                while((ctr < tq) && (temp_burst[queue[0]-1] > 0)){
                    temp_burst[queue[0]-1] -= 1;
                    timer += 1;
                    ctr++;

                    //Updating the ready queue until all the processes arrive
                    checkNewArrival(timer, arrival, n, maxProccessIndex, queue);
                }
                if((temp_burst[queue[0]-1] == 0) && (complete[queue[0]-1] == false)){
                    turn[queue[0]-1] = timer;        //turn currently stores exit times
                    complete[queue[0]-1] = true;
                }
                
                  //checks whether or not CPU is idle
                boolean idle = true;
                if(queue[n-1] == 0){
                    for(int k = 0; k < n && queue[k] != 0; k++){
                        if(complete[queue[k]-1] == false){
                            idle = false;
                        }
                    }
                }
                else
                    idle = false;

                if(idle){
                    timer++;
                    checkNewArrival(timer, arrival, n, maxProccessIndex, queue);
                }
              
                //Maintaining the entries of processes after each premption in the ready Queue
                queueMaintainence(queue,n);
            }
        }

        for(int i = 0; i < n; i++){
            turn[i] = turn[i] - arrival[i];
            wait[i] = turn[i] - burst[i];
        }

        System.out.print("\nProgram No.\tArrival Time\tBurst Time\tWait Time\tTurnAround Time"
                         + "\n");
        for(int i = 0; i < n; i++){
            System.out.print(i+1+"\t\t"+arrival[i]+"\t\t"+burst[i]
                             +"\t\t"+wait[i]+"\t\t"+turn[i]+ "\n");
        }
        for(int i =0; i< n; i++){
            avgWait += wait[i];
            avgTT += turn[i]; 
        }
        System.out.print("\nAverage wait time : "+(avgWait/n)
                         +"\nAverage Turn Around Time : "+(avgTT/n));
    }
    public static void queueUpdation(int queue[],int timer,int arrival[],int n, int maxProccessIndex){
        int zeroIndex = -1;
        for(int i = 0; i < n; i++){
            if(queue[i] == 0){
                zeroIndex = i;
                break;
            }
        }
        if(zeroIndex == -1)
            return;
        queue[zeroIndex] = maxProccessIndex + 1;
    }

    public static void checkNewArrival(int timer, int arrival[], int n, int maxProccessIndex,int queue[]){
        if(timer <= arrival[n-1]){
            boolean newArrival = false;
            for(int j = (maxProccessIndex+1); j < n; j++){
                if(arrival[j] <= timer){
                    if(maxProccessIndex < j){
                        maxProccessIndex = j;
                        newArrival = true;
                    }
                }
            }
            if(newArrival)    //adds the index of the arriving process(if any)
                queueUpdation(queue,timer,arrival,n, maxProccessIndex);        
        }
    }
  
    public static void queueMaintainence(int queue[], int n){

        for(int i = 0; (i < n-1) && (queue[i+1] != 0) ; i++){
            int temp = queue[i];
            queue[i] = queue[i+1];
            queue[i+1] = temp; 
        }
    }
}

// Java Code
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

class GFG {

  // At every time quantum or when a process has been
  // executed before the time quantum, check for any new
  // arrivals and push them into the queue
  public static void
    checkForNewArrivals(Process[] processes, int n,
                        int currentTime,
                        Queue<Integer> readyQueue)
  {
    for (int i = 0; i < n; i++) {
      Process p = processes[i];
      // checking if any processes has arrived
      // if so, push them in the ready Queue.
      if (p.arrivalTime <= currentTime && !p.inQueue
          && !p.isComplete) {
        processes[i].inQueue = true;
        readyQueue.add(i);
      }
    }
  }

  // Context switching takes place at every time quantum
  // At every iteration, the burst time of the processes
  // in the queue are handled using this method
  public static void
    updateQueue(Process[] processes, int n, int quantum,
                Queue<Integer> readyQueue, int currentTime,
                int programsExecuted)
  {
    int i = readyQueue.remove();

    // if the process is going to be finished executing,
    // ie, when it's remaining burst time is less than
    // time quantum mark it completed and increment the
    // current time and calculate its waiting time and
    // turnaround time
    if (processes[i].burstTimeRemaining <= quantum) {
      processes[i].isComplete = true;
      currentTime += processes[i].burstTimeRemaining;
      processes[i].completionTime = currentTime;
      processes[i].waitingTime
        = processes[i].completionTime
        - processes[i].arrivalTime
        - processes[i].burstTime;
      processes[i].turnaroundTime
        = processes[i].waitingTime
        + processes[i].burstTime;

      if (processes[i].waitingTime < 0)
        processes[i].waitingTime = 0;

      processes[i].burstTimeRemaining = 0;

      // if all the processes are not yet inserted in
      // the queue, then check for new arrivals
      if (programsExecuted != n) {
        checkForNewArrivals(
          processes, n, currentTime, readyQueue);
      }
    }
    else {
      // the process is not done yet. But it's going
      // to be pre-empted since one quantum is used
      // but first subtract the time the process used
      // so far
      processes[i].burstTimeRemaining -= quantum;
      currentTime += quantum;

      // if all the processes are not yet inserted in
      // the queue, then check for new arrivals
      if (programsExecuted != n) {
        checkForNewArrivals(
          processes, n, currentTime, readyQueue);
      }
      // insert the incomplete process back into the
      // queue
      readyQueue.add(i);
    }
  }

  // Just a function that outputs the result in terms of
  // their PID.
  public static void output(Process[] processes, int n)
  {
    double avgWaitingTime = 0;
    double avgTurntaroundTime = 0;
    // sort the processes array by processes.PID
    Arrays.sort(processes, (Process p1, Process p2) -> {
      return p1.pid - p2.pid;
    });

    for (int i = 0; i < n; i++) {
      System.out.println(
        "Process " + processes[i].pid
        + ": Waiting Time: "
        + processes[i].waitingTime
        + " Turnaround Time: "
        + processes[i].turnaroundTime);
      avgWaitingTime += processes[i].waitingTime;
      avgTurntaroundTime
        += processes[i].turnaroundTime;
    }
    System.out.println("Average Waiting Time: "
                       + avgWaitingTime / n);
    System.out.println("Average Turnaround Time: "
                       + avgTurntaroundTime / n);
  }

  /*
     * This function assumes that the processes are already
     * sorted according to their arrival time
     */
  public static void roundRobin(Process[] processes,
                                int n, int quantum)
  {
    Queue<Integer> readyQueue
      = new LinkedList<Integer>();
    readyQueue.add(0); // initially, pushing the first
    // process which arrived first
    processes[0].inQueue = true;

    int currentTime
      = 0; // holds the current time after each
    // process has been executed
    int programsExecuted
      = 0; // holds the number of programs executed so
    // far

    while (!readyQueue.isEmpty()) {
      updateQueue(processes, n, quantum, readyQueue,
                  currentTime, programsExecuted);
    }
  }

  public static class Process {
    int pid;
    int arrivalTime;
    int burstTime;
    int burstTimeRemaining; // the amount of CPU time
    // remaining after each
    // execution
    int completionTime;
    int turnaroundTime;
    int waitingTime;
    boolean isComplete;
    boolean inQueue;
  }

  public static void main(String[] args)
  {
    int n, quantum;

    System.out.println(
      "Enter the number of processes: ");
    n = Integer.parseInt(System.console().readLine());
    System.out.println("Enter time quantum: ");
    quantum
      = Integer.parseInt(System.console().readLine());

    Process[] processes = new Process[n + 1];

    for (int i = 0; i < n; i++) {
      System.out.println(
        "Enter arrival time and burst time of each process "
        + (i + 1) + ": ");
      processes[i].arrivalTime = Integer.parseInt(
        System.console().readLine());
      processes[i].burstTime = Integer.parseInt(
        System.console().readLine());
      processes[i].burstTimeRemaining
        = processes[i].burstTime;
      processes[i].pid = i + 1;
      System.out.println();
    }

    // stl sort in terms of arrival time
    Arrays.sort(processes, (Process p1, Process p2) -> {
      return p1.arrivalTime - p2.arrivalTime;
    });

    roundRobin(processes, n, quantum);

    output(processes, n);
  }
}

// This code is contributed by akashish__