Write a program in the language of your choice (prefer C or Java) that will simu
ID: 3813343 • Letter: W
Question
Write a program in the language of your choice (prefer C or Java) that will simulate process scheduling
-From the command line, you take in the input file name as one of the arguments
-The input file will be a CSV file
-Format: priority, submission time, CPU burst time, IO burst time, CPU, IO ...(use more CPU burst time or IO burst time if needed)
-The number of rows in the file is the number of process profiles
2.Simulate the following scheduling algorithms
-FCFS
-SJF
-Priority First
-Round Robin
3.Your program should analyze the given sets of process profiles
-Average Wait time
-Average Turnaround time
-Throughput per mys
3.If you work in groups there are additional requirements for each team member added.
-Deliverables
-All source code
-Output analysis for each given set of process profiles
5.Input files
sample1.csv
1 0 100 1 0 100 1 0 100 1 0 100 1 0 100 1 0 100 1 500 200 1 500 200 1 500 200 1 500 200 1 500 200 1 500 200 1 500 200 3 1000 200 3 1000 200 3 1000 200 3 1000 200 3 1000 200 3 1000 200Explanation / Answer
Code:
Test.java
import java.util.Queue;
public class Test {
public static void main(String[] args) {
ReadFile rf = new ReadFile();
Queue<Process1> qp = rf.read("input.txt");
Processor processor = new Processor(qp);
// processor.RR();
// processor.FCFS();
// processor.SJF();
processor.priorityFirst();
}
}
ReadFile.java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Queue;
public class ReadFile {
public Queue<Process1> read(String fileName) {
BufferedReader br = null;
FileReader fr = null;
Queue<Process1> processQueue = null;
try {
String sCurrentLine;
fr = new FileReader(new File(fileName));
br = new BufferedReader(fr);
processQueue = new LinkedList<Process1>();
while ((sCurrentLine = br.readLine()) != null) {
System.out.println(sCurrentLine);
String line[] = sCurrentLine.split(",");
Process1 p = new Process1(line[0], Integer.parseInt(line[1]), Integer.parseInt(line[2]),
Integer.parseInt(line[3]));
processQueue.add(p);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null)
br.close();
if (fr != null)
fr.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
return processQueue;
}
}
Process1.java
public class Process1 implements Comparable<Process1> {
public int getTotalExecutedTime() {
return totalExecutedTime;
}
public void setTotalExecutedTime(int totalExecutedTime) {
this.totalExecutedTime = totalExecutedTime;
}
public int getPriority() {
return priority;
}
public void setPriority(int priority) {
this.priority = priority;
}
public String getProcessName() {
return processName;
}
public void setProcessName(String processName) {
this.processName = processName;
}
public Process1(String processName, int priority, int arrivalTime, int serviceTime) {
super();
this.processName = processName;
this.arrivalTime = arrivalTime;
this.serviceTime = serviceTime;
this.priority = priority;
}
public int getArrivalTime() {
return arrivalTime;
}
public void setArrivalTime(int arrivalTime) {
this.arrivalTime = arrivalTime;
}
public int getServiceTime() {
return serviceTime;
}
public void setServiceTime(int serviceTime) {
this.serviceTime = serviceTime;
}
private String processName;
private int arrivalTime;
private int serviceTime;
private int priority;
private int totalExecutedTime = 0;
@Override
public int compareTo(Process1 o) {
return this.serviceTime - o.getServiceTime();
}
}
Processor.java
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Processor {
public Queue<Process1> getWaitingQueue() {
return waitingQueue;
}
public void setWaitingQueue(Queue<Process1> waitingQueue) {
this.waitingQueue = waitingQueue;
}
public int getCurrentTime() {
return currentTime;
}
public void setCurrentTime(int currentTime) {
this.currentTime = currentTime;
}
public Queue<Process1> getProcesses() {
return processes;
}
public void setProcesses(Queue<Process1> processes) {
this.processes = processes;
}
public String getProcessorName() {
return processorName;
}
public void setProcessorName(String processorName) {
this.processorName = processorName;
}
public int getNumberOfProcesses() {
return numberOfProcesses;
}
public void setNumberOfProcesses(int numberOfProcesses) {
this.numberOfProcesses = numberOfProcesses;
}
public int getQuantumTime() {
return quantumTime;
}
public void setQuantumTime(int quantumTime) {
this.quantumTime = quantumTime;
}
public Processor(String processorName, int numberOfProcesses, int quantumTime) {
super();
this.processorName = processorName;
this.numberOfProcesses = numberOfProcesses;
this.quantumTime = quantumTime;
}
private String processorName;
private int numberOfProcesses;
private int quantumTime = 50;
private Queue<Process1> processes;
// public void initProcessor(Queue<Process1> p) {
// Process1 process1 = p.poll();
// this.setProcessorName(process1.getProcessName());
// this.setNumberOfProcesses(process1.getArrivalTime());
// this.setQuantumTime(process1.getServiceTime());
// this.setProcesses(p);
// }
public Processor() {
super();
}
public Processor(Queue<Process1> qp) {
this.processes = qp;
}
private int currentTime = 0;
public void FCFS() {
Queue<Process1> processes = this.getProcesses();
int waitingTime = 0;
int turnAroundTime = 0;
int processCount = processes.size();
System.out.println("Output : ProcessName:SubmissionTime->BustTime");
while (!processes.isEmpty()) {
Process1 p = processes.poll();
System.out.println(p.getProcessName() + ":" + currentTime + "->" + (currentTime + p.getServiceTime()));
turnAroundTime += currentTime + p.getServiceTime() - p.getArrivalTime();
waitingTime += currentTime - p.getArrivalTime();
currentTime += p.getServiceTime();
}
System.out.println("Average Waiting Time: " + waitingTime / processCount);
System.out.println("Average Turn Around Time: " + turnAroundTime / processCount);
}
private Queue<Process1> waitingQueue = new LinkedList<Process1>();
public void RR() {
Queue<Process1> processes = this.getProcesses();
int waitingTime = 0;
int turnAroundTime = 0;
int processCount = processes.size();
while (!processes.isEmpty() || !waitingQueue.isEmpty()) {
Iterator<Process1> iter = this.getProcesses().iterator();
while (iter.hasNext()) {
Process1 process1 = iter.next();
if (process1.getArrivalTime() <= currentTime) {
waitingQueue.add(process1);
iter.remove();
}
}
Process1 p = waitingQueue.poll();
int executionTime = (p.getServiceTime() < this.quantumTime) ? p.getServiceTime() : this.quantumTime;
System.out.println(p.getProcessName() + ":" + currentTime + "->" + (currentTime + executionTime));
p.setServiceTime(p.getServiceTime() - executionTime);
p.setTotalExecutedTime(p.getTotalExecutedTime() + executionTime);
currentTime += executionTime;
if (p.getServiceTime() > 0) {
waitingQueue.add(p);
} else if (p.getServiceTime() == 0) {
turnAroundTime += currentTime + p.getServiceTime() - p.getArrivalTime();
waitingTime += currentTime - p.getArrivalTime() - p.getTotalExecutedTime();
}
}
System.out.println("Average Waiting Time: " + waitingTime / processCount);
System.out.println("Average Turn Around Time: " + turnAroundTime / processCount);
}
public void SJF() {
Queue<Process1> processes = this.getProcesses();
int waitingTime = 0;
int turnAroundTime = 0;
int processCount = processes.size();
while (!processes.isEmpty() || !waitingQueue.isEmpty()) {
Iterator<Process1> iter = this.getProcesses().iterator();
while (iter.hasNext()) {
Process1 process1 = iter.next();
if (process1.getArrivalTime() <= currentTime) {
waitingQueue.add(process1);
iter.remove();
}
}
Collections.sort((List<Process1>) waitingQueue);
Process1 p = waitingQueue.poll();
int executionTime = p.getServiceTime();
System.out.println(p.getProcessName() + ":" + currentTime + "->" + (currentTime + executionTime));
p.setServiceTime(p.getServiceTime() - executionTime);
p.setTotalExecutedTime(p.getTotalExecutedTime() + executionTime);
currentTime += executionTime;
if (p.getServiceTime() > 0) {
waitingQueue.add(p);
} else if (p.getServiceTime() == 0) {
turnAroundTime += currentTime + p.getServiceTime() - p.getArrivalTime();
waitingTime += currentTime - p.getArrivalTime() - p.getTotalExecutedTime();
}
}
System.out.println("Average Waiting Time: " + waitingTime / processCount);
System.out.println("Average Turn Around Time: " + turnAroundTime / processCount);
}
public void priorityFirst() {
Queue<Process1> processes = this.getProcesses();
int waitingTime = 0;
int turnAroundTime = 0;
int processCount = processes.size();
while (!processes.isEmpty() || !waitingQueue.isEmpty()) {
Iterator<Process1> iter = this.getProcesses().iterator();
while (iter.hasNext()) {
Process1 process1 = iter.next();
if (process1.getArrivalTime() <= currentTime) {
waitingQueue.add(process1);
iter.remove();
}
}
PrioritySort ps = new PrioritySort();
Collections.sort((List<Process1>) waitingQueue, ps);
Process1 p = waitingQueue.poll();
int executionTime = p.getServiceTime();
System.out.println(p.getProcessName() + ":" + currentTime + "->" + (currentTime + executionTime));
p.setServiceTime(p.getServiceTime() - executionTime);
p.setTotalExecutedTime(p.getTotalExecutedTime() + executionTime);
currentTime += executionTime;
if (p.getServiceTime() > 0) {
waitingQueue.add(p);
} else if (p.getServiceTime() == 0) {
turnAroundTime += currentTime + p.getServiceTime() - p.getArrivalTime();
waitingTime += currentTime - p.getArrivalTime() - p.getTotalExecutedTime();
}
}
System.out.println("Average Waiting Time: " + waitingTime / processCount);
System.out.println("Average Turn Around Time: " + turnAroundTime / processCount);
}
}
PrioritySort.java
import java.util.Comparator;
public class PrioritySort implements Comparator<Process1> {
@Override
public int compare(Process1 o1, Process1 o2) {
return o1.getPriority() - o2.getPriority();
}
}
input.txt
A,2,0,100
B,1,0,100
C,1,0,100
D,1,0,50
E,1,0,100
F,1,0,100
G,2,500,200
H,1,500,200
I,2,500,200
J,2,500,50
K,2,500,200
L,1,500,200
M,1,500,200
N,3,1000,200
O,3,1000,200
P,3,1000,200
Q,3,1000,200
R,3,1000,200
S,3,1000,200
Output:
B:0->100
C:100->200
D:200->250
E:250->350
F:350->450
A:450->550
H:550->750
L:750->950
M:950->1150
G:1150->1350
I:1350->1550
J:1550->1600
K:1600->1800
N:1800->2000
O:2000->2200
P:2200->2400
Q:2400->2600
R:2600->2800
S:2800->3000
Average Waiting Time: 713
Average Turn Around Time: 871
Comment:
In the Processor.java we have the logic to do the different kinds of schedules. The above output is for the RoundRobin(default quantum time 50ms). I considered FCFS as non-preemptive and all the other schedule preemptive considering (arrival time & priority) for priority scheduling, quantum time(in case of RoundRobin), shortest burst time in case of SJF. Calculated average waiting time and average turn around time also. All the best. Just put all the files in same folder and run Test.java.
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.