예제 #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;

}
예제 #2
0
파일: Zaren.cpp 프로젝트: Naremdela/Zaren
    PCB* SetupPCB(string name, int priority, int processClass)
    {
        if (FindPCB(name) != NULL)
        {
            cout << "Process Name already in use" << endl;
            return NULL;
        }
        if (priority > 128 || priority < -127)
        {
            cout << "Priority must be between -127 and 128" << endl;
            return NULL;
        }
        if (processClass < 1 || processClass > 2)
        {
            cout << "Process Class must either be 1-Application or 2-System" << endl;
            return NULL;
        }
        PCB *pcb = AllocatePCB();
        pcb->setProcessName(name);
        pcb->setPriority(priority);
        pcb->setProcessClass(processClass);
        pcb->setState(2);
        return pcb;


    }
예제 #3
0
PCB* PCBList::shortestToCompletion()
{
    PCB* holder = firstNode;
    PCB* shortestHolder = NULL;
    int shortestValue;
    if(firstNode!=NULL)
    {
        shortestValue = holder->getTimeRemaining();
        shortestHolder = holder;
        qDebug()<<holder;
        qDebug()<<shortestValue;
        while(holder!=NULL)
        {
            qDebug()<<holder;
            qDebug()<<holder->getTimeRemaining();
            if(holder->getTimeRemaining()<shortestValue)
            {
                shortestValue = holder->getTimeRemaining();
                shortestHolder = holder;
            }
            holder = holder->nextPCB;
        }
    }
    qDebug()<<shortestValue;
    qDebug()<<shortestHolder;
    return shortestHolder;
}
예제 #4
0
//arg1 scheduling algorithm
//arg2 quantum, NOTE not all algorithms use quantum
//arg3 primary output file name
//arg4 secondary output file name
//arg5 input data file, NOTE must be well formed
//arg6 number of cores, NOTE must be 1 for uniprocessor
int main(int argc, char *argv[]) {
	vector<Process> procs;
	//hard coded for now
	unsigned int sim_time = 100000;
	map<string, SCHED_TYPE> my_map;
	my_map["FCFS"] = FCFS; my_map["RR"] = RR; my_map["SPN"] = SPN; my_map["SRT"] = SRT; my_map["Feedback"] = Feedback;
	SCHED_TYPE sched_string = my_map[argv[1]];
	unsigned int core_num = atoi(argv[6]);
	unsigned int quantum = atoi(argv[2]);
	string filename = argv[3];
	string file = argv[4];
	string infile = argv[5];

	remove(file.c_str());
	remove(filename.c_str());
	string line;
	for (int i = 0; i < argc; i++) {
		cout << argv[i] << " " << endl;
	}
	ifstream myfile(infile);
	if (myfile.is_open()) {
		while (getline(myfile, line)) {
			istringstream ss(line);
			istream_iterator<string> begin(ss);
			istream_iterator<string> end;
			vector<string> vstrings(begin, end);

			vector<pair<string, unsigned int> > bursts;
			unsigned int PID = atoi(vstrings[0].c_str());
			unsigned int arrival_time = atoi(vstrings[2].c_str());

			for (unsigned int i = 4; i < vstrings.size(); i += 2) {
				if (vstrings[i - 1].compare("CPU") == 0) {
					bursts.push_back(make_pair("CPU", atoi(vstrings[i].c_str())));
				}
				else {
					bursts.push_back(make_pair("IO", atoi(vstrings[i].c_str())));
				}
			}

			Process *p = new Process(PID, arrival_time, bursts);
			procs.push_back(*p);
		}
		myfile.close();
	}
	else cout << "Unable to open data file :(" << endl;

	PCB pcb = PCB(procs, sim_time, sched_string, core_num, quantum, filename);

	//start running simulation
	for (unsigned int clock_int = 0; clock_int < pcb.getSimTime(); clock_int++) {
		pcb.Update(clock_int);
		if (clock_int % 1000 == 0)
			cout << "At clock int: " << clock_int << endl;
	}
	pcb.writeAdditionalData(file);

	return 0;
}
/*
 * Simulates the arrival of a new process into the OS.
 */
