Question

implement a program, which allow you to evaluate and compare different scheduling algorithms. List of implemented algorithms for evaluation should include FCFS algorithm and at least one from the following:

-SJF – preemptive and non-preemptive

-Priority scheduling – preemptive and non-preemptive

-RR

-Multilevel feedback queue

Your program should be able to work in two different modes: “Single algorithm performance evaluation” and “Algorithm comparing”

Answer 1

import java.util.Scanner;

// Class RoundRobin definition

class RoundRobin

{

// Scanner class object created to accept data

Scanner keyboard = new Scanner(System.in);

int[] burstTime, remainingTime, waitingTime, turnAroundTime;

int numberOfProcess, quantum;

float totalWT = 0, totalTAT = 0;

int flag = 0;

  

// Method to accept data

void acceptData()

{

// Accepts number of processes

System.out.print("Enter the no of process: ");

numberOfProcess = keyboard.nextInt();

// Dynamically allocates memory for all the arrays

burstTime = new int[numberOfProcess];

waitingTime = new int[numberOfProcess];

turnAroundTime = new int[numberOfProcess];

remainingTime = new int[numberOfProcess];

// Loops till number of process

for(int c = 0; c < numberOfProcess; c++)

{

// Accepts burst time for each process

System.out.print("Enter burst time of P" + (c + 1) + ": ");

burstTime[c] = remainingTime[c] = keyboard.nextInt();

}// End of for loop

// Accepts time quantum

System.out.print("Enter Time Quantum: ");

quantum = keyboard.nextInt();

}// End of method

  

// Method to implement Round Robin algorithm

void RRScheduling()

{

// Loops till flag is not 1

do

{

// Initializes flag to zero

flag = 0;

// Loops till number of process

for(int c = 0; c < numberOfProcess; c++)

{

// Checks if remaining time of process c is greater than or equals to time quantum

if(remainingTime[c] >= quantum)

{

// Displays each process and its remaining time

System.out.print("P"+(c + 1)+ " -> " + "\t");

// Loops till number of process

for(int d = 0; d < numberOfProcess; d++)

{

// Checks if d value is equals to c

if(d == c)

// Update the remaining time of process c

// by subtract the time quantum from remaining time of process c

remainingTime[c] = remainingTime[c] - quantum;

// Otherwise checks if the remaining time of process d is greater than zero

else if(remainingTime[d] > 0)

// Update the waiting time of process d

// by adding waiting time of process d with time quantum

waitingTime[d] += quantum;

}// End of inner for loop

}// End of if condition

// Otherwise checks remaining time of process c is greater than zero

else if(remainingTime[c] > 0)

{

// Displays each process and its remaining time

System.out.print("P"+(c + 1)+ " -> " + "\t");

// Loops till number of process

for(int d = 0; d < numberOfProcess; d++)

{

// Checks if d value is equals to c

if(d == c)

// Set the remaining time of process c to zero

remainingTime[c] = 0;

// Otherwise checks if the remaining time of process d is greater than zero

else if(remainingTime[d] > 0)

// Update the waiting time of process d

// by adding remaining time of process c with time quantum

waitingTime[d] += remainingTime[c];

}// End of inner for loop

}// End of else if condition

}// End of outer for loop

// Loops till number of process

for(int c = 0; c < numberOfProcess; c++)

// Checks if the remaining time of process c is greater than zero

if(remainingTime[c] > 0)

// Set the flag to one

flag = 1;

}while(flag == 1); // End of do - while loop

// Loops till number of process

for(int c = 0; c < numberOfProcess; c++)

// Calculates turn around time of each process

turnAroundTime[c] = waitingTime[c] + burstTime[c];

}// End of method

  

// Method to display processes information

void display()

{

// Displays the heading

System.out.println("\nProcess\tBurst\tWaiting\tTurnaround");

// Loops till number of process

for(int c = 0; c < numberOfProcess; c++)

{

// Displays process number, burst time, waiting time and turn around time

System.out.println("P" + (c + 1) + "\t" + burstTime[c] + "\t"+waitingTime[c] + "\t" + turnAroundTime[c]);

// Calculates total waiting time

totalWT += waitingTime[c];

// Calculates total turn around time

totalTAT += turnAroundTime[c];

}// End of for loop

// Calculates and displays average waiting time and average turn around time

System.out.printf("%nAverage waiting time: %f", (totalWT / numberOfProcess));

System.out.printf("%nAverage Turnaround time: %f", (totalTAT / numberOfProcess));

}// End of method

}// End of class

