示例#1
0
文件: main.cpp 项目: Bjornkjohnson/OS
int readTimeSlice(PCB & current, int maxSlice){
    int timeSlice;
    cout << "How long was this process in the CPU: ";
    cin >> timeSlice;
    cout << endl;
    while(!cin || timeSlice < 0 || timeSlice > maxSlice)
    {
        cout << "Time must be between 0 and " << maxSlice << "ms" << endl << endl;
        cout << "How long was this process in the CPU: ";
        cin.clear();
        cin.ignore(100,'\n');
        cin >> timeSlice;
        cout << endl;
    }
    
    current.updateProcessTime(timeSlice);
    //current.increaseCpuCount();
    
    cout <<"Total CPU Process time has been updated" << endl << endl;
    cout <<"Current CPU Time is " << current.getTotalProcessTime()
         << "ms for process " << current.getPID() << endl;
    cout << endl;

    return timeSlice;

}
void MainProcess::Destroy(str PID)
{
	//Check for process existence
	std::vector<str>::iterator findIt = std::find(nameList.begin(), nameList.end(), PID);

	if (findIt == nameList.end()){
		std::cout << "error ";
		ss << "error ";

		return;
	}

	//Remove from name list
	nameList.erase(findIt);

	PCB* temp;

	//Search the ready list for the PCB with the specified PID
	for (int i = 1; i < 3; i++){
		//for (PCB* p : readyList[i])
		for (std::list<PCB*>::iterator it = readyList[i].begin(); it != readyList[i].end(); it++)		
		{
			if ((*it)->getPID() == PID){
				temp = *it;
				readyList[i].erase(it);
				KillTree(temp);
				
				Scheduler();
				return;
			}
		}
	}


	temp = TreeSearch(PID, &initProcess);

	
	if (temp->getPID() != PID){
		std::cout << "error ";
		ss << "error ";
		return;

	}
	
	KillTree(temp);
	//Scheduler();
	return;
}
PCB* MainProcess::TreeSearch(str pID, PCB* p){

	if (p->getPID() != pID){

		PCB* temp;
		if (!p->children.empty()){
			for (PCB* q : p->children){
				temp = TreeSearch(pID, q);

				if (temp->getPID() == pID)
					return temp;
			}
		}
	}


	
	return p;
		

}
示例#4
0
文件: main.cpp 项目: Bjornkjohnson/OS
int main(int argc, const char * argv[]) {
    int printerNum;
    int cdrwNum;
    int diskNum;
    int timeSlice;
    int terminatedProcessCount = 0;
    int terminatedProcessTotalTime = 0;
    float totalAveTerminatedCpuTime = 0;
    //int cylinderNum;
    int systemPID = 0;
    int totalMemSize = 0;
    int processSize = 0;
    int roundedProcessSize = 0;
    int maxProcessSize;
    int pageSize = 0;
    int freeMem = 0;
    int usedMem = 0;
    pair<bool, int> activeRecord;
    string userInput;
    vector<int> cylinderNum;
    vector<deque<PCB> > printers;
    vector<FscanDiskQueue> disks;
    vector<deque<PCB> > cdrws;
    vector<pair<bool, int>> frameList;
    deque<PCB> printerQueue;
    FscanDiskQueue diskQueue;
    deque<PCB> cdrwQueue;
    deque<PCB> readyQueue;
    deque<PCB> jobPool;
    
    
    printWelcome();
    
    cout << "*************SYS GEN***************" << endl;
    
    //SYS GEN*****************************************
    //************TotalMemSize****************
    cout << "What is the total Memory Size: ";
    cin >> totalMemSize;
    cout << endl;
    while((!cin || totalMemSize < 1|| (totalMemSize == 0)) || !memContraintCheck(totalMemSize) )
    {
        cout << "Invalid Input!" << endl;
        cout << "Total Memory Size should be divisible by a power of 2" << endl << endl;
        cout << "What is the total Memory Size: ";
        cin.clear();
        cin.ignore(100,'\n');
        cin >> totalMemSize;
        cout << endl;
    }
    cout << " The Total Memory Size is " << totalMemSize << " Words" << endl;
    cout << endl;

    //************MaxProcessSize****************
    cout << "What is the Max Process Size: ";
    cin >> maxProcessSize;
    cout << endl;
    while(!cin || maxProcessSize < 1 || maxProcessSize > totalMemSize)
    {
        cout << "Invalid Input!" << endl;
        cout << "Max Process size must be less than Total Memory Size." << endl;
        cout << "What is the Max Process Size: ";
        cin.clear();
        cin.ignore(100,'\n');
        cin >> maxProcessSize;
        cout << endl;
    }
    cout << " The Max Process Size is " << maxProcessSize << " Words" << endl;
    cout << endl;

    //************PageSize****************
    cout << "What is the Page Size(Powers of 2 only): ";
    cin >> pageSize;
    cout << endl;
    while(!cin || pageSize < 1 || totalMemSize % pageSize != 0
                || (pageSize == 0) || (pageSize & (pageSize - 1)) )
    {
        cout << "Invalid Input!" << endl;
        cout << "Page Size must be a power of 2 and divide Memory evenly" << endl << endl;
        cout << "What is the Page Size: ";
        cin.clear();
        cin.ignore(100,'\n');
        cin >> pageSize;
        cout << endl;
    }
    cout << " The Page Size is " << pageSize << " Words" << endl;
    cout << endl;
    //cout << "Total Memory size must be deivisible by" << endl;
    //************Timeslice****************
    cout << "How long is a time slice (in milliseconds): ";
    cin >> timeSlice;
    cout << endl;
    while(!cin || timeSlice < 1)
    {
        cout << "Invalid Input!" << endl;
        cout << "How long is a time slice (in milliseconds) ";
        cin.clear();
        cin.ignore(100,'\n');
        cin >> timeSlice;
        cout << endl;
    }
    cout << " A Timeslice is " << timeSlice << " milliseconds" << endl;
    cout << endl;
    
    //**************Printers**************
    cout << "How Many Printers would you like: ";
    cin >> printerNum;
    cout << endl;
    while(!cin || printerNum < 1)
    {
        cout << "Invalid Input!" << endl;
        cout << "How Many Printers: ";
        cin.clear();
        cin.ignore(100,'\n');
        cin >> printerNum;
        cout << endl;
    }
    cout << printerNum << " Printers added" << endl;
    cout << endl;
    
    //*************Disks***************
    cout << "How Many Disks would you like: ";
    cin >> diskNum;
    cout << endl;
    while(!cin || diskNum < 1)
    {
        cout << "Invalid Input!" << endl;
        cout << "How Many Disks: ";
        cin.clear();
        cin.ignore(100,'\n');
        cin >> diskNum;
        cout << endl;
    }
    cout << diskNum << " Disks added" << endl;
    cout << endl;
    
    //**************Cylinders**************
    
    for (int i = 0; i < diskNum; i++) {
        cout << "How Many Cylinders does disk " << i + 1 << " have: ";
        int cylNum;
        cin >> cylNum;
        cout << endl;
        while(!cin || cylNum < 1)
        {
            cout << "Invalid Input!" << endl;
            cout << "How Many Cylinders: ";
            cin.clear();
            cin.ignore(100,'\n');
            cin >> cylNum;
            cout << endl;
        }
        cylinderNum.push_back(cylNum);
    }
    for (int i = 0 ; i < diskNum; i++) {
        cout << "Disk " << i+1 << " has " << cylinderNum[i] << " cylinders" << endl;
    }
    //cout << "Each Disk has " << cylinderNum << " Cylinders" << endl;
    cout << endl;
    
    //*************CDRW***************
    cout << "How Many CD/RWs would you like: ";
    cin >> cdrwNum;
    cout << endl;
    while(!cin || cdrwNum < 1)
    {
        cout << "Invalid Input!" << endl;
        cout << "How Many CD/RWs: ";
        cin.clear();
        cin.ignore(100,'\n');
        cin >> cdrwNum;
        cout << endl;
    }
    cout << cdrwNum << " CD/RWs added" << endl;
    cout << endl;
    
    //*************MakeQueuesAndFrameList***************
    for (int i = 0; i < printerNum+1; i++) {
        printers.push_back(printerQueue);
    }
    
    for (int i = 0; i < diskNum+1; i++) {
        disks.push_back(diskQueue);
    }
    
    for (int i = 0; i < cdrwNum+1; i++) {
        cdrws.push_back(cdrwQueue);
    }
    
    int totalFrames = totalMemSize / pageSize;
    
    activeRecord.first = false;
    
    for (int i = 0; i< totalFrames; i++) {
        frameList.push_back(activeRecord);
    }
    
    
    
    cout << "*************STARTING OS***************" << endl;
    
    //RUNNING*****************************************
    
    try {
        while (true) {
            
            
            try {
                userInput = "";
                cout << "Commands examples: {A, S, t, T, p1, d2, c3, P3, D2, C1}" << endl;
                cout << '>' ;
                cin >> userInput;
                cout << endl;
                
                if (userInput == "q" || userInput == "Q") {
                    throw -1;
                }
                
                
                //ADD PROCESSES*****************************************
                if (userInput == "A") {
                    
                    
                    cout << "What is the size of the Process: ";
                    cin >> processSize;
                    cout << endl;
                    while(!cin || processSize < 1 )
                    {
                        cout << "Invalid Input!" << endl;
                        cout << "Max Process Size is " << maxProcessSize << endl;
                        cout << "What is the size of the Process: " << endl;
                        cin.clear();
                        cin.ignore(100,'\n');
                        cin >> processSize;
                        cout << endl;
                    }
                    if (processSize > maxProcessSize ) {
                        cout << "Process is too large and has been rejected." << endl << endl;
                    }
                    else{
                        cout << " The Process Size is " << processSize << endl;
                        cout << endl;
                        PCB newProcess(systemPID);
                        newProcess.setProcessSize(processSize);
                        if ((usedMem + processSize) <= totalMemSize) {
                            readyQueue.push_back(newProcess);
                            cout << "Process added to ready queue" << endl << endl;
                            if (processSize % pageSize == 0) {
                                usedMem += processSize;
                                freeMem = totalMemSize - usedMem;
                            }
                            else{
                                roundedProcessSize = ((processSize / pageSize) + 1) * pageSize;
                                usedMem += roundedProcessSize;
                                freeMem = totalMemSize - usedMem;
                            }
                            
                            //usedMem += processSize;
                            //freeMem = totalMemSize - usedMem;
                            cout << "Free Memory: " << freeMem << endl;
                            cout << "Used Memory: " << usedMem << endl << endl;
                            
                            int framesNeeded;
                            
                            if (processSize % pageSize == 0) {
                                framesNeeded = processSize/pageSize;
                            }
                            else{
                                framesNeeded = (processSize/pageSize) + 1;
                            }
                            
                            int i = 0;
                            int j = 0;
                            while (j < framesNeeded) {
                                
                                if (frameList[i].first == false) {
                                    frameList[i].first = true;
                                    frameList[i].second = readyQueue.back().getPID();
                                    readyQueue.back().updateFrames(i);
                                    j++;
                                }
                                i++;
                            }
                            
                        }
                        else{
                            jobPool.push_back(newProcess);
                            sort(jobPool.begin(), jobPool.end(), sortHelp);
                            cout << "Process added to Job Pool" << endl << endl;
                            cout << "Free Memory: " << freeMem << endl;
                            cout << "Used Memory: " << usedMem << endl << endl;
                        }
                        
                        
                        systemPID++;
                        
                    }
                    
                }
                
                //SNAPSHOTS*****************************************
                else if(userInput == "S"){
                    
                    do{
                        cout << "Please choose the snapshot you'd like:" << endl;
                        cout << "'r', 'p', 'd', 'c', or 'm' : ";
                        
                        cin >> userInput;
                        
                        cout << endl;
                    }
                    while (userInput != "r" && userInput != "p" && userInput != "d" && userInput != "c" && userInput != "m");
                    
                    //READY QUEUE PRINT*****************************************
                    if (userInput == "r") {
                        cout << endl << "READY QUEUE" << endl;
                        printListHeader(totalAveTerminatedCpuTime, freeMem, usedMem);
                        for (int i = 0; i < readyQueue.size(); i++) {
                            float aveBurst = 0;
                            if (readyQueue[i].getCpuCount() > 0) {
                                aveBurst = ((float)readyQueue[i].getTotalProcessTime())/readyQueue[i].getCpuCount();
                            }
                            
                            cout << left << "  " <<  setw(5) << readyQueue[i].getPID()
                            << left << "| " <<  setw(9) << "N/A"
                            << left << "| " <<  setw(8) << "N/A"
                            << left << "| " <<  setw(9) << "N/A"
                            << left << "| " <<  setw(5)  << "N/A"
                            << left << "| " <<  setw(8) << "N/A"
                            << left << "| " <<  setw(6)  << "N/A"
                            << left << "| " <<  setw(6) << readyQueue[i].getTotalProcessTime()
                            << left << "| " <<  setw(10) << readyQueue[i].getAveBurstTime()
                            << left << "| ";
                            readyQueue[i].printFrames();
                            

                            //cout << readyQueue[i].getPID() << endl;
                        }
                        cout <<" ---------------------------------------------------------------------------------------------"<<endl;

                        cout  << endl;
                        cout << "Job Pool PID numbers: ";
                        
                        if (!jobPool.empty()) {
                            for (int i = 0 ; i < jobPool.size(); i++) {
                                
                                cout << "PID " << jobPool[i].getPID() << " ";
                                
                            }
                        }
                        else{
                            cout << "Empty";
                        }
                        
                        cout << endl << endl;
                    }
                    //MEMORY PRINT*****************************************
                    else if (userInput == "m") {
                        cout << endl << "MEMORY INFORMATION" << endl << endl;
                        cout << "-------------------" << endl;
                        cout << left << "| " <<  setw(6) << "Frame "
                        << left << "| " <<  setw(6) << "Process |" << endl;
                        cout << "-------------------" << endl;
                        
                        for (int i = 0 ; i < frameList.size(); i++) {
                            if (frameList[i].first == true) {
                                
                                cout << left << "| " <<  setw(6) << i
                                << left << "| " <<  setw(7) << frameList[i].second << " |" << endl;
                                
                                //cout << "Frame | " << i << " Process |" << frameList[i].second << " |" << endl;
                            }
                            
                        }
                        cout << "-------------------" << endl << endl;
                        
                        cout << "Free Frames: ";
                        for (int i = 0 ; i < frameList.size(); i++) {
                            if (frameList[i].first == false) {
                                cout << i << " ";
                            }
                        }
                        cout << endl << endl;
                        
                    }

                    
                    //PRINTER QUEUE PRINT*****************************************
                    else if (userInput == "p") {
                        cout << endl << "PRINTER QUEUE" << endl;
                        printListHeader(totalAveTerminatedCpuTime, freeMem, usedMem);
                        
                        for (int i = 1; i < printers.size(); i++) {
                            cout << " --"<< "p" << i << endl;
                            //<<"--------------------------------------------------------------------"<< endl;
                            for (int j = 0; j < printers[i].size(); j++) {
                                
                                cout << printers[i][j];
                            }
                        }
                        cout <<" ---------------------------------------------------------------------------------------------"<<endl;

                        cout  << endl;
                    }
                    
                    
                    //DISK QUEUE PRINT*****************************************
                    else if (userInput == "d") {
                        cout << endl << "DISK QUEUE" << endl;
                        printListHeader(totalAveTerminatedCpuTime, freeMem, usedMem);
                        
                        for (int i = 1; i < disks.size(); i++) {
                            cout << " --"<< "d" << i << endl;
                            //<<"--------------------------------------------------------------------" << endl;
                            disks[i].printDiskQueue();
                        }
                        cout <<" ---------------------------------------------------------------------------------------------"<<endl;

                        cout  << endl;
                    }
                    
                    //CDRW QUEUE PRINT*****************************************
                    else if (userInput == "c") {
                        cout << endl << "CDRW QUEUE" << endl;
                        printListHeader(totalAveTerminatedCpuTime, freeMem, usedMem);
                        
                        for (int i = 1; i < cdrws.size(); i++) {
                            cout << " --"<< "c" << i << endl;
                            //<<"--------------------------------------------------------------------" << endl;
                            for (int j = 0; j < cdrws[i].size(); j++) {
                                cout << cdrws[i][j];
                            }
                        }
                        cout <<" ---------------------------------------------------------------------------------------------"<<endl;

                        cout  << endl;
                    }
                    
                    
                    else{
                        throw userInput;
                    }
                    
                }
                
                //TERMINATE PROCESS*****************************************
                else if(userInput == "t"){
                    if (readyQueue.empty()) {
                        cout << "The Ready Queue is empty" << endl << endl;
                    }
                    else{
                        readTimeSlice(readyQueue.front(), timeSlice);
                        cout << "Terminating Process " << readyQueue.front().getPID() << endl;
                        cout << "Total CPU time was " << readyQueue.front().getTotalProcessTime() << endl;
                        
                        terminatedProcessCount++;
                        terminatedProcessTotalTime += readyQueue.front().getTotalProcessTime();
                        
                        if (readyQueue.front().getProcessSize() % pageSize == 0) {
                            usedMem = usedMem - readyQueue.front().getProcessSize();
                            freeMem = totalMemSize - usedMem;
                        }
                        else{
                            roundedProcessSize = ((readyQueue.front().getProcessSize() / pageSize) + 1) * pageSize;
                            usedMem = usedMem - roundedProcessSize;
                            freeMem = totalMemSize - usedMem;
                        }
                        
                        cout << "Free Memory: " << freeMem << endl;
                        cout << "Used Memory: " << usedMem << endl;
                        
                        vector<int> frames = readyQueue.front().getFrames();
                        
                        for (int i = 0 ; i < frames.size() ; i++) {
                            frameList[frames[i]].first = false;
                        }
                        
                        readyQueue.pop_front();
                        cout  << endl;
                        totalAveTerminatedCpuTime = (float)terminatedProcessTotalTime/terminatedProcessCount;
                        
                        
                        
                        int i = 0;
                        while (!jobPool.empty() && jobPool.front().getProcessSize() < freeMem ) {
                            while (jobPool.back().getProcessSize() > freeMem && i < jobPool.size()) {
                                jobPool.push_front(jobPool.back());
                                jobPool.pop_back();
                                i++;
                                
                            }
                            if (jobPool.back().getProcessSize() < freeMem) {
                                readyQueue.push_back(jobPool.back());
                                jobPool.pop_back();
                                cout << "Process " << readyQueue.back().getPID() << " added to Ready Queue" << endl;
                                int framesNeeded;
                                
                                if (processSize % pageSize == 0) {
                                    framesNeeded = processSize/pageSize;
                                }
                                else{
                                    framesNeeded = (processSize/pageSize) + 1;
                                }
                                
                                int i = 0;
                                int j = 0;
                                while (j < framesNeeded) {
                                    
                                    if (frameList[i].first == false) {
                                        frameList[i].first = true;
                                        frameList[i].second = readyQueue.back().getPID();
                                        readyQueue.back().updateFrames(i);
                                        j++;
                                    }
                                    i++;
                                }

                                if (readyQueue.back().getProcessSize() % pageSize == 0) {
                                    usedMem = usedMem + readyQueue.back().getProcessSize();
                                    freeMem = totalMemSize - usedMem;
                                }
                                else{
                                    roundedProcessSize = ((readyQueue.back().getProcessSize() / pageSize) + 1) * pageSize;
                                    usedMem += roundedProcessSize;
                                    freeMem = totalMemSize - usedMem;
                                }
                                
                                cout << "Free Memory: " << freeMem << endl;
                                cout << "Used Memory: " << usedMem << endl;
                                i = 0;
                            }
                            sort(jobPool.begin(), jobPool.end(), sortHelp);
                        }
                        
                        
                        
                        
                    }
                }
                //MOVETOBACKOFQUEUE******************************
                else if(userInput == "T"){
                    if (readyQueue.empty()) {
                        cout << "The Ready Queue is empty" << endl << endl;
                    }
                    else{
                        cout << "Moving Process " << readyQueue.front().getPID()
                             << " to back of the Ready Queue " << endl << endl;
                        
                        readyQueue.push_back(readyQueue.front());
                        readyQueue.pop_front();
                        readyQueue.back().updateProcessTime(timeSlice);
                        
                        cout <<"Total CPU Process time has been updated" << endl << endl;
                        cout <<"Current CPU Time is " << readyQueue.back().getTotalProcessTime()
                        << "ms for Process " << readyQueue.back().getPID() << endl;
                        cout << endl;
                    }
                }
                
                
                

                //KILL PROCESS ANYWHERE*****************************************
                else if(userInput[0] == 'K'){
                    userInput.erase(0,1);
                    if (checkValidNum(userInput, systemPID - 1) || stoi(userInput) == 0) {
                        PCB temp(-1);
                        int i = 0;
                        bool found = false;
                        int searchPID = stoi(userInput);
                        //READY QUEUE KILL***************************************
                        while (i < readyQueue.size() && found == false) {
                            cout << "Searching Ready Queue" << endl;
                            
                            
                            if (searchPID == readyQueue[i].getPID()) {
                                temp = readyQueue[i];
                                readyQueue.erase(readyQueue.begin()+i);
                                
                                found = true;
                                cout << "Found the Process in the Ready Queue" << endl << endl;
                                if (i == 0) {
                                    readTimeSlice(temp, timeSlice);
                                }
                                
                            }
                            i++;
                        }
                        //PRINT KILL*********************************************
                        if (found == false) {
                            for (int i = 1; i < printers.size(); i++) {
                                for (int j = 0; j < printers[i].size(); j++) {
                                    cout << "Searching Print Queues" << endl;
                                    if (searchPID == printers[i][j].getPID()) {
                                        temp = printers[i][j];
                                        printers[i].erase(printers[i].begin() + j);
                                        found = true;
                                        cout << "Found the Process in the Print Queue" << endl << endl;
                                        
                                    }
                                    
                                }
                            }
                        }
                        
                        
                        //DISK KILL*********************************************
                        
                        if (found == false) {
                            for (int i = 1; i < disks.size(); i++) {
                                
                                if (disks[i].findProcess(searchPID)) {
                                    temp = disks[i].killProcess(searchPID);
                                }
                                
                            }
                        }
                        
                        //CDRW KILL*********************************************
                        if (found == false) {
                            for (int i = 1; i < cdrws.size(); i++) {
                                for (int j = 0; j < cdrws[i].size(); j++) {
                                    cout << "Searching CDRW Queue" << endl;
                                    if (searchPID == cdrws[i][j].getPID()) {
                                        temp = cdrws[i][j];
                                        cdrws[i].erase(cdrws[i].begin() + j);
                                        found = true;
                                        cout << "Found the Process in the CDRW Queue" << endl << endl;
                                    }
                                    
                                }
                            }
                        }
                        //CLEAN UP FOR NON JOB POOL
                        if (found == true) {
                            //readTimeSlice(temp, timeSlice);
                            cout << "Killing Process " << temp.getPID() << endl;
                            cout << "Total CPU time was " << temp.getTotalProcessTime() << endl;
                            
                            terminatedProcessCount++;
                            terminatedProcessTotalTime += temp.getTotalProcessTime();
                            
                            if (temp.getProcessSize() % pageSize == 0) {
                                usedMem = usedMem - temp.getProcessSize();
                                freeMem = totalMemSize - usedMem;
                            }
                            else{
                                roundedProcessSize = ((temp.getProcessSize() / pageSize) + 1) * pageSize;
                                usedMem = usedMem - roundedProcessSize;
                                freeMem = totalMemSize - usedMem;
                            }
                            
                            cout << "Free Memory: " << freeMem << endl;
                            cout << "Used Memory: " << usedMem << endl;
                            
                            vector<int> frames = temp.getFrames();
                            
                            for (int i = 0 ; i < frames.size() ; i++) {
                                frameList[frames[i]].first = false;
                            }
                            
                            
                            cout  << endl;
                            totalAveTerminatedCpuTime = (float)terminatedProcessTotalTime/terminatedProcessCount;
                            
                            
                            
                            i = 0;
                            while (!jobPool.empty() && jobPool.front().getProcessSize() <= freeMem ) {
                                while (jobPool.back().getProcessSize() > freeMem && i < jobPool.size()) {
                                    jobPool.push_front(jobPool.back());
                                    jobPool.pop_back();
                                    i++;
                                    
                                }
                                if (jobPool.back().getProcessSize() <= freeMem) {
                                    readyQueue.push_back(jobPool.back());
                                    jobPool.pop_back();
                                    cout << "Process " << readyQueue.back().getPID() << " added to Ready Queue" << endl;
                                    int framesNeeded;
                                    
                                    if (processSize % pageSize == 0) {
                                        framesNeeded = processSize/pageSize;
                                    }
                                    else{
                                        framesNeeded = (processSize/pageSize) + 1;
                                    }
                                    
                                    int i = 0;
                                    int j = 0;
                                    while (j < framesNeeded) {
                                        
                                        if (frameList[i].first == false) {
                                            frameList[i].first = true;
                                            frameList[i].second = readyQueue.back().getPID();
                                            readyQueue.back().updateFrames(i);
                                            j++;
                                        }
                                        i++;
                                    }
                                    
                                    if (readyQueue.back().getProcessSize() % pageSize == 0) {
                                        usedMem = usedMem + readyQueue.back().getProcessSize();
                                        freeMem = totalMemSize - usedMem;
                                    }
                                    else{
                                        roundedProcessSize = ((readyQueue.back().getProcessSize() / pageSize) + 1) * pageSize;
                                        usedMem += roundedProcessSize;
                                        freeMem = totalMemSize - usedMem;
                                    }
                                    
                                    cout << "Free Memory: " << freeMem << endl;
                                    cout << "Used Memory: " << usedMem << endl;
                                    i = 0;
                                }
                                sort(jobPool.begin(), jobPool.end(), sortHelp);
                            }
                        }

                        
                        
                        //JOB POOL KILL*********************************************
                        if (found == false) {
                            for (int i = 0; i < jobPool.size(); i++) {
                                if (searchPID == jobPool[i].getPID()) {
                                    cout << "Searching Job Pool" << endl;
                                    PCB temp = jobPool[i];
                                    jobPool.erase(jobPool.begin() + i);
                                    found = true;
                                    cout << "Found the Process in the Job Pool" << endl << endl;
                                    cout << "Killing Process " << temp.getPID() << endl << endl;
                                    terminatedProcessCount++;
                                }
                            }
                        }

                        if (found == false) {
                            cout << "PID not found" << endl << endl;
                        }
                        
                    }
                    else{
                        cout << "PID does not exist" << endl << endl;
                    }
                    
                    
                    
                }
                
                //ADD TO PRINTER QUEUE*****************************************
                else if(userInput[0] == 'p'){
                    userInput.erase(0,1);
                    if (checkValidNum(userInput, printerNum)) {
                        if (!readyQueue.empty()) {
                            readyQueue.front().fillPCB('p', false, 0,pageSize);
                            printers[stoi(userInput)].push_back(readyQueue.front());
                            readyQueue.pop_front();
                            readTimeSlice(printers[stoi(userInput)].back(), timeSlice);
                            printers[stoi(userInput)].back().increaseCpuCount();
                        }
                        else{
                            cout << "There are no available processes in the Ready Queue" << endl;
                            cout << "Please populate the Ready Queue and try again" << endl << endl;
                        }
                        
                    }
                    else{
                        cout << "Printer does not exist" << endl << endl;
                    }
                    
                
                    
                }
                //ADD TO DISK QUEUE*****************************************
                else if(userInput[0] == 'd'){
                    userInput.erase(0,1);
                    if (checkValidNum(userInput,diskNum)) {
                        if (!readyQueue.empty()) {
                            readyQueue.front().fillPCB('d', true, cylinderNum[stoi(userInput)-1], pageSize);
                            readTimeSlice(readyQueue.front(), timeSlice);
                            readyQueue.front().increaseCpuCount();
                            disks[stoi(userInput)].push_back(readyQueue.front());
                            readyQueue.pop_front();

                        }
                        else{
                            cout << "There are no available processes in the Ready Queue" << endl;
                            cout << "Please populate the Ready Queue and try again" << endl << endl;
                        }
                        
                    }
                    else{
                        cout << "Printer does not exist" << endl << endl;
                    }
                }
                //ADD TO CDRW QUEUE*****************************************
                else if(userInput[0] == 'c'){
                    userInput.erase(0,1);
                    if (checkValidNum(userInput,cdrwNum)) {
                        if (!readyQueue.empty()) {
                            readyQueue.front().fillPCB('c', false, 0, pageSize);
                            cdrws[stoi(userInput)].push_back(readyQueue.front());
                            readyQueue.pop_front();
                            readTimeSlice(cdrws[stoi(userInput)].back(), timeSlice);
                            cdrws[stoi(userInput)].back().increaseCpuCount();

                        }
                        else{
                            cout << "There are no available processes in the Ready Queue" << endl;
                            cout << "Please populate the Ready Queue and try again" << endl << endl;
                        }
                        
                    }
                    else{
                        cout << "CDRW does not exist" << endl << endl;
                    }
                    
                }
                //REMOVE FROM PRINTER QUEUE*****************************************
                else if(userInput[0] == 'P'){
                    userInput.erase(0,1);
                    if (userInput.length()<1) {
                        throw userInput;
                    }
                    if (checkValidNum(userInput, printerNum)) {
                        if (printers[stoi(userInput)].empty()) {
                            cout << "Printer Queue is empty" << endl << endl;
                        }
                        else{
                            readyQueue.push_back(printers[stoi(userInput)].front());
                            printers[stoi(userInput)].pop_front();
                            cout << "Printer Interrupt Handled" << endl << endl;
                        }
                    }
                    else{
                        cout << "Printer does not exist" << endl << endl;
                    }
                    
                }
                //REMOVE FROM DISK QUEUE*****************************************
                else if(userInput[0] == 'D'){
                    userInput.erase(0,1);
                    if (userInput.length()<1) {
                        throw userInput;
                    }
                    if (checkValidNum(userInput, diskNum)) {
                        if (disks[stoi(userInput)].empty()) {
                            cout << "Disk Queue is empty" << endl << endl;
                        }
                        else{
                            readyQueue.push_back(disks[stoi(userInput)].front());
                            disks[stoi(userInput)].pop_front();
                            cout << "Disk Interrupt Handled" << endl << endl;
                        }
                    }
                    else{
                        cout << "Disk does not exist" << endl << endl;
                    }
                    
                }
                //REMOVE FROM CDRW QUEUE*****************************************
                else if(userInput[0] == 'C'){
                    userInput.erase(0,1);
                    if (userInput.length()<1) {
                        throw userInput;
                    }
                    if (checkValidNum(userInput, cdrwNum)) {
                        if (cdrws[stoi(userInput)].empty()) {
                            cout << "CDRW Queue is empty" << endl << endl;
                        }
                        else{
                            readyQueue.push_back(cdrws[stoi(userInput)].front());
                            cdrws[stoi(userInput)].pop_front();
                            cout << "CD/RW Interrupt Handled" << endl << endl;
                        }
                    }
                    else{
                        cout << "CDRW does not exist" << endl << endl;
                    }
                    
                    
                    
                }
                
                
                else{
                    throw userInput;
                }
                
            } catch (string) {
                cout << "Input error: Please try again" << endl << endl;
            }
            //cout << endl;
        }