C++ ::::: In this assignment you will implement a basic single threaded 3 state processor with the...

Question

C++ ::::: In this assignment you will implement a basic single threaded 3 state processor with the following process states: ready, blocked, and processing. The 2 additional states are notArrived and done (these are analogous to the New and Exit states we discussed in class).Notes:	You place a process on the "processor" by marking the processor as unavailable - processorAvailable = false;Then the process that is to be running has its processor time incremented for the time units that it is to be running	When a process is placed on the processor it should continue to process until it is done or blocked by an IOEvent	When a process is complete or blocked, the first ready process in the vector (by index) should be placed on the processor. This is a basic first come, first served scheduler	Processor Flow	Set processes to ready (when they arrive and become unblocked)	Check for thefirstprocess that is ready	"Process" (processorAvailable = false) for 1 time unit (i.e., one while loop iteration)	Repeat 3 until done or blocked (make sure that time isn't standing still for other processes)	Repeat steps 1-4 until all processes are complete	CompilingTypemakeand press enterJust make sure your program can compile on the campus machines	Running	./program [file] [sleepDuration]file - filename for the process information file to use (see Input section below)sleepDuration - how long the program sleeps after each loop iteration		main.cpp #include "process.h" #include  // for sleep #include  // for sleep int main(int argc, char* argv[]) {     // single thread processor     // it's either processing something or it's not     bool processorAvailable = true;     // vector of processes, fill by reading from a file     vector processList;     // Do not touch     long time = 1;     long sleepDuration = 50;     string file;     stringstream ss;     // Do not touch     switch(argc)     {         case 1:             file = "procList.txt";  // default input file             break;         case 2:             file = argv[1];         // file given from command line             break;         case 3:             file = argv[1];         // file given             ss.str(argv[2]);        // sleep duration given             ss >> sleepDuration;             break;         default:             cerr & processVector) {     stringstream ss;     ifstream in(fileName.c_str());     string line, strItem;     Process proc;     IOEvent io;     processVector.clear();     if(!in.good())     {         cerr > proc.arrivalTime;         ss >> proc.reqProcessorTime;         proc.ioEvents.clear();         proc.ioEvents.reserve(20);         while(ss >> io.time)         {             ss >> io.duration;             proc.ioEvents.push_back(io);         }         processVector.push_back(proc);     } } void printProcessStates(vector& processVector) {     char stateChar;     for(auto & Proc : processVector)     {         switch (Proc.state)         {             case ready:                 stateChar = 'r';                 break;             case processing:                 stateChar = 'p';                 break;             case blocked:                 stateChar = 'b';                 break;             case notArrived:                 stateChar = 'n';                 break;             case done:                 stateChar = 'd';                 break;         }         cout & processVector) {     cout & processVector) {     for(auto & Proc : processVector)     {         if(Proc.state != done)         {             return false;         }     }     return true; } process.h /* Relationship between IOEvent::time and Process time: IOEvent::time represents the number of time steps into a process execution that an IO Event will occur. This value will be relative to Process::processorTime. For example, if a Process has an IOEvent with a time value of 10, then that means  that when the process hits it's 10th time step (i.e., Process::processorTime = 10) it should enter a blocked state for IOEvent::duration time steps. */ #pragma once #include #include #include #include #include using namespace std; struct IOEvent {     IOEvent() : time(-1), duration(0) {}     long time;       // The time the event occurs during the process execution     long duration;   // The duration that the process will be Blocked by this IOEvent }; enum State { ready, processing, blocked, notArrived, done }; // Used to track the three process states struct Process {     Process() : arrivalTime(-1), doneTime(-1), reqProcessorTime(0), processorTime(0), state(notArrived) {}     long arrivalTime;       // When the process will start/become runnable     long doneTime;          // Convenience variable, use this to keep track of when a process completes     long reqProcessorTime;  // Total amount of processor time needed     long processorTime;     // Amount of processor given to this process     State state; // State of the process     vector ioEvents;  // The IO events for this process     IOEvent currentEvent;      // Used to track the progress of the event when process is blocked     void printProcess()     {         cout & processVector); // Print the state of all the processes in the vector void printProcessStates(vector& processVector); // Print all information about all processes from a vector (debugging function) void printProcessSet(vector& processVector); // Check if all of the processes are complete bool allProcessesComplete(vector& processVector); procList.txt 1 20 2 40 5

Karthi · Accepted Answer

fivestate/main.cpp
#include "process.h"
#include  // for sleep
#include  // for sleep
int main(int argc, char* argv[])
{
    // single thread processor
    // it's either processing something or it's not
    bool processorAvailable = true;
    // acts as a processorAvailable in the for loop
    bool tempAvailable = true;
    // vector of processes, fill by reading from a file
    vector processList;
    // number of processes in the processList
    unsigned long processes;
    // tracks the event number in the processes 
    vector  eventIndex;
    // tracks the time an event has been active
    vector eventDuration;
    
    // Do not touch
    long time = 1;
    long sleepDuration = 50;
    string file;
    stringstream ss;
    // Do not touch
    switch(argc)
    {
        case 1:
            file = "procList.txt";  // default input file
            break;
        case 2:
            file = argv[1];         // file given from command line
            break;
        case 3:
            file = argv[1];         // file given
            ss.str(argv[2]);        // sleep duration given
            ss >> sleepDuration;
            break;
        default:
            cerr & processVector)
{
    stringstream ss;
    ifstream in(fileName.c_str());
    string line, strItem;
    Process proc;
    IOEvent io;
    processVector.clear();
    if(!in.good())
    {
        cerr > proc.arrivalTime;
        ss >> proc.reqProcessorTime;
        proc.ioEvents.clear();
        proc.ioEvents.reserve(20);
        while(ss >> io.time)
        {
            ss >> io.duration;
            proc.ioEvents.push_back(io);
        }
        processVector.push_back(proc);
    }
}
void printProcessStates(vector& processVector)
{
    char stateChar;
    for(auto & Proc : processVector)
    {
        switch (Proc.state)
        {
            case ready:
                stateChar = 'r';
                break;
            case processing:
                stateChar = 'p';
                break;
            case blocked:
                stateChar = 'b';
                break;
            case notArrived:
                stateChar = 'n';
                break;
            case done:
                stateChar = 'd';
                break;
        }
        cout & processVector)
{
    cout & processVector)
{
    for(auto & Proc : processVector)
    {
        if(Proc.state != done)
        {
            return false;
        }
    }
    return true;
}
fivestate/process.h
/*
Relationship between IOEvent::time and Process time:
IOEvent::time represents the number of time steps into a process execution that
an IO Event will occur. This value will be relative to Process::processorTime.
For example, if a Process has an IOEvent with a time value of 10, then that means 
that when the process hits it's 10th time step (i.e., Process::processorTime = 10)
it should enter a blocked state for IOEvent::duration time steps.
*/
#pragma once
#include
#include
#include
#include
#include
using namespace std;
struct IOEvent
{
    IOEvent() : time(-1), duration(0) {}
    long time;       // The time the event occurs during the process execution
    long duration;   // The duration that the process will be Blocked by this IOEvent
};
enum State { ready, processing, blocked, notArrived, done }; // Used to track the three process states
struct Process
{
    Process() : arrivalTime(-1), doneTime(-1), reqProcessorTime(0), processorTime(0), state(notArrived) {}
    long arrivalTime;       // When the process will start/become runnable
    long doneTime;          // Convenience variable, use this to keep track of when a process completes
    long reqProcessorTime;  // Total amount of processor time needed
    long processorTime;     // Amount of processor given to this process
    State state; // State of the process
    vector ioEvents;  // The IO events for this process
    IOEvent currentEvent;      // Used to track the progress of the event when process is blocked
    void printProcess()
    {
        cout & processVector);
// Print the state of all the processes in the vector
void printProcessStates(vector& processVector);
// Print all information about all processes from a vector (debugging function)
void printProcessSet(vector& processVector);
// Check if all of the processes are complete
bool allProcessesComplete(vector& processVector);
fivestate/procList.txt
1 20
2 40 5 10 15 10
2 80 20 10 40 10 60 10
2 20 10 40
4 60 20 10 40 10
4 50 40 15
6 40
6 30 5 5 10 5 15 5
8 11 2 4 4 4 6 4 8 4 10 4
8 30 10 5 20 10
8 30 10 5 20 10
fivestate/sampleOutput.

C++ ::::: In this assignment you will implement a basic single threaded 3 state processor with the following process states: ready, blocked, and processing. The 2 additional states are notArrived and...

Processor Flow

Compiling

Running

Answer To: C++ ::::: In this assignment you will implement a basic single threaded 3 state processor with the...

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment