Programming Assignment - Shortest Job First Scheduling

Author: dalmia

Assignment - Shortest Job first scheduling/AllocationStrategy.class

@@ -0,0 +1,22 @@
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Queue;
+
+/* implement this class for all three strategies */
+
+public abstract class AllocationStrategy {
+ protected List<Job> Jobs;
+ protected ArrayList<Job> Queue;
+
+ public AllocationStrategy(List<Job> jobs) {
+ super();
+ Jobs = jobs;
+ }
+
+ public abstract void run();
+ // update current job by 1 tick
+ // check if the job queue might need to be changed.
+ // check for jobs to add to the queue
+}

Assignment - Shortest Job first scheduling/AllocationStrategy.java

@@ -0,0 +1,99 @@
+public class Job {
+ private int id, submitTime, CPUTime, CPUTimeLeft;
+
+ private int startTime = 0, endTime = 0;
+
+
+ public int ProcessCompletionTime;
+ public int processArrivalTime;
+ public int waitingTime;
+ public int turnAroundTime;
+
+ private int arrivalTime,cpuTime,processId;
+
+ public Job(int processId, int arrivalTime, int cpuTime) {
+
+ this.processId = processId;
+ this.arrivalTime = arrivalTime;
+ this.cpuTime = cpuTime;
+
+ }
+
+ public void start(int sysTime) {
+ startTime = sysTime;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public int getSubmitTime() {
+ return submitTime;
+ }
+
+ public void setSubmitTime(int submitTime) {
+ this.submitTime = submitTime;
+ }
+
+ public int getCPUTime() {
+ return CPUTime;
+ }
+
+ public void setCPUTime(int cPUTime) {
+ CPUTime = cPUTime;
+ }
+
+ public int getCPUTimeLeft() {
+ return CPUTimeLeft;
+ }
+
+ public void setCPUTimeLeft(int cPUTimeLeft) {
+ CPUTimeLeft = cPUTimeLeft;
+ }
+
+ public int getStartTime() {
+ return startTime;
+ }
+
+ public void setStartTime(int startTime) {
+ this.startTime = startTime;
+ }
+
+ public int getEndTime() {
+ return endTime;
+ }
+
+ public void setEndTime(int endTime) {
+ this.endTime = endTime;
+ }
+
+ public int getArrivalTime() {
+ return arrivalTime;
+ }
+
+ public void setArrivalTime(int arrivalTime) {
+ this.arrivalTime = arrivalTime;
+ }
+
+ public int getCpuTime() {
+ return cpuTime;
+ }
+
+ public void setCpuTime(int cpuTime) {
+ this.cpuTime = cpuTime;
+ }
+
+ public int getProcessId() {
+ return processId;
+ }
+
+ public void setProcessId(int processId) {
+ this.processId = processId;
+ }
+
+
+}

Assignment - Shortest Job first scheduling/Job.class

@@ -0,0 +1,3 @@
+public interface JobFinishEvent {
+ public void onFinish(Job j);
+}

Assignment - Shortest Job first scheduling/Job.java

@@ -0,0 +1,54 @@
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+
+public class Question1 {
+
+ public static void main(String[] args) {
+
+ int quantum=20;
+ String filename = "testing.txt";
+
+ BufferedReader br = null;
+
+ try {
+
+ String sCurrentLine;
+
+ br = new BufferedReader(new FileReader(filename));
+ System.out.println("processId arrivalTime cpuTime");
+
+ List<Job> jobList = new ArrayList<Job>();
+ while ((sCurrentLine = br.readLine()) != null) {
+
+ String a[] = sCurrentLine.split(",");
+ int processId = new Integer(a[0]);
+ int arrivalTime = new Integer(a[1]);
+ int cpuTime = new Integer(a[2]);
+
+ Job job = new Job(processId, arrivalTime, cpuTime);
+ jobList.add(job);
+
+ System.out.println(processId + "\t\t" + arrivalTime + "\t\t" + cpuTime);
+ }
+
+ ShortestRemainingTime srtf = new ShortestRemainingTime(jobList);
+ srtf.run(jobList);
+
+ } catch (IOException e) {
+ e.printStackTrace();
+ } finally {
+ try {
+ if (br != null) br.close();
+ } catch (IOException ex) {
+ ex.printStackTrace();
+ }
+ }
+ }
+
+}

Assignment - Shortest Job first scheduling/JobFinishEvent.java

@@ -0,0 +1,93 @@
+import java.util.List;
+
+
+public class ShortestRemainingTime extends AllocationStrategy {
+
+ public ShortestRemainingTime(List<Job> jobs) {
+ super(jobs);
+ }
+
+ public void run() {
+
+ }
+
+ public void run(List<Job> jobList) {
+
+ float avgTurnArroundTime = 0;
+ float avgWaitigTime = 0;
+ int n;
+ n = jobList.size();
+ int p[] = new int[n];
+ int at[] = new int[n];
+ int bt[] = new int[n];
+ int bt2[] = new int[n];
+ int wt[] = new int[n];
+ int tat[] = new int[n];
+ int count = 0;
+ double tempWT=0;
+ for (Job job:jobList) {
+ p[count] = count;
+ at[count] = job.getArrivalTime();
+ bt[count] = job.getCpuTime();
+ bt2[count] = bt[count];
+ count++;
+ }
+ int tbt = 0;
+ for (int i = 0; i < n; i++) {
+ tbt = tbt + bt[i];
+ }
+ int time[] = new int[tbt];
+ int k = 0;
+ int q2 = 0;
+
+ System.out.println("============================================ ");
+ System.out.println("Process ID | Turnaround time | Waiting time ");
+ System.out.println("============================================ ");
+ int counter=1;
+ for (int i = 0; i < tbt; i++) {
+
+ int q = Min(bt, at, tbt, i, n);
+
+ if (q != q2) {
+ time[k++] = i;
+
+ wt[q] = i;
+ tat[q] = i + bt[q];
+ counter++;
+ tempWT+=wt[q];
+ }
+ avgWaitigTime+= wt[q];
+ avgTurnArroundTime+=tat[q];
+ bt[q] = bt[q] - 1;
+ q2 = q;
+
+ System.out.println( (p[q]+1) +"\t|\t"+tat[q]+"\t|\t"+wt[q]);
+ System.out.println("----------------------------------------");
+
+ }
+ time[k] = tbt;
+ System.out.println();
+ System.out.print("0\t");
+
+ for (int i = 0; i <= k; i++) {
+ System.out.print(time[i] + "\t");
+ }
+ System.out.println("\n============================================ ");
+ System.out.println("Avg WT||TAT::"+tempWT/counter+"|"+avgTurnArroundTime/counter);
+ System.out.println("============================================ ");
+
+ }
+
+ public int Min(int b[], int a[], int tbt, int r, int n) {
+ int j = 0;
+ int min = tbt;
+ for (int i = n - 1; i != 0; i--) {
+ if (b[i] < min && b[i] > 0 && r != a[i]) {
+ min = b[i];
+ j = i;
+ }
+ }
+ return j;
+ }
+
+}

Assignment - Shortest Job first scheduling/Question1.class

@@ -0,0 +1,4 @@
+1,0,8
+2,1,4
+3,2,9
+4,3,5