private ProcessTableEntry ContextSwitch(int iEnteringProcessId) { ProcessTableEntry out_process = null; if (CPU.ActiveProcess != -1) { out_process = m_dProcessTable[CPU.ActiveProcess]; out_process.Console = CPU.ActiveConsole; out_process.ProgramCounter = CPU.ProgramCounter; out_process.LastCPUTime = CPU.TickCount; if (m_spPolicy is RoundRobin || m_spPolicy is PrioritizedScheduling) { if (!out_process.Done) { m_spPolicy.AddProcess(iEnteringProcessId); CPU.RemainingTime = out_process.Quantum; } } } ProcessTableEntry in_process = m_dProcessTable[iEnteringProcessId]; CPU.ActiveProcess = iEnteringProcessId; CPU.ProgramCounter = in_process.ProgramCounter; CPU.ActiveConsole = in_process.Console; CPU.ActiveAddressSpace = in_process.AddressSpace; if (m_spPolicy is RoundRobin || m_spPolicy is PrioritizedScheduling) { CPU.RemainingTime = in_process.Quantum; } return(out_process); }
private ProcessTableEntry ContextSwitch(int iEnteringProcessId) { ProcessTableEntry newProcess = m_dProcessTable[iEnteringProcessId]; if (CPU.ActiveProcess != -1) // there is a process in the background at the moment { ProcessTableEntry oldProcess = m_dProcessTable[CPU.ActiveProcess]; if (oldProcess == newProcess) // we are trying to swittch between same process.. no need to waist time for updating... { if ((m_spPolicy is RoundRobin)) { CPU.RemainingTime = oldProcess.Quantum; //updaating the quantom of the SAME process } return(oldProcess); } if (oldProcess.Name != "idle" && oldProcess.Done == false && oldProcess.Blocked == false) { oldProcess.outOfBlock = CPU.TickCount; // this is for knowing the time that a process is ready m_spPolicy.AddProcess(oldProcess.ProcessId); // adding the oldProcess to the schedualing policy because we switched it with the newProcess } //updating the max starvation for the last function in "Program.cs" if (CPU.TickCount - oldProcess.outOfBlock > oldProcess.MaxStarvation) { oldProcess.MaxStarvation = (CPU.TickCount - oldProcess.outOfBlock); } /* this is for RoundRobin only!!! */ object obj = m_spPolicy as RoundRobin; if (obj != null) { CPU.RemainingTime = newProcess.Quantum; //updating remaining time of the cpu to be the quantom of the new process } oldProcess.ProgramCounter = CPU.ProgramCounter; //update the line, which the old process stop, in the table CPU.ActiveProcess = iEnteringProcessId; // update the id of the new process as the running process CPU.ProgramCounter = newProcess.ProgramCounter; // put the PC of new process in the cpu so the new process continue from there CPU.ActiveAddressSpace = newProcess.AddressSpace; //update address space CPU.ActiveConsole = newProcess.Console; //update console situation return(oldProcess); } else // we are the first program { CPU.ActiveProcess = iEnteringProcessId; // update the id of the new process as the running process CPU.ProgramCounter = newProcess.ProgramCounter; // put the PC of new process in the cpu so the new process continue from there CPU.ActiveAddressSpace = newProcess.AddressSpace; //update address space CPU.ActiveConsole = newProcess.Console; //update console situation return(null); //return null because we've been asked to return the returning movie but now no movie should return. } }
public void CreateProcess(string sCodeFileName) { Code code = new Code(sCodeFileName); m_dProcessTable[m_cProcesses] = new ProcessTableEntry(m_cProcesses, sCodeFileName, code); m_dProcessTable[m_cProcesses].StartTime = CPU.TickCount; m_spPolicy.AddProcess(m_cProcesses); m_cProcesses++; }
public OperatingSystem(CPU cpu, Disk disk, SchedulingPolicy sp) { CPU = cpu; Disk = disk; m_dProcessTable = new Dictionary <int, ProcessTableEntry>(); m_lReadRequests = new List <ReadTokenRequest>(); cpu.OperatingSystem = this; disk.OperatingSystem = this; m_spPolicy = sp; //"idle" process here IdleCode idleCode = new IdleCode(); m_dProcessTable[m_cProcesses] = new ProcessTableEntry(m_cProcesses, "idle", idleCode); m_cProcesses++; }
public OperatingSystem(CPU cpu, Disk disk, SchedulingPolicy sp) { CPU = cpu; Disk = disk; m_dProcessTable = new Dictionary <int, ProcessTableEntry>(); m_lReadRequests = new List <ReadTokenRequest>(); cpu.OperatingSystem = this; disk.OperatingSystem = this; m_spPolicy = sp; IdleCode idleCode = new IdleCode(); m_dProcessTable[IDLE_PROCESS_ID] = new ProcessTableEntry(IDLE_PROCESS_ID, "idle", idleCode); m_dProcessTable[IDLE_PROCESS_ID].StartTime = CPU.TickCount; m_spPolicy.AddProcess(m_cProcesses); m_cProcesses++; }
public override int NextProcess(Dictionary <int, ProcessTableEntry> dProcessTable) { if (active_proccess.Count == 0) { return(-1); } foreach (int id in active_proccess) { ProcessTableEntry proccess = dProcessTable[id]; if (proccess.ProcessId != 0 && !proccess.Done && !proccess.Blocked) { return(id); } } return(-1); }
public override int NextProcess(Dictionary <int, ProcessTableEntry> dProcessTable) { if (active_proccess.Count == 0) { return(-1); } int id = active_proccess.Dequeue(); ProcessTableEntry proccess = dProcessTable[id]; if (!proccess.Done && !proccess.Blocked) { proccess.Quantum = quantum; return(id); } return(-1); }
public void Interrupt(ReadTokenRequest rFinishedRequest) { ProcessTableEntry curProcess = m_dProcessTable[rFinishedRequest.ProcessId]; int NumOfProcess = rFinishedRequest.ProcessId; //when the token is null, EOF has been reached. //we write the value to the appropriate address space of the calling process. if (rFinishedRequest.Token == null) { curProcess.AddressSpace[rFinishedRequest.TargetVariable] = double.NaN; } else { //translate the returned token into a value (double). double token = Convert.ToDouble(rFinishedRequest.Token); curProcess.AddressSpace[rFinishedRequest.TargetVariable] = token; } curProcess.Blocked = false; //so we will not stuck in the "idle" later on... curProcess.outOfBlock = CPU.TickCount; //the process isn't blocked any more... hence, its ready. so we save the time... for later calculate max starvation if (m_dProcessTable[NumOfProcess].Done != true) //didn't finish so i need to schedual via policy { m_spPolicy.AddProcess(NumOfProcess); } //activate the next request in queue on the disk. if (m_lReadRequests.Count > 0) { //need to activate next request... Disk.ActiveRequest = m_lReadRequests[0]; m_lReadRequests.RemoveAt(0); } if (m_spPolicy.RescheduleAfterInterrupt()) { ActivateScheduler(); } }
public void Interrupt(ReadTokenRequest rFinishedRequest) { //implement an "end read request" interrupt handler. //translate the returned token into a value (double). //when the token is null, EOF has been reached. //write the value to the appropriate address space of the calling process. //activate the next request in queue on the disk. ProcessTableEntry active_process = m_dProcessTable[rFinishedRequest.ProcessId]; String var_name = rFinishedRequest.TargetVariable; String var_value = rFinishedRequest.Token; if (var_value == null) { active_process.AddressSpace[var_name] = double.NaN; } else { active_process.AddressSpace[var_name] = Convert.ToDouble(var_value); } m_dProcessTable[rFinishedRequest.ProcessId].Blocked = false; m_spPolicy.AddProcess(rFinishedRequest.ProcessId); m_lReadRequests.Remove(rFinishedRequest); if (m_lReadRequests.Count > 0) { ReadTokenRequest awaiting_procees_request = m_lReadRequests.First(); //m_dProcessTable[awaiting_procees_request.ProcessId].Blocked = true; Disk.ActiveRequest = awaiting_procees_request; } if (m_spPolicy.RescheduleAfterInterrupt()) { ActivateScheduler(); } }