Help with Read me file

JGilchrist_Ilab2_execution_file.txt

/* * File: week1ECET360Execution.cpp * Author: JGilchrist * Tutor: Paul Nichols * References used: http://www.advancedlinuxprogramming.com/alp-folder/alp-ch03-processes.pdf * cplusplus.com, stackedoverflow.com * Created on November 10, 2013, 6:20 PM */ #include <cctype> // for toupper() #include <cstdlib> // for EXIT_SUCCESS and EXIT_FAILURE #include <cstring> // for strerror() #include <cerrno> // for errno #include <deque> // for deque (used for ready and blocked queues) #include <fstream> // for ifstream (used for reading simulated process programs) #include <iostream> // for cout, endl, and cin #include <sstream> // for stringstream (for parsing simulated process programs) #include <sys/wait.h> // for wait() #include <unistd.h> // for pipe(), read(), write(), close(), fork(), and _exit() #include <vector> // for vector (used for PCB table) #include <stdexcept> // std::out_of_range using namespace std; class Instruction {//file instruction format public: char operation; int intArg; string stringArg; }; /********************************************************************************************************* * Cpu is used to simulate the execution of a simulated process that is in running state. * It should include data members to store a pointer to the program array, current program counter value, * integer value, and time slice of that simulated process. In addition, it should store the number of * time units used so far in the current time slice. *********************************************************************************************************/ class Cpu { public: vector<Instruction> *pProgram;//this is a pointer to PcbEntry.program int programCounter; int value; int timeSlice;//curent time slice int timeSliceUsed;//time units used so far in current time slice }; enum State {//curent state of pcbEntry STATE_READY, STATE_RUNNING, STATE_BLOCKED }; class PcbEntry {//class of values to save in PCB table public: int processId; int parentProcessId; vector<Instruction> program;//program is a list Instruction class objects(char operation, int, string) unsigned int programCounter; int value; unsigned int priority; State state; unsigned int startTime; // For iLab 3, unused for iLab 2 unsigned int timeUsed; // For iLab 3, unused for iLab 2 }; unsigned int timestamp = 0; // The current simulation time. Cpu cpu; // The current CPU state. // For the states below, -1 indicates empty (since it is an invalid index).***see State description /***************************************************************************************************** * RunningState stores the PcbTable index of the currently running simulated process. *******************************************************************************************************/ int runningState = -1; // The index of the running process in the PCB table. /**************************************************************************************************** * ReadyState stores all simulated processes (PcbTable indices) that are ready to run. * This can be implemented using a queue or priority queue data structure. ****************************************************************************************************/ deque<int> readyState; // A queue of PCB indices for ready processes.(index) /***************************************************************************************************** * BlockedState stores all processes (PcbTable indices) that are currently blocked. * This can be implemented using a queue data structure. *******************************************************************************************************/ deque<int> blockedState; // A queue of PCB indices for blocked processes. // In this implementation, we'll never explicitly clear PCB entries and the // index in the table will always be the process ID. These choices waste memory, // but since this program is just a simulation it the easiest approach. // Additionally, debugging is simpler since table slots and process IDs are // never re-used. /********************************************************************************************************* * PcbTable is an array with one entry for every simulated process that hasn't finished its execution yet. * Each entry should include data members to store process id, parent process id, a pointer to program counter * value (initially 0), integer value, priority, state, start time, and CPU time used so far. ********************************************************************************************************/ vector<PcbEntry *> pcbTable; double cumulativeTimeDiff = 0; int numTerminatedProcesses = 0; // Sadly, C++ has no built-in way to trim strings: string& trim(string &argument) { string whitespace(" \t\n\v\f\r"); size_t found = argument.find_last_not_of(whitespace); if (found != string::npos) { argument.erase(found + 1); argument.erase(0, argument.find_first_not_of(whitespace)); } else { argument.clear(); // all whitespace } return argument; } bool createProgram(const string &filename, vector<Instruction> &program) { cout << "running creatProgram process " << endl; ifstream file; //open a stream to "init" named file int lineNum = 0; file.open(filename.c_str()); if (!file.is_open()) { cout << " file open: Error opening file " << filename << endl; return false; } while (file.good()) {//------------------- process init file -------------------------------------------- string line; getline(file, line); cout << " read from " << filename.c_str() << " : " << line << endl; trim(line); if (line.size() > 0) { Instruction instruction; instruction.operation = toupper(line[0]); instruction.stringArg = trim(line.erase(0, 1)); stringstream argStream(instruction.stringArg); switch (instruction.operation) { case 'S': // Integer argument. case 'A': // Integer argument. case 'D': // Integer argument. case 'F': // Integer argument. if (!(argStream >> instruction.intArg)) { cout << filename << ":" << lineNum << " - Invalid integer argument " << instruction.stringArg << " for " << instruction.operation << " operation" << endl; file.close(); return false; } break; case 'B': // No argument. case 'E': // No argument. break; case 'R': // String argument. // Note that since the string is trimmed on both ends, // filenames with leading or trailing whitespace (unlikely) // will not work. if (instruction.stringArg.size() == 0) { cout << filename << ":" << lineNum << " - Missing string argument" << endl; file.close(); return false; } break; default: cout << filename << ":" << lineNum << " - Invalid operation, " << instruction.operation << endl; file.close(); return false; } program.push_back(instruction); } lineNum++; }//-------------------------------- finished processing the file -------------------------/ file.close(); return true; } /********************************************************************************************* * Instructions S, A and D update the integer value stored in Cpu. ********************************************************************************************/ void set(int value){ cpu.value = value; cout << "running set process...setting cpu value to "<< cpu.value << endl; } void add(int value){ cpu.value = cpu.value + value; cout << "running +add process new cpu value = "<< cpu.value << endl; } void decrement(int value){ cpu.value = cpu.value - value; cout << "running -decrement process new cpu value = " << cpu.value << endl; } // Performs scheduling. void schedule() { cout << "running schedule process "; cout << " PID = " << runningState << " "; // 1. Return if there is still a processing running (runningState != -1). if (runningState == -1 && !readyState.empty()){//nothing running and process is in queue // 2. Get a new process to run, if possible, from the readystate queue. runningState = readyState.front();//retrieve the index of the pcbTable that is ready to run cout << "...loading new process from que pid is " << runningState << endl; readyState.pop_front();//remove it from queue push back-->pop front; // 3. If we were able to get a new process to run: // a. Mark the processing as running (update new process's PCB state) //***warning*** if pcbTable[location] does not exist you are exited!!!! pcbTable[runningState]->state = STATE_RUNNING; //cout << "SET NEW RUNNING STATE" << endl; // b. Update the CPU structure with the PCB entry details (program, // program counter, value, etc.) cpu.pProgram = &pcbTable[runningState]->program;//the whole list //cout << "SET NEW PROGRAM" << endl; cpu.programCounter = pcbTable[runningState]->programCounter; //cout << "SET NEW PROGRAM COUNTER" << endl; cpu.value = pcbTable[runningState]->value; //cout << "SET NEW VALUE" << endl; cpu.timeSlice = pcbTable[runningState]->startTime; //cout << "SET NEW TIMESLICE" << endl; cpu.timeSliceUsed = pcbTable[runningState]->timeUsed; } else if ((runningState == -1)&& (readyState.empty())) cout << "nothing in queue and nothing running blocked state = " << blockedState.size()<< " try and Unblock "<< endl; else cout << "...process is running" << endl; } /****************************************************************************************** * Instruction B moves the currently running simulated process to the blocked state * and moves a process from the ready state to the running state. * This will result in a context switch. *****************************************************************************************/ void block() { cout << "running block process " << endl; // 1. Add the PCB index of the running process (stored in runningState) to // the blocked queue. blockedState.push_back(runningState);//push back pull front // 2. Update the process's PCB entry // a. Change the PCB's state to blocked. // b. Store the CPU program counter in the PCB's program counter. // c. Store the CPU's value in the PCB's value cout << " adding pid = " << pcbTable[runningState]->processId << " to the block queue" <<endl; pcbTable[runningState]->state = STATE_BLOCKED; pcbTable[runningState]->programCounter = cpu.programCounter; pcbTable[runningState]->value = cpu.value; // 3. Update the running state to -1 (basically mark no process as running). // Note that a new process will be chosen to run later (via the Q command // code calling the schedule() function). runningState = -1; } /****************************************************************************************** * Instruction E terminates the currently running simulated process, frees up all memory * (e.g. program array) associated with that process and updates the PcbTable. * A simulated process from the ready state is moved to running state. * This also results in a context switch. *******************************************************************************************/ void end() { cout << "running end process " << endl; // TODO:Get the PCB entry of the running process. cumulativeTimeDiff = timestamp + 1 - pcbTable[runningState]->startTime; ++numTerminatedProcesses; runningState = -1; // memory will get freed when the simulation terminates. } /******************************************************************************************************* * Instruction F results in the creation of a new simulated process. A new entry is created in * the PcbTable for this new simulated process. A new (unique) process id is assigned and the * parent process id is process id of the parent simulated process. Start time is set to the current * Time value and CPU time used so far is set to 0. The program array and integer value of the new * simulated process are a copy of the program array and integer value of the parent simulated process. * The new simulated process has the same priority as the parent simulated process. * * The program counter value of the new simulated process is set to the instruction immediately * after the F instruction, while the program counter value of the of the parent simulated process * is set to n instructions after the next instruction (instruction immediately after F). * * The new simulated process is created in the ready state. *******************************************************************************************************/ void fork(int value) { cout << "running fork process " << endl; PcbEntry *myPCB = new PcbEntry(); myPCB->program = pcbTable[runningState]->program; if ((value > -2) && (value < 1000)){//ensure passed in method not out of bounds try{//catch all out of range myPCB->processId = pcbTable.size();//a PCB index+table.size myPCB->parentProcessId = pcbTable[runningState]->processId; myPCB->programCounter = cpu.programCounter; myPCB->value = cpu.value; myPCB->priority = pcbTable[runningState]->priority; myPCB->state = STATE_READY;//dont forget to add to ready queue myPCB->startTime = timestamp; pcbTable.push_back(myPCB);//queue push back, pull front readyState.push_back(myPCB->processId); cpu.programCounter = cpu.programCounter + value; cout << " forked process, pid = " << myPCB->processId << " and pushed it to the ready queue" << endl; } catch (const out_of_range& oor) { std::cerr << "Out of Range error: " << oor.what() << '\n'; } catch(const runtime_error& re) { cout << "Exception caught: " << re.what() << '\n'; } } else cout << "value is out of bounds" << endl; } /****************************************************************************************************** * The R instruction results in replacing the process image of the currently * running simulated process. Its program array is overwritten by the code in file filename, * program counter value is set to 0, and integer value is undefined. Note that all these changes * are made only in the Cpu data structure. Process id, parent process id, start time, * CPU time used so far, state, and priority remain unchanged. *****************************************************************************************************/ void replace(string &argument) { cout << "running replace process opening file " << endl; cpu.pProgram->clear();//shouldnt I read argument first? cout << "replace argument is " << argument << endl; if (!createProgram(argument, *cpu.pProgram)) {//storing file into pProgram cout << " ERROR can not open file!" << endl; cpu.programCounter = cpu.programCounter + 1; //do more error handling } else { cpu.programCounter = 0; cout << " createprogram..sucess" << endl; } } // Implements the Q command. /***************************************************************************************************** * On receiving a Q command, * the process manager executes the next instruction of the currently running simulated process, * increments program counter value (except for F or R instructions), increments Time, * and then performs scheduling. Note that scheduling may involve performing context switching. *****************************************************************************************************/ void quantum() { cout << "starting quantum process " << endl; Instruction instruction; if (runningState == -1) { cout << "No processes are running" << endl; ++timestamp; return; } if (cpu.programCounter < cpu.pProgram->size()) { instruction = (*cpu.pProgram)[cpu.programCounter]; cpu.programCounter++; } else { cout << "End of program reached without E operation" << endl; instruction.operation = 'E'; } switch (instruction.operation) { case 'S': set(instruction.intArg); break; case 'A': add(instruction.intArg); break; case 'D': decrement(instruction.intArg); break; case 'B': block(); break; case 'E': end(); break; case 'F': fork(instruction.intArg); break; case 'R': replace(instruction.stringArg); break; } ++timestamp; schedule(); } // Implements the U command. void unblock() { cout << "entered unblocked method" << endl; if(!blockedState.empty()){//check for empty queue int pcbIndex = blockedState.front(); cout << " unblocking PID = " << pcbIndex << " adding it to ready que" << endl; blockedState.pop_front(); readyState.push_back(pcbIndex); pcbTable[pcbIndex]->state = STATE_READY; schedule(); } else {cout << " blocked buffer was empty" << endl; } } /************************************************************************************************* * On receiving a P command, the process manager spawns a new reporter process. ************************************************************************************************/ void print() { cout << "Print command is not implemented until iLab 3" << endl; } // Function that implements the process manager. /************************************************************************************************* * The process manager process simulates four process management functions: * 1. creation of new (simulated) processes, * 2. replacing the current process image of a simulated process with a new process image, * 3. management of process state transitions, * 4. process scheduling. *************************************************************************************************/ int runProcessManager(int fileDescriptor) { PcbEntry *pcbEntry = new PcbEntry(); const char *INITPATH = "init"; // Attempt to create the init process. /******************************************************************************************************* * The process manager creates[createProgram()] the first simulated process (process id = 0) program from an input file * (filename: init). This is the only simulated process created by the process manager on its own. * All other simulated processes are created in response to the execution of the F instruction * *****************************************************************************************************/ if (!createProgram(INITPATH , pcbEntry->program)) { delete pcbEntry; return EXIT_FAILURE; } /******************************************************************************************************** * The process manager maintains six data structures: They are in the pcbEntry class * Time, Cpu, PcbTable, {[state::] ReadyState, BlockedState, and RunningState.} ******************************************************************************************************/ pcbEntry->processId = pcbTable.size(); pcbEntry->parentProcessId = -1; pcbEntry->programCounter = 0; pcbEntry->value = 0; pcbEntry->priority = 0; pcbEntry->state = STATE_RUNNING; // Time is an integer variable initialized to zero. pcbEntry->startTime = 0; pcbEntry->timeUsed = 0; /********************************************************************************************************* * PcbTable is an array with one entry for every simulated process that hasn't finished its execution yet. * Each entry should include data members to store process id, parent process id, a pointer to program counter * value (initially 0), integer value, priority, state, start time, and CPU time used so far. ********************************************************************************************************/ pcbTable.push_back(pcbEntry); runningState = pcbEntry->processId; cout << "Running init process, pid = " << pcbEntry->processId << endl; /********************************************************************************************************* * Cpu is used to simulate the execution of a simulated process that is in running state. * It should include data members to store a pointer to the program array, current program counter value, * integer value, and time slice of that simulated process. In addition, it should store the number of * time units used so far in the current time slice. *********************************************************************************************************/ cpu.pProgram = &(pcbEntry->program); cpu.programCounter = pcbEntry->programCounter; cpu.value = pcbEntry->value; timestamp = 0; double avgTurnaroundTime = 0; // Loop until a 'T' is read, then terminate. char ch; do { // Read a command character from the pipe. /**************************************************************************************************** * After creating the first process and initializing all its data structures, * the process manager repeatedly receives and processes one command at a time * from the commander process (read via the pipe). * **************************************************************************************************/ if (read(fileDescriptor, &ch, sizeof(ch)) != sizeof(ch)) { // Assume the parent process exited, breaking the pipe. break; } // Ignore whitespace characters. if (isspace(ch)) { continue; } // Convert commands to a common case so both lower and uppercase // commands can be used. ch = toupper(ch); switch (ch) { case 'Q': quantum(); break; case 'U': unblock(); break; case 'P': print(); break; /****************************************************************************************** * On receiving a T command, the process manager first spawns a reporter process and then * terminates after termination of the reporter process. The process manager ensures that * no more than one reporter process is running at any moment. *****************************************************************************************/ case 'T': if (numTerminatedProcesses != 0) { avgTurnaroundTime = cumulativeTimeDiff / (double)numTerminatedProcesses; } cout << "The average turnaround time is " << avgTurnaroundTime << "." << endl; break; default: cout << "Unknown command, " << ch << endl; } } while (ch != 'T'); // Cleanup any remaining PCB entries. for (vector<PcbEntry *>::iterator it = pcbTable.begin(); it != pcbTable.end(); it++) { delete *it; } pcbTable.clear(); return EXIT_SUCCESS; } //recieves a pipe descriptor int main(int argc, char** argv) { //variables} int result; int pfd[2]; //read arguments if(argc < 3) { cout << "You must provide a pipe adress descriptor " << endl; // Keeep command window open until user presses ENTER key cout << "Press ENTER key to exit" << endl; cin.ignore( ); exit(0); } pfd[0] = atoi(argv[2]); // Run the process manager. result = runProcessManager(pfd[0]); // Close the read end of the pipe for the process manager process (for // cleanup purposes). cout << "closing pipe...GOODBYE" << endl; close(pfd[0]);//close read end of pipe //exit (using the _exit() system call). exit(result); // Keeep command window open until user presses ENTER key cout << "Press ENTER key to exit" << endl; cin.ignore( ); return(0); }