void new_process_arrival(PCB new_arrival)
{
	if (new_arrival.check_state("NULL"))
		return;

	new_arrival.set_state("NEW");
	new_queue.push_back(new_arrival);

	// A new process enters the system, the display should now update.
	state_changed_flag = true;
}
예제 #6
0
void MainProcess::Create(str name, int p)
{

	std::vector<str>::iterator it = std::find(nameList.begin(), nameList.end(), name);

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

		return;
	}

	if (p > 2){
		std::cout << "error ";
		ss << "error ";

		return;
	}

	else{

		//Add the new process name to the list of process names
		nameList.push_back(name);

		//Create a reference to a new process
		PCB* newProcess = new PCB(name, p);

		//Set the back pointer to the ready list
		newProcess->setBackPtr(readyList);

		//Set the parent pointer to the parent process
		newProcess->setParent(currentlyRunning);

		//Add it to the process tree
		currentlyRunning->children.push_back(newProcess);

		//Add the new process to the ready list
		newProcess->setStatus(READY);
		readyList[newProcess->getPriority()].push_back(newProcess);

		//Call the scheduler
		Scheduler();

	}



}
예제 #7
0
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;
}
예제 #8
0
파일: Zaren.cpp 프로젝트: Naremdela/Zaren
    PCB* FindPCB(string processName)
    {
        PCB *temp;
        queue<PCB*> readyCopy = ready;
        while (!readyCopy.empty())
        {
            temp = readyCopy.front();
            readyCopy.pop();

            if (temp->getProcessName() == processName)
            {
                return temp;
            }
        }
        queue<PCB*> blockedCopy = blocked;
        while (!blockedCopy.empty())
        {
            temp = blockedCopy.front();
            blockedCopy.pop();
            if (temp->getProcessName() == processName)
            {
                return temp;
            }
        }
        queue<PCB*> suspendedReadyCopy = suspendedReady;
        while (!suspendedReadyCopy.empty())
        {
            temp = suspendedReadyCopy.front();
            suspendedReadyCopy.pop();
            if (temp->getProcessName() == processName)
            {
                return temp;
            }
        }
        queue<PCB*> suspendedBlockedCopy = suspendedBlocked;
        while (!suspendedBlockedCopy.empty())
        {
            temp = suspendedBlockedCopy.front();
            suspendedBlockedCopy.pop();
            if (temp->getProcessName() == processName)
            {
                return temp;
            }
        }
        return NULL;
    }
