Assignment No.

3
UCE2023431

Title: Simulation of the scheduling algorithms. For example: First Come

First Serve
(FCFS), Shortest Job First (SJF).
Objective: To implement non-pre-emptive CPU scheduling algorithms.

Code:

import java.util.*;
class PCB{
​ String n;
​ int arrivalTime, burstTime, completionTime, waitingTime,
turnaroundTime;
​ PCB(String n, int at, int bt) {
​ ​ this.n = n;
​ ​ arrivalTime = at;
​ ​ burstTime = bt;
​ ​ waitingTime = 0;
​ ​ turnaroundTime = 0;
​ }
​
​ void calcTTWT(PCB process) {
​ ​
process.turnaroundTime=process.completionTime-process.arrivalTim
e;
​ ​
process.waitingTime=process.turnaroundTime-process.burstTime;
​ }
}
public class Main {
​ static Scanner sc = new Scanner(System.in);
​ static void sortArr(PCB[] jobQueue) {
​ ​ Arrays.sort(jobQueue, (p1, p2) ->
Integer.compare(p1.arrivalTime, p2.arrivalTime));
​ }
​
​ static void FCFS(PCB[] jobQueue) {
​ ​ sortArr(jobQueue);
​ ​ for (int i = 0; i < jobQueue.length; i++) {
​ ​ ​ if (i == 0) {
​ ​ ​ ​ jobQueue[i].completionTime =
jobQueue[i].arrivalTime+ jobQueue[i].burstTime;
​ ​ ​ } else {
​ ​ ​ ​ //ct of prev + bt of curr
​ ​ ​ ​ jobQueue[i].completionTime =
jobQueue[i].burstTime + jobQueue[i-1].completionTime;
​ ​ ​ }
​ ​ ​ jobQueue[i].calcTTWT(jobQueue[i]);
​ ​ }
​ }

​ static void SJF(PCB[] jobQueue) {

​ ​ sortArr(jobQueue);
​ PriorityQueue<PCB> readyQueue = new
PriorityQueue<>(Comparator.comparingInt(p -> p.burstTime));
​ // sort comparator burst time
​ int currentTime = 0;
​ int i = 0;
​ while (i < jobQueue.length || !readyQueue.isEmpty()) {
// processes waiting in the ready ques or till all the process
in job queue not completed
​ while (i < jobQueue.length &&
jobQueue[i].arrivalTime <= currentTime) {
​ readyQueue.add(jobQueue[i]); // PQ will sort it
during insertion
​ i++;
​ }
​ if (readyQueue.isEmpty()) { // no process waiting
to be executed
​ if (i < jobQueue.length) {
​ currentTime = jobQueue[i].arrivalTime;
​ } else {
​ break;
​ }
​ continue; // readyQueue is empty here so
polling of the same should not take place
​ }
​ PCB p = readyQueue.poll();
​ p.completionTime = currentTime + p.burstTime;
​ currentTime = p.completionTime;
​ p.calcTTWT(p);
​ }
​ }
​
​ static void SRTF(PCB[] jobQueue) {
​ sortArr(jobQueue);
​ int[] remainingBurstTime = new int[jobQueue.length];
​ for (int i = 0; i < jobQueue.length; i++) {
​ remainingBurstTime[i] = jobQueue[i].burstTime;
​ }
​ int currentTime = 0;
​ int cp = 0; //completed processes count
​ PriorityQueue<Integer> readyQueue = new
PriorityQueue<>(Comparator.comparingInt(i ->
remainingBurstTime[i]));
​ // sort comparator remaining burst time
​ int i = 0;
​ while (cp < jobQueue.length) {
​ while (i < jobQueue.length &&
jobQueue[i].arrivalTime <= currentTime) {
​ readyQueue.add(i);
​ i++;
​ }
​ if (readyQueue.isEmpty()) {
​ currentTime++;
​ continue;
​ }
​ int p = readyQueue.poll();
​ remainingBurstTime[p]--;
​ currentTime++;
​ if (remainingBurstTime[p] == 0) {
​ cp++;
​ jobQueue[p].completionTime = currentTime;
​ jobQueue[p].calcTTWT(jobQueue[p]);
​ } else {
​ readyQueue.add(p);
​ }
​ }
​ }
​
​ static void RR(PCB[] jobQueue, int timeQuantum) {
​ ​ sortArr(jobQueue);
​ Queue<Integer> q = new LinkedList<>(); // q of indices
of the processes of jobQueue
​ int currentTime = 0;
​ int[] remainingBurstTime = new int[jobQueue.length];
​ for (int i = 0; i < jobQueue.length; i++) {
​ remainingBurstTime[i] = jobQueue[i].burstTime;
​ }
​ int i = 0;
​ while (i < jobQueue.length && jobQueue[i].arrivalTime
<= currentTime) {
​ q.add(i);
​ i++;
​ }
​ while (!q.isEmpty()) {
​ int p = q.poll();
​ if (remainingBurstTime[p] > timeQuantum) {
​ currentTime += timeQuantum;
​ remainingBurstTime[p] -= timeQuantum;
​ } else {
​ currentTime += remainingBurstTime[p];
​ jobQueue[p].completionTime = currentTime;
​ jobQueue[p].calcTTWT(jobQueue[p]);
​ remainingBurstTime[p] = 0;
​ }
​ while (i < jobQueue.length &&
jobQueue[i].arrivalTime <= currentTime) {
​ q.add(i);
​ i++;
​ }
​ if (remainingBurstTime[p] > 0) {
​ q.add(p);
​ }
​ }
​ }
​
​ static void displayA(PCB[] processes) {
​ ​ int ttsum = 0, wtsum = 0;
​ ​ for (int i = 0; i < processes.length; i++) {
​ ​ ​ System.out.println(processes[i].n + " " +
processes[i].arrivalTime + " " + processes[i].burstTime + " "
​ ​ ​ ​ ​ + processes[i].completionTime + " " +
processes[i].waitingTime + " " + processes[i].turnaroundTime);
​ ​ ​ ttsum = ttsum + processes[i].turnaroundTime;
​ ​ ​ wtsum = wtsum + processes[i].waitingTime;
​ ​ }
​ ​ System.out.println("Average turn around time: " +
ttsum / processes.length);
​ ​ System.out.println("Average waiting around time: " +
wtsum / processes.length);
​ ​
​ }
​
​ public static void main(String[] args) {
​ ​ System.out.print("Enter the number of processes: ");
​ ​ int p = sc.nextInt();
​ ​ PCB[] jobQueue = new PCB[p];
​ ​ int at, bt;
​ ​ String n;
​ ​ for (int i = 0; i < p; i++) {
​ ​ ​ sc.nextLine();
​ ​ ​ System.out.print("Enter the name of the process:
");
​ ​ ​ n = sc.nextLine();
​ ​ ​ System.out.print("Enter the arrival time: ");
​ ​ ​ at = sc.nextInt();
​ ​ ​ System.out.print("Enter the burst time: ");
​ ​ ​ bt = sc.nextInt();
​ ​ ​ jobQueue[i] = new PCB(n, at, bt);
​ ​ ​ System.out.println();
​ ​ }
​ ​
​ ​ int ch=0;
​ ​ do {
​ ​ ​ System.out.print("Enter your choice=> 1. FCFS
2. SJF 3. SRTF 4.RR : ");
​ ​ ​ ch=sc.nextInt();
​ ​ ​
​ ​ ​ switch(ch) {
​ ​ ​ ​ case 1: //FCFS
​ ​ ​ ​ ​ FCFS(jobQueue);
​ ​ ​ ​ ​ displayA(jobQueue);
​ ​ ​ ​ ​ break;
​ ​ ​ ​ case 2: //SJF
​ ​ ​ ​ ​ SJF(jobQueue);
​ ​ ​ ​ ​ displayA(jobQueue);
​ ​ ​ ​ ​ break;
​ ​ ​ ​ case 3: //SRTF
​ ​ ​ ​ ​ SRTF(jobQueue);
​ ​ ​ ​ ​ displayA(jobQueue);
​ ​ ​ ​ ​ break;
​ ​ ​ ​ case 4: //RR
​ ​ ​ ​ ​ System.out.print("Enter the time
quantum: ");
​ ​ ​ ​ ​ int q= sc.nextInt();
​ ​ ​ ​ ​ RR(jobQueue,q);
​ ​ ​ ​ ​ displayA(jobQueue);
​ ​ ​ ​ ​ break;
​ ​ ​ ​ case 0: //exit
​ ​ ​ ​ ​ System.out.println("Exited");
​ ​ ​ ​ ​ break;
​ ​ ​ ​ default: System.out.println("Invalid
choice!");
​ ​ ​ }
​ ​ } while (ch != 0);
​ }
}