Ask Question

Name:
Title:
Your Question:

Answer Question

Name:
Your Answer:
User Submitted Source Code!


Description:
  csci 310
Language: C/C++
Code:
#include <iostream>
#include <queue>
#include <sstream>
#include <random>

using namespace std;

bool checkFaultOPT(int pageFrameOPT[], int input, int & numFaultsOPT);
void checkFaultsFIFO(queue<int> & pageFrame, int input, int & numFaultsFIFO);
void displayPageFIFO(queue<int> pageFrame);         // created for debugging purposes
void displayPageOPT(int pageFrameOPT[]);            // created for debugging purposes

const int NUMRUNS = 5000;

int main() {
    bool fault, found, positionOPT[8];
    int input, counter, next, numFaultsFIFO = 0, numFaultsOPT = 0, oldPosition = 0, currPos = 0;
     int pageFrameOPT[8] = {10,10,10,10,10,10,10,10};// its 10 to avoid early comparison issues
    queue<int> pageFrameFIFO;                       // empty queue for FIFO
     
     default_random_engine generator;
    uniform_int_distribution<int> distribution(1,9);
     string str = "";
    for(int i = 0; i <NUMRUNS; i++){
        str += to_string(distribution(generator));  // generates number in the range 1..9
        str += ' ';                                 // space to seperate numbers
    }
     istringstream iss(str);                         // allows us to use ">>" operator on strings
     
// ===========================================================================================
//                                          FIFO
// ===========================================================================================
     for(int i = 0; i < NUMRUNS; i++){
         iss >> input;                               // extracts 1 integars from file
         if(pageFrameFIFO.size() < 8){               // If queue / PT is not full yet...
             pageFrameFIFO.push(input);              // then its an automatic fault
             numFaultsFIFO++; 
         }
        else
            checkFaultsFIFO(pageFrameFIFO, input, numFaultsFIFO);  //else you gotta check faults manually
        //displayPageFIFO(pageFrameFIFO);              // displays the copy queue
     }//for
   iss.seekg(oldPosition);                  // returns ">>" position to the begining of the string (for OPT)

// ===========================================================================================
//                                          OPT
// ===========================================================================================
    while(currPos != 8){                                // --- INITALIZING ARRAY ---
         iss >> input;                                   // extracts 1 integars from string
         fault = checkFaultOPT(pageFrameOPT, input, numFaultsOPT);     // checks for faults
         
         if(fault){                                      // if there is a fault
             pageFrameOPT[currPos] = input;              // that means we put input into Page Frame.
             currPos++;                                  // moves to the next position
         }
     }//while

     while(!iss.eof()){                              // --- RUNNING 'OPT' FOR THE REST OF THE ARRAY ---
         oldPosition = iss.tellg();                  // saves old position - incase we have to move back
         iss >> input;                                   // extracts 1 integars from string
        fault = checkFaultOPT(pageFrameOPT, input, numFaultsOPT); // checks for faults
         
// THE PURPOSE OF THIS IS TO FIND THE 1st 7 UPCOMING NUMBERS, THE POSITION OF THE LAST NUMBER BECOMES THE "VITCIM"
         if(fault){                                  // --- RESETING VARIBLES ---
             counter = 0;                            // resets counter is singal the end
             found = false;                          // resets condition for finding position
             for(int i = 0; i < 8; i++)              // resets the table used to find position
                 positionOPT[i] = true;
      
            while(!iss.eof() && counter != 7){      // --- FINDS THE 1st 7 UPCOMING NUMBERS ---  
                iss >> next;                        // gets the next integar for comparison
                for(int i =0; i < 8; i++)           // goes through the whole Page Frame.
                    if(next == pageFrameOPT[i]){    // checks if theres a match
                        counter++;                  // if there is a match, counter gets ++
                        positionOPT[i] = false;     // the position gets marked
                    }//if
            }//while
            
            for(int j = 0; !found && j < 8; j++){   // --- LAST OF THE 8 NUMBERS BECOMES REPLACED ---
                if(positionOPT[j]){                 // looks for the victim (determined by previous while)
                    pageFrameOPT[j] = input;        // changes contents of PF to the input
                    found = true;                   // makes sure its only one PF that gets changed
                }//if
            }//while
            iss.seekg(oldPosition);                  // ">>" returns to old position in string
         }//if
     }//while
// ===========================================================================================
     cout << "(FIFO) Number of faults: " << numFaultsFIFO << endl;
     cout << "(OPT) Number of faults: " << numFaultsOPT << endl;
     cout << "--PROGRAM HAS FINISHED--" << endl;
}//main





// ===========================================================================================
//                                          Functions
// ===========================================================================================
bool checkFaultOPT(int pageFrameOPT[], int input, int & numFaultsOPT){
        bool fault = true;                                  // assume that input is not in Page Frame
        for(int i =0; i < 8 && fault; i++)                  // checks if input is in Page Frame
             if(pageFrameOPT[i] == input)                    // compares each Page Frame to input
                fault = false;                              // its in Page Frame, therefore no fault
        if(fault)
            numFaultsOPT++;
    return fault;
}

void checkFaultsFIFO(queue<int> & pageFrame, int input, int & numFaultsFIFO){
            bool fault = true;              // assuming there is a fault, until proven otherwise
            queue<int> copy = pageFrame;    // copied so main isn't destroyed
            
            while(!copy.empty()){
                if(copy.front() == input)
                    fault = false;      // if it exists in PT, then no fault
                copy.pop();             // next item in PT
            }//while
            if(fault){
                pageFrame.pop();
                pageFrame.push(input);
                numFaultsFIFO++;
            }
    
}

void displayPageFIFO(queue<int> pageFrame){
         while(!pageFrame.empty()){               // displays all elements
             cout << pageFrame.front() << "  ";
             pageFrame.pop();
     }
     cout << endl;
}

void displayPageOPT(int pageFrameOPT[]){
    for(int i = 0; i < 8; i++)                  // displays all elements
        cout << pageFrameOPT[i] << " ";
    cout << endl;
}
Comments: