Scheduling Simulation

Write a simulation to analyze CPU scheduling algorithms. You will simulate the following schedulers:

First Come First Serve
Preemptive Shortest Job First
Priority (preemptive)
Round Robin with quantum=20.

All time units should be an integral number of milliseconds. These milliseconds don't have to literally take a millisecond while running. Don't make things happen in "real time".

Simulate context switches between processes, each of which will require 5 ms. Context switches should not be preempted.

You may write your program in a language of your choice, but I must be able to run it somewhere.

Command Line Arguments

Your program will need to specify an input file name from the command line and a single flag. The flag is optional on the command line. If it is specified, your program will produce verbose output (see below), otherwise it will produce the default output only.

Suppose you write a program called CPUSim. The command line format would be:

      CPUSim infile -v

      java CPUSim infile -v

where infile is the name of the input file and the optional -v specifies verbose output.

You can specify command line arguments in eclipse by modifying the Run Configurations for your project so you aren't stuck only running from the command line.

Input Format

Your program will read processes from a file. The first line of the file will contain n:the number of processes to simulate which will have a value between 1 and 1000.

There will then be n lines (one for each process) containing 4 integers separated by a single space:

The process ID which will be unique for each line.
The process's priority (use for the priority schedulers only). A lower number indicates a higher priority.
The process's arrival time in the ready queue.
The process's CPU burst time.

The lines will be ordered by the process's arrival time.

For example the input file might be:

Output Format

There are two output formats that your program should produce. The first is the default format, the second format will be used when your program is run with a -v on the command line. Time units in the output should be in milliseconds, but may be floating point numbers. The output described below should be all that appears on standard output (System.out, cout or stdout). Use standard error for debugging messages (System.err, cerr, stderr).

Default Output

The default output just produces the following statistics for each of the schedulers:

The name of the scheduler
The time in the simulation when the last process finished.
The percent CPU utilization (the amount of time the CPU is running the processes).
The throughput in processes per second.
The average wait time.
The average turnaround time.

Verbose Output

The verbose output will print out the default output followed by individual process statistics. For each scheduling algorithm you should output information about each process. Each of these should be on its own line which contains the following information:

The process ID
Arrival time.
Completion time.
Turnaround time.
Total wait.

The line should be just numbers separated by a space with no labels.

The file testOut.txt contains verbose output for the example input above. Your calculations may differ a bit from mine depending on your design and scheduling decisions. They do not need to match exactly.

There is an additional sample input file, procTest.txt and its verbose output procTest_output.txt. You can make other input files using ProcGen.java Java program provided.

Comments

Your code should be readable and understandable. To facilitate this you should include two varieties of comments. The standard mechanical comments will indicate what code is doing, what parameters/return values mean etc.

You will also include thematic comments. These will describe in general terms the activities and events surrounding the "process" structure in your simulation. Document what is done to the processes, how they are manipulated, how they change. If your code tells a story, the process is the protagonist.

Thematic comments should begin with a "--". So in Java and C++ you would use //-- or /*-- to indicate the beginning of a thematic comment.

Hints and Suggestions

The following are suggestions, not requirements for the assignment.

Start early.
Make each iteration of an outer loop represent 1 msec. Each iteration should update each process's statistics and make any state changes necessary.
This is not an exercise in syntax and semantics, it is all about the simulation. If you find yourself getting caught up in details, stop and ask for help.
Don't run with scissors.

OOP Design Suggestions

Create a ProcessInfo class to contain the all of the information associated with a process.
Create a Scheduler class that contains all of the information and data that is common to each scheduler. The Scheduler class could implement a simple algorithm like FCFS, or it could be abstract.
Create subclasses of the Scheduler class for each other scheduling algorithm.
Make the simulation only require the methods in the Scheduler object. Use polymorphism with the subclasses to get different behaviors.