예제 #9
0
//Facilitates the sending of messages between processes
// This function is non-blocking 
int MsgServ::sendMsg(int destPid, MsgEnv* msg)
{
	if(msg != NULL && destPid >= 0 && destPid < PROCESS_COUNT)
	{
		//retrieve PCB of currently excecuting process 
		PCB* tempPCB;		
		assure((tempPCB = gRTX->getCurrentPcb()) != NULL,"Failed to retrieve current PCB",__FILE__,__LINE__,__func__,false); //ERic

		//insert destination and origin into msg envelope
		msg->setDestPid(destPid);
		msg->setOriginPid(tempPCB->getId());
		_msgTrace->addTrace(msg, SEND); 
		 
		//retrieve destination process PCB
		PCB* tempDestPCB;
		assure(gRTX->getPcb(destPid, &tempDestPCB) == EXIT_SUCCESS,"Failed to retrieve dest. PCB",__FILE__,__LINE__,__func__,true);
		
		int status = tempDestPCB->getState();
		if(status == BLOCKED_MSG_RECIEVE || 
			 ( status == SLEEPING && msg->getMsgType() == MsgEnv::REQ_DELAY ))
		{
			_scheduler->unblock_process(tempDestPCB);
		}
		
		//determine if process being sent to needs to be made ready
		//add msg to process mailbox

		if( msg->getDestPid() != PROC_TIMING &&
			  msg->getMsgType() == MsgEnv::REQ_DELAY )
		{
			int type;
			strToInt(msg->getMsgData(),&type);
			msg->setMsgType(type);
			msg->setMsgData("");
		}

		tempDestPCB->addMail(msg);

		return EXIT_SUCCESS;
	}
	return EXIT_ERROR;
}
//
// New processes are allocated memory in the main_memory array. 
//
void memory_allocate(PCB new_arrival)
{
	int PID = new_arrival.get_id();
	int requested_memory = new_arrival.get_size();
	int free_memory = 0;

	while(main_memory[free_memory] != 0)
		free_memory++;

	if((MEM_SIZE - free_memory) >= requested_memory)
		for(int i = free_memory; i < free_memory + requested_memory; i++)
			main_memory[i] = PID;
	else
	{
		if (DEBUG) cout << "(memory_allocate): ERROR Not enough memory for process " << PID << endl;
	}

	// Memory has been allocated, update UI.
	state_changed_flag = true;
}
예제 #11
0
파일: Zaren.cpp 프로젝트: Naremdela/Zaren
    void OSTest2() //PCB Tests
    {
        PCB *a = pcbControl.SetupPCB("a",12,1);
        PCB *b = pcbControl.SetupPCB("b",-12,2);
        PCB *c = pcbControl.SetupPCB("c",32,1);
        PCB *d = pcbControl.SetupPCB("d",34,1);
        PCB *e = pcbControl.SetupPCB("e",12,2);
        PCB *f = pcbControl.SetupPCB("f",16,1);
        PCB *g = pcbControl.SetupPCB("g",12,1);

        b->setState(3);
        c->setState(4);
        d->setState(5);
        e->setState(3);
        g->setState(5);

        pcbControl.InsertPCB(a);
        pcbControl.InsertPCB(b);
        pcbControl.InsertPCB(c);
        pcbControl.InsertPCB(d);
        pcbControl.InsertPCB(e);
        pcbControl.InsertPCB(f);

        pcbControl.showQueue(5);

        pcbControl.RemovePCB(a);
        pcbControl.RemovePCB(b);
        pcbControl.RemovePCB(c);
        pcbControl.RemovePCB(d);
        pcbControl.RemovePCB(e);
        pcbControl.RemovePCB(f);

        pcbControl.FreePCB(a);
        pcbControl.FreePCB(b);
        pcbControl.FreePCB(c);
        pcbControl.FreePCB(d);
        pcbControl.FreePCB(e);
        pcbControl.FreePCB(f);

        pcbControl.showQueue(5);
    }