// Class FCFS definition

class FCFS

{

// Method to implement FCFS

public void FCFSScheduling()

{

// Scanner class object created

Scanner in = new Scanner(System.in);

// To store number of process

int numberOfProcess;

float totalWT = 0, totalTAT = 0;

// Accepts number of processes from the user

System.out.print("Enter number of processes: ");

numberOfProcess = in.nextInt();

// Dynamically allocates memory for burstTime array

int burstTime[] = new int[numberOfProcess];

System.out.print("Enter burst time");

// Loops till number of process

for(int c = 0; c < numberOfProcess; c++)

{

// Accepts burst time for each process

System.out.print("Burst time for P" + (c + 1) + " = ");

burstTime[c ] =in.nextInt();

}// End of for loop

// Dynamically allocates memory for waitingTime array

int waitingTime[] = new int[numberOfProcess];

waitingTime[0] = 0;

// Loops till number of process

for(int c = 1; c < numberOfProcess; c++)

{

// Calculates waiting time of each process

waitingTime[c] = burstTime[c - 1] + waitingTime[c - 1];

// Calculates total waiting time

totalWT += waitingTime[c];

}// End of for loop

// Dynamically allocates memory for turnAroundTime array

int turnAroundTime[] = new int[numberOfProcess];

// Loops till number of process

for(int c = 0; c < numberOfProcess; c++)

{

// Calculates turn around time

turnAroundTime[c] = burstTime[c] + waitingTime[c];

// Calculates total turn around time

totalTAT += turnAroundTime[c];

}// End of for loop

// Displays heading

System.out.println("Process\tBurst time\tWaiting time\tTurn Around time");

// Loops till number of process

for(int c = 0; c < numberOfProcess; c++)

{

// Displays each process number, burst time, waiting time and turn around time

System.out.println("P" + (c + 1) + "\t\t" + burstTime[c] + "\t\t" + waitingTime[c] + "\t\t"+turnAroundTime[c]);

}// End of for loop

System.out.printf("%nAverage Waiting time = %f", totalWT / numberOfProcess);

System.out.printf("%nAverage Turn Around time = %f", totalTAT / numberOfProcess);

}// End of for loop

}// End of class

// Driver class CompareFCFSAndRR definition

public class CompareFCFSAndRR

{

// main method definition

public static void main(String[] args)

{

System.out.println("\t\tFCFS");

// Creates an object of FCFS class

FCFS fcfs = new FCFS();

// Calls the method to implement FCFS scheduling

fcfs.FCFSScheduling();

System.out.println("\n\n\t\tRR");

// Creates an object of RoundRobin class

RoundRobin rr = new RoundRobin();

// Calls the method to accept data

rr.acceptData();

// Calls the method to implement RR scheduling

rr.RRScheduling();

// Calls the method to display result

rr.display();   

}// End of main method

}// End of class

Sample Run:

FCFS

Enter number of processes: 3

Enter burst timeBurst time for P1 = 10

Burst time for P2 = 7

Burst time for P3 = 5

Process Burst time Waiting time Turn Around time

P1 10 0 10

P2 7 10 17

P3 5 17 22

Average Waiting time = 9.000000

Average Turn Around time = 16.333334

RR

Enter the no of process: 3

Enter burst time of P1: 10

Enter burst time of P2: 7

Enter burst time of P3: 5

Enter Time Quantum: 3

P1 -> P2 -> P3 -> P1 -> P2 -> P3 -> P1 -> P2 -> P1 ->

Process Burst Waiting Turnaround

P1 10 12 22

P2 7 14 21

P3 5 12 17

Average waiting time: 12.666667

Average Turnaround time: 20.000000