program will read input and directives from a file. The input describes a time sequence of events that occur. These are the full set of events you will simulate:
cpu - The processor runs for 1 time step the currently running process
new - A new process is created
done - The currently running process has finished
wait X - The currently running process has done an I/O operation and
is waiting on event X
event X - Event X has occurred, all processes waiting on that event should
be made ready.
The input file will simply be a list of events that occur in the system, in the order they are to occur. For example:
----- events-example.sim --------
new
cpu
cpu
wait 1
cpu
event 1
cpu
cpu
done
----------------------------------
Your task is to read in the events, and simulate the creation and execution of processes in the system as they move through the various three-states of their process life cycle. You need to
Define a simple process control block (PCB) to hold information about all processes currently running in your system. The PCB can be a simple C struct or a C++ class. At a minimum you need to have a field for the process identifier, the process state (Ready, Running or Blocked). You need to also keep track of the time step that the process entered the system, and the number of steps the process has been running.
You will need a ready and blocked queue of some kind. You can use a simple C array to hold your queues, though you will need to implement some simple queuing functions in that case. You may also use the C++ Standard Template Library (STL) vector and/or queue data structures to implement your queues.
You will need to implement a simple dispatcher function. Whenever a cpu event occurs, and no process is currently running, you should select the next Ready process from your ready queue and start it running on the processor.
You need to also implement a simple time slicing mechanism. You should define a time quantum of 5 time steps for your system (but this should be a parameter, so that you can change the time quantum for different simulations). At the end of a cpu cycle, you should check if the currently running process has executed for its full time quantum. In that case, the currently running proces should timeout, and be returned to the end of the Ready queue.
new events should cause a new process to be created (including creating its PCB and filling it in). New events will be placed on the ready queue after being created. You should assign each new event a process identifier. The process identifier should be a simple integer value, and you should start numbering processes from 1.
For a done event, if a process is currently running it should then be released. It should be removed from the cpu, and not placed back on the ready or blocked queue.
A wait event simulates the currently running process performing some I/O operation. If a wait occurs, the currently running process should become blocked and put on the blocked queue. You also need an entry in the PCB so you know what event the process is waiting for. The wait event is followed by an integer number, which is an indication of the type of event the process has requested.
Likewise the event directive simulates the finishing of some I/O operation. When an event occurs, you should scan your blocked queue and make any jobs ready that were waiting on that event. The integer value following an event indicates the type of event that just occurred.