Question

Please help me create this CLI CPU Scheduling Simulator in java:

1. First Come First Serve (FCFS)
2. Round Robin (RR)

Process information

The process information will be read from an input file. The format is:

pid arrival_time burst_time

All of fields are integer type where:

• pid is a unique numeric process ID
• arrival_time is the time when the task arrives in the unit of milliseconds
• burst_time the is the CPU time requested by a task, in the unit of milliseconds
• The time unit for arrival_time, burst_time and interval is millisecond.

The program will be run from the command line where you provide the name of the file where the processes are stores.

The simulator first reads task information from input file and stores all data in a data structure. Then it starts simulating one scheduling algorithm in a time-driven manner. At each time unit (or slot), it adds any newly arrived task(s) into the ready queue and calls a specific scheduler algorithm in order to select appropriate task from ready queue. When a task is chosen to run, the simulator prints out a message indicating what process ID is chosen to execute for this time slot. If no task is running (i.e. empty ready queue), it prints out an "idle" message. Before advancing to the next time unit, the simulator should update all necessary changes in task and ready queue status

Inputs and Outputs

Sample input files and expected outputs are shown in the Appendix. You can use it to verify your results. Notice that these input files are not for testing and grading your program in.

• Your program will output the waiting times of all the processes and compute the average waiting time
• Your program will output the response times of all the processes and compute the average response time
• Your program will output the turn-around times of all the processes and compute the average-turn around time

Command-line Usage Examples:

myCPUScheduler input_file [FCFS|RR|MLFQ]

Input file example:

% more input.txt

PID         Arrival   Burst

1              0              10

2              1              9

3              2              8

4              3              7

Output:

When a task is scheduled, the simulator will simply print out what task is selected to run at a time. Show the status of related process at each scheduling event, e.g.,: starts running, has finished, is preempted into Queue #, or continues running.

Print statistical information. As soon as all tasks are completed, the program should compute and print 1) average waiting time, 2) average response time, 3) average turnaround time.

%myCPUScheduler input_file FCFS

Selected Scheduling algorithm: FCFS

PID starts runningat TIME

PID has finished at TIME

PID starts runningat TIME

PID has finished at TIME

…

=============================

Average waiting time:    10.00 ms

Average response time: 3.00 ms

Average turnaround time: 13.00 ms

Answer 1

// Java program for implementation of FCFS
// scheduling

import java.io.File;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.util.Scanner;

public class FCFS {

   // Function to find the waiting time for all
   // processes
      
   static void findWaitingTime(int processes[], int n,
           int bt[], int wt[]) {
       // waiting time for first process is 0
       wt[0] = 0;

       // calculating waiting time
       for (int i = 1; i < n; i++) {
           wt[i] = bt[i - 1] + wt[i - 1];
       }
   }

   // Function to calculate turn around time
   static void findTurnAroundTime(int processes[], int n,
           int bt[], int wt[], int tat[]) {
       // calculating turnaround time by adding
       // bt[i] + wt[i]
       for (int i = 0; i < n; i++) {
           tat[i] = bt[i] + wt[i];
       }
   }

   //Function to calculate average time
   static void findavgTime(int processes[], int n, int bt[]) {
       int wt[] = new int[n], tat[] = new int[n];
       int total_wt = 0, total_tat = 0;

       //Function to find waiting time of all processes
       findWaitingTime(processes, n, bt, wt);

       //Function to find turn around time for all processes
       findTurnAroundTime(processes, n, bt, wt, tat);

       //Display processes along with all details
       System.out.printf("Processes Burst time Waiting"
                   +" time Turn around time\n");

       // Calculate total waiting time and total turn
       // around time
       for (int i = 0; i < n; i++) {
           total_wt = total_wt + wt[i];
           total_tat = total_tat + tat[i];
//            System.out.printf(" %d ", (i + 1));
//            System.out.printf("   %d ", bt[i]);
//            System.out.printf("   %d", wt[i]);
//            System.out.printf("   %d\n", tat[i]);
       }
       float s = (float)total_wt /(float) n;
       int t = total_tat / n;
       System.out.printf("Average waiting time = %f", s);
       System.out.printf("\n");
       System.out.printf("Average turn around time = %d ", t);
   }

   // Driver code
   public static void main(String[] args) throws ParseException, FileNotFoundException {
       String fileName;
       Scanner scanner=new Scanner(System.in);
       fileName=scanner.nextLine();
       File file = new File(fileName);
       int processesid[]=new int[100];
       int arrival[]=new int[100];
       int burst[]=new int[100];
       Scanner sc = new Scanner(file);
       int i=0,j=0;
       while(sc.hasNext())
       {
       String s=sc.nextLine();
           System.out.println(s);
           String str[]=s.split(" ");
           processesid[i]=Integer.parseInt(str[j++]);
           arrival[i]=Integer.parseInt(str[j++]);
           burst[i]=Integer.parseInt(str[j]);
           j=0;
           i++;
       }

       findavgTime(processesid, i--, burst);

   }
}