예제 #12
0
PCB* PCBList::findPCB(QString nameSearch)
{
    PCB* holder;
    holder = firstNode;
    if(nameSearch!=NULL)
    {
        while(holder!=NULL)
        {
            //qDebug()<<"inside while";
            if(holder->getName()==nameSearch)
            {
                //qDebug()<<"inside if";
                //qDebug()<<holder;
                return holder;
            }
            holder = holder->nextPCB;
        }
        //qDebug()<<holder;
    }
    return NULL;
}
예제 #13
0
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;
		

}
예제 #14
0
//Facilitates the retrieval of messages from the process PCB mailbox 
//This Function is blocking if there are no messages waiting to be recieved
MsgEnv* MsgServ::recieveMsg()
{
	//retrieve PCB of currently excecuting process 
	PCB* tempPCB = gRTX->getCurrentPcb();
	assure(tempPCB != NULL, "Failed to retrieve current PCB",__FILE__,__LINE__,__func__,false);

	while (tempPCB->checkMail() == 0)
	{
		//i_process cannot be blocked
		if (tempPCB->getProcessType() == PROCESS_I)
    		return NULL;
  		
  		//block calling process, this automatically calls a process_switch
  	if(gRTX->getCurrentPcb()->getState() != SLEEPING)
			_scheduler->block_process(BLOCKED_MSG_RECIEVE); 		
	}
	//get mail
	MsgEnv* tempMsg = tempPCB->retrieveMail();
	
	_msgTrace->addTrace(tempMsg, RECEIVE);
	return tempMsg;
}
예제 #15
0
PCB* SJFScheduler::schedule(ReadyQueue* q){
	PCB* currentProcess;
	PCB* selectedProcess;

	//Bring iterator to beginning of ready queue
	q->begin();

	//Intially set current and selected processes to the current process
	currentProcess = q->getCurrent();
	selectedProcess = q->getCurrent();

	//Iterate through the ready queue and find the shortest process
	while(currentProcess != NULL){
		if(currentProcess->getTimeRemInBurst() < selectedProcess->getTimeRemInBurst()){
			selectedProcess = q->getCurrent();
		}
		currentProcess = q->getNext();
	}

	//Remove the shortest process from the ready queue and return it
	q->remove(selectedProcess);
	return selectedProcess;
}
예제 #16
0
void RMS::iniciarEscalonamento() {
    int tamanho = pronto.ObtemTamanho()+1;
    NoDaListaSimples<PCB>* aux;
    while(tamanho > 0) {
        PCB* maisPrio = pronto.obtemPrimeiro()->ObtemInfo();
        int pos = 0;
        aux = pronto.obtemPrimeiro();
        int tamanhoAtual = pronto.ObtemTamanho()+1;
        for(int i = 0; i < tamanhoAtual; i++) {
            if(maisPrio->getPeriodo() > aux->ObtemInfo()->getPeriodo()) {

                maisPrio = aux->ObtemInfo();
                pos = i;
            }
            aux = aux->ObtemProximo();
        }
        pronto.RetiraDaPosicao(pos);
        cout << "tamanho atual" << tamanhoAtual << endl;
        cout << "tamanho total" << tamanho << endl;
        if(tamanho == tamanhoAtual) {
            tempo++;
            executando.AdicionarNoFim(maisPrio);
            cout << "processo com periodo exec "<<maisPrio->getPeriodo() << endl;
            cout << "processo tem " << maisPrio->getExec() << endl;
            maisPrio->decremento();
            cout << "processo foi decrementado e tem " << maisPrio->getExec() << endl;
            if(maisPrio->getExec() == 0) {
                cout << "processo acabou" << endl;
                terminado.AdicionarNoFim(maisPrio);
                executando.Retirar();
                tamanho--;

            } else {
                cout << "voltou para pronto" << endl;
                pronto.AdicionarNoFim(maisPrio);

            }

            //cout << "pos que vai ser tirada" << pos<< endl;

            //cout << maisPrio->getPeriodo();

        }

    }
}
// 
// Processes that are finished running have their memory removed. 
// Remaining memory is then shifted down. 
//
void memory_deallocate(PCB finished_process)
{
	int i = 0;
	int j;
	int PID = finished_process.get_id();
	while(main_memory[i] != PID)
		i++;
	j = i;
	while(main_memory[j] == PID)
	{
		main_memory[j] = 0;
		j++;
	}
	while(main_memory[j] != 0 && j < MEM_SIZE)
	{
		main_memory[i] = main_memory[j];
		main_memory[j] = 0;
		i++;
		j++;
	}

	// Memory has been deallocated, update UI.
	state_changed_flag = true;
}
예제 #18
0
파일: main.cpp 프로젝트: Bjornkjohnson/OS
bool sortHelp (PCB i,PCB j) { return (i.getProcessSize()<j.getProcessSize()); }
예제 #19
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;
        }
예제 #20
0
void system_call_handler(LinkedList<PCB> *device_array, LinkedList<PCB> &ready_queue, int device_num,
                         string device_type, int array_size)
{
        string file_name;
        int file_size, location;
        char file_op;
        PCB vessel;

        file file_parameters;
        if(device_num > array_size)
        {
          cout << "error: " << device_type << " number exceeded." << endl;
          return;
        }
        else if (device_num == 0){
          cout << "error: " << device_type << " has no value " << device_num << " amount." << endl;
          return; 
        }
        else if(ready_queue.IsEmpty())
        {
          cout << "No processes in ready queue" << endl;
          return;
        }

        vessel = ready_queue.peek();
        ready_queue.deQueue();
        cout << "Sending the first object to a printer queue" << endl;
        cout << "Enter the file name: ";
        while( file_name.length() == 0 || file_name.length() > 16)
        {
          cin >> file_name;
          if(file_name.length() > 16)
          {
            cout << "Please reenter your file; input too long." << endl;
          } 
          else if(file_name.length() == 0) cout << "No input detected. Try again." << endl;
        }
        cout << endl;

        cout << "Enter the file size: ";
        cin >> file_size;
        cout << endl;

        cout << "Enter the file location: ";
        cin >> location;
        cout << endl;

        cout << "Enter the file operation: ";
        if(device_type == "printers"){
          cout << "Printer op; setting operation to (w)rite." << endl;
          file_op = 'w';
        }
        else{
          cin >> file_op;
          newLine();
          cout << endl;
          while(file_op != 'r' && file_op != 'w')
          {
            cout << "Please enter r for read or w for write: " << endl;
            cin >> file_op;
            newLine();
          }
        }

        cout << "parameters are: " << file_name << " " << file_size << " " << location << " " << file_op << endl;

        file_parameters.change_parameters(file_name, file_op, file_size, location);

        vessel.file_parameters(file_parameters);

        cout << "going into device number: " << device_num << endl;
        admit_into_queue(device_array[device_num - 1], vessel);
}
예제 #21
0
파일: OS.cpp 프로젝트: Pyrot1c/cse460
void OS::start() 
{
 // Get the s files
 
    system("ls *.s > progs");
     
    fstream readProgs;
    readProgs.open("progs", ios::in);
	
    if (!readProgs.is_open()) {
        cout << "cant open progs\n";
        exit(1);
    }

    string line;
    getline(readProgs, line);
    
    while (!readProgs.eof()) {
        
        as.assemble(line); // assemble the files
    
        //make the PCB for each file, put the jobs list, and then the ready queue
    
        PCB * p = new PCB;
        jobs.push_back(p);
        readyQ.push(p);
        p->state = "ready";
        
        string fileName = line.erase(line.length() -2, 2);
        
        // assign file names, input and outputs
        p->originalfilename = fileName + ".o";          
        p->readfilename = fileName + ".in";           
        p->writefilename = fileName + ".out";       
        p->stfilename =  fileName + ".st";        

        // Read in files
        p->openReadInFileStream();
        p->openWriteOutFileStream();
        
        //read into mem
    
        int base, limit;
    
        vm.loadIntoMemory(p->originalfilename, &base, &limit);
    
        p->base = base;
        p->limit = limit;
        p->pc = base;
        
        getline(readProgs, line);      
    } 
    
    readProgs.close();
    system("rm progs");

    // copy item 1 in readyQueue to running , load pcb data to vm  

    running = readyQ.front();
    readyQ.pop();
    givePCBToVM();
    
    int code = 0; 
    
    while (!done()) // main loops
    {
        code = 0;
   
        vm.run(); 
        
        code = vm.sr;    
        code = code & 0xe0;  
        code >>= 5;          
        
        masterClock += 5;
        contextSwitchClock += 5;
        
        for (list<PCB *>::iterator it = jobs.begin(); it != jobs.end(); it++)
            if(!strcmp((*it)->state.c_str(), "terminated"))
                (*it)->contextSwitchTime += 5;

    
        // if interrupt move.
        if(!waitQ.empty()) {
            while (waitQ.front()->interruptTime <= masterClock) {
                PCB * temp = waitQ.front();
                waitQ.pop();
                readyQ.push(temp); 
                temp->state = "ready";      
                if(waitQ.empty())
                    break;     
            }
        }
        

        for (list<PCB *>::iterator it = jobs.begin(); it != jobs.end(); it++)
            if(strcmp((*it)->state.c_str(), "ready"))
                (*it)->waitingTime += vm.clock; 
            
        if(!(running == NULL)) {
    
            //update clocks
            masterClock += vm.clock;
            running->cpuTime += vm.clock;

			//them errors cases
            switch (code) {
                case 0:
                    getPCBFromVM();
                    readyQ.push(running);          
                    break;           
                case 1:
                    running->state = "terminated";
                    break;           
                case 2:
                    running->state = "terminated";
                    outputErrorCode("Out-of-Bound Reference");
                    break;           
                case 3:
                    running->state = "terminated";           
                    outputErrorCode("Stack Overflow");
                    break;      
                case 4:
                    running->state = "terminated";
                    outputErrorCode("Stack Underflow");
                    break;
                case 5:
                    running->state = "terminated";
                    outputErrorCode("Invalid OPCode");
                    break;
                case 6:
                {          
                    int readIn;
               
                    running->readIntoRegister >> readIn;

                    int readReg = vm.sr;
 
                    readReg &= 0x300;         
                    readReg >>= 8; 
                     
                    if(readReg < 0 || readReg > 3) {
                        outputErrorCode("Invalid IO Register");
                        break;
                    }
                
                    vm.reg[readReg] = readIn; 
      
                    masterClock++;
                    running->ioTime += 27;
                    running->cpuTime++;  
                    waitQ.push(running);
                    running->state = "waiting";
                    getPCBFromVM(); 
                    running->interruptTime = masterClock + 28;
               
                    break;
                }
            
                case 7:
                {        
                    int writeToReg = vm.sr;
           
                    writeToReg &= 0x300;   
                
                    writeToReg >>= 8;   
                
                    int temp = vm.reg[writeToReg] & 0x8000;
      
                    if (temp) 
                        temp = vm.reg[writeToReg] | 0xffff0000;
                    else
                        temp = vm.reg[writeToReg] & 0xffff;
    
                    running->writeToRegister << temp << endl;
                
                    masterClock++;
                    running->ioTime += 27;
                    running->cpuTime++;                   
               
                    waitQ.push(running);
                    running->state = "waiting";
                    getPCBFromVM();
                    running->interruptTime = masterClock + 28;

                    break;
                }
                
                default:
                    outputErrorCode("Invalid Return Code");
                    running->state = "terminated";
                    break;
            }
        
            running = NULL;
 
        } 
        

   
		//update clock after item 1
        if(readyQ.empty() && !waitQ.empty()) {

            int temp = waitQ.front()->interruptTime - masterClock;
    
            masterClock += temp;
            idleClock += temp;
            readyQ.push(waitQ.front());
            waitQ.front()->state = "ready";
            waitQ.pop(); 
        
            for (list<PCB *>::iterator it = jobs.begin(); it != jobs.end(); it++)
                if(!strcmp((*it)->state.c_str(), "terminated"))
                    (*it)->idleTime += temp;      
        }

        if(!readyQ.empty()) {
            running = readyQ.front();
            running->state = "running";
            readyQ.pop();
            givePCBToVM();
        }  
    
    } 
예제 #22
0
파일: os.cpp 프로젝트: Pyrot1c/cse460
void OS::start() 
{
 // read in all the .s files 
 
    system("ls *.s > progs");
     
    fstream readProgs;
    readProgs.open("progs", ios::in);
	
    if (!readProgs.is_open()) {
        cout << "could not open progs.\n";
        exit(1);
    }

    string line;
    getline(readProgs, line);
    
	
	//begin while loops when !progs end of file
    while (!readProgs.eof()) {
        
        as.assemble(line); // assemble each file using the asembler
    
        //create PCB for each file, put in jobs list, and put in ready queue 
    
        PCB * p = new PCB;
        jobs.push_back(p);
        readyQ.push(p);
        p->state = "ready";
        
        string fileName = line.erase(line.length() -2, 2);
        
        // set file names for input and output
        p->originalfilename = fileName + ".o";          
        p->readfilename = fileName + ".in";           
        p->writefilename = fileName + ".out";       
        p->stfilename =  fileName + ".st";        

        // Open input and output file streams in PCB
        p->openReadInFileStream();
        p->openWriteOutFileStream();
        
        //read into memory, modify PCB with values for base and limit
    
        int base, limit;
    
        vm.loadIntoMemory(p->originalfilename, &base, &limit);
    
        p->base = base;
        p->limit = limit;
        p->pc = base;
        
        getline(readProgs, line);      
    } // end reading into memory
    
    readProgs.close();
    system("rm progs");

    // copy first item in readyQ to running , load pcb data to vm  

    running = readyQ.front();
    readyQ.pop();
    givePCBToVM();
    
    int code = 0; 
    
    while (!done()) // main while loop main processing
    {
        code = 0;
   
        vm.run(); // runs current process in vm, returns error code stored for later
        
        // get return code from status register
        code = vm.sr;    
        code = code & 0xe0;  
        code >>= 5;          
        
        // update clocks for context switch
        masterClock += 5;
        contextSwitchClock += 5;
        
        // update all processes that aren't terminated with addition to context switch time
        for (list<PCB *>::iterator it = jobs.begin(); it != jobs.end(); it++)
            if(!strcmp((*it)->state.c_str(), "terminated"))
                (*it)->contextSwitchTime += 5;

        // First item in main loop
    
        // move items from waitQ into readyQ if interrupt time hit
        if(!waitQ.empty()) {
            while (waitQ.front()->interruptTime <= masterClock) {
                PCB * temp = waitQ.front();
                waitQ.pop();
                readyQ.push(temp); 
                temp->state = "ready";      
                if(waitQ.empty())
                    break;     
            }
        }

        // Second item in main loop
        

        // Update waiting time for all items in ready queue with latest cycle time from vm.run()
        for (list<PCB *>::iterator it = jobs.begin(); it != jobs.end(); it++)
            if(strcmp((*it)->state.c_str(), "ready"))
                (*it)->waitingTime += vm.clock; 
            
        if(!(running == NULL)) {
    
            // update master clock and cpu time
            masterClock += vm.clock;
            running->cpuTime += vm.clock;

            // main switch to handle return code, if terminated set, output errorcode.
            switch (code) {
                case 0:
                    getPCBFromVM();
                    readyQ.push(running);          
                    break;           
                case 1:
                    running->state = "terminated";
                    break;           
                case 2:
                    running->state = "terminated";
                    outputErrorCode("Out-of-Bound Reference");
                    break;           
                case 3:
                    running->state = "terminated";           
                    outputErrorCode("Stack Overflow");
                    break;      
                case 4:
                    running->state = "terminated";
                    outputErrorCode("Stack Underflow");
                    break;
                case 5:
                    running->state = "terminated";
                    outputErrorCode("Invalid OPCode");
                    break;
                case 6:
                {          
                    int readIn;
               
                    running->readIntoRegister >> readIn;

                    int readReg = vm.sr;
 
                    readReg &= 0x300;         
                    readReg >>= 8; 
                     
                    if(readReg < 0 || readReg > 3) {
                        outputErrorCode("Invalid IO Register");
                        break;
                    }
                
                    vm.reg[readReg] = readIn; 
      
                    masterClock++;
                    running->ioTime += 27;
                    running->cpuTime++;  
                    waitQ.push(running);
                    running->state = "waiting";
                    getPCBFromVM(); 
                    running->interruptTime = masterClock + 28;
               
                    break;
                }
            
                case 7:
                {        
                    int writeToReg = vm.sr;
           
                    writeToReg &= 0x300;   
                
                    writeToReg >>= 8;   
                
                    int temp = vm.reg[writeToReg] & 0x8000;
      
                    if (temp) 
                        temp = vm.reg[writeToReg] | 0xffff0000;
                    else
                        temp = vm.reg[writeToReg] & 0xffff;
    
                    running->writeToRegister << temp << endl;
                
                    masterClock++;
                    running->ioTime += 27;
                    running->cpuTime++;                   
               
                    waitQ.push(running);
                    running->state = "waiting";
                    getPCBFromVM();
                    running->interruptTime = masterClock + 28;

                    break;
                }
                
                default:
                    outputErrorCode("Invalid Return Code");
                    running->state = "terminated";
                    break;
            }
        
            running = NULL;
 
        } // end if running loop
        

        // Third item in main loop
   
        // if all items in waitQ, update masterclock to get first item out of waitQ
        if(readyQ.empty() && !waitQ.empty()) {

            int temp = waitQ.front()->interruptTime - masterClock;
    
            masterClock += temp;
            idleClock += temp;
            readyQ.push(waitQ.front());
            waitQ.front()->state = "ready";
            waitQ.pop(); 
        
            // update idle time for all non terminated process in jobs list
            for (list<PCB *>::iterator it = jobs.begin(); it != jobs.end(); it++)
                if(!strcmp((*it)->state.c_str(), "terminated"))
                    (*it)->idleTime += temp;      
        }

        // move next process from readyQ into running state, copy over pcb contents
        if(!readyQ.empty()) {
            running = readyQ.front();
            running->state = "running";
            readyQ.pop();
            givePCBToVM();
        }  
    
    } // end main process loop