//version 2 feedback with quantum = 2^i - aging solution public List <PCB> v2Feedback(Queue <PCB> processes, bool CPUburst) { Console.WriteLine(data.introAlgString(data.algorithms[7], processes.Count, CPUburst)); var finished = false; counter = 0; var startIndex = 0; numProcesses = processes.Count; var localFinishedProcesses = 0; nonEmptyProcesses.Clear(); List <Queue <PCB> > rq = new List <Queue <PCB> >(); for (int i = 0; i < 20; i++) { rq.Add(new Queue <PCB>()); } while (counter != processes.Peek().arrivalTime) { counter++; } process = processes.Dequeue(); process.serviceTime = process.CPU.Dequeue(); process.beginServiceTime = process.serviceTime; if (process.responseTime == -1) { process.responseTime = counter; } process.waitTime += counter; if (process.waitTime < 0) { Console.WriteLine(); } while (counter != processes.Peek().arrivalTime) { counter++; //quantum is only (2^0)=1 for this case if (debugStatements) { Console.WriteLine("Process " + process.PID + " service time is " + process.serveTime(1.00)); } else { process.serveTime(1.00); } } rq[++startIndex].Enqueue(process); while (!finished) { process.stop = counter; //if a process has arrived either on time or has been waiting, get the process and start our index of queues back at 0 if (processes.Count != 0) { if (counter >= processes.Peek().arrivalTime) { process = processes.Dequeue(); process.serviceTime = process.CPU.Dequeue(); process.beginServiceTime = process.serviceTime; if (process.responseTime == -1) { process.responseTime = counter; } process.waitTime += counter; if (process.waitTime < 0) { Console.WriteLine(); } startIndex = 0; rq[startIndex].Enqueue(process); } } while (rq[startIndex].Count == 0 && startIndex < rq.Count - 1) { startIndex++; } process = rq[startIndex].Dequeue(); if (process.stop != 0) { process.start = counter; process.waitTime += (process.start - process.stop); } //the process serves 2^1 amount of time var quantum = Math.Pow(2.00, (Double)startIndex); var processServeTime = Convert.ToInt32(process.serveTime(quantum)); //must check if the process finished before the quantum amount if (processServeTime < 0) { counter += (processServeTime * (-1)); } else { counter += (int)quantum; //otherwise we just set it to the total time } if (debugStatements) { Console.WriteLine("Process " + process.PID + " service time is " + process.serveTime(quantum) + " at time " + counter + " and wait time is " + process.waitTime); } else { process.serveTime(quantum); } if (process.serviceTime <= 0) { process.finished = true; localFinishedProcesses++; process.executionTime = counter; if ((CPUburst && process.IO.Count > 0) || (!CPUburst && process.CPU.Count > 0)) // if we still have IO or CPU bursts to process... { nonEmptyProcesses.Add(process); // add it to the process list that still needs to further processed } else { process.executionTime = timeCounter + counter; process.determineTurnaroundTime(); process.determineTRTS(process.beginServiceTime); finishedProcesses.Add(process); // add it to the list of "finished" processes (processes that don't have any more bursts) } if (localFinishedProcesses == numProcesses) { finished = true; } if (debugStatements) { Console.WriteLine("Process " + process.PID + " finished at time " + process.executionTime); } continue; } if ((startIndex + 1) == rq.Count) { rq.Add(new Queue <PCB>()); } rq[++startIndex].Enqueue(process); if (rq[--startIndex].Count == 0) { startIndex++; } counter += contextSwitchCost; totalContextSwitch += contextSwitchCost; } timeCounter += counter; var throughput = numProcesses - nonEmptyProcesses.Count; throughputList[7] += throughput; Console.WriteLine(data.outroAlgString(data.algorithms[7], counter, throughput, nonEmptyProcesses.Count, finishedProcesses.Count, timeCounter)); return(nonEmptyProcesses); }
// version 1 feedback with quantum = 1 - preemptive public List <PCB> v1Feedback(Queue <PCB> processes, bool CPUburst) { //Queue<PCB> processes = data.sample; Console.WriteLine(data.introAlgString(data.algorithms[6], processes.Count, CPUburst)); int quantum = 1; var finished = false; // flag to tell when algorithm is complete counter = 0; var startIndex = 0; // start index of the ready queues numProcesses = processes.Count; var localFinishedProcesses = 0; // to help us decide whether or not the algorithm is finished nonEmptyProcesses.Clear(); //create a list of queues List <Queue <PCB> > rq = new List <Queue <PCB> >(); for (int i = 0; i < 1000; i++) { rq.Add(new Queue <PCB>()); } //first process while (counter != processes.Peek().arrivalTime) { counter++; } process = processes.Dequeue(); process.serviceTime = process.CPU.Dequeue(); process.beginServiceTime = process.serviceTime; if (process.responseTime == -1) { process.responseTime = counter; } process.waitTime += counter; while (counter != processes.Peek().arrivalTime) { counter++; if (debugStatements) { Console.WriteLine("Process " + process.PID + " service time is " + process.serveTime(quantum) + " at time " + counter); } else { process.serveTime(quantum); } } //assuming first process will not finish before next process comes in - not realistic of a CPU rq[++startIndex].Enqueue(process); while (!finished) { process.stop = counter; //if a process has arrived, get the process and start our index of queues back at 0 if (processes.Count != 0) { if (counter >= processes.Peek().arrivalTime) { process = processes.Dequeue(); process.serviceTime = process.CPU.Dequeue(); process.beginServiceTime = process.serviceTime; if (process.responseTime == -1) { process.responseTime = counter; } process.waitTime += counter; startIndex = 0; rq[startIndex].Enqueue(process); } } //if inbetween queues are empty, move along until we get to next queue that has elements while (rq[startIndex].Count == 0 && startIndex < rq.Count - 1) { startIndex++; } //take the process of the current queue process = rq[startIndex].Dequeue(); if (process.stop != 0) { process.start = counter; process.waitTime += (process.start - process.stop); } counter++; if (debugStatements) { Console.WriteLine("Process " + process.PID + " service time is " + process.serveTime(quantum) + " at time " + counter + " and wait time is " + process.waitTime); } else { process.serveTime(quantum); } if (process.serviceTime == 0) { localFinishedProcesses++; // count the number of processes that have finished if ((CPUburst && process.IO.Count > 0) || (!CPUburst && process.CPU.Count > 0)) // if we still have IO or CPU bursts to process... { nonEmptyProcesses.Add(process); // add it to the process list that still needs to further processed } else { process.executionTime = timeCounter + counter; process.determineTurnaroundTime(); process.determineTRTS(process.beginServiceTime); finishedProcesses.Add(process); // add it to the list of "finished" processes (processes that don't have any more bursts) } // we have finished once all the processes have finished if (localFinishedProcesses == numProcesses) { finished = true; } if (debugStatements) { Console.WriteLine("Process " + process.name + " finished at time " + process.executionTime); } continue; } //move to the next queue if ((startIndex + 1) == rq.Count) { rq.Add(new Queue <PCB>()); } rq[startIndex + 1].Enqueue(process); //if there are no processes in this queue, then we move to the next queue if (rq[startIndex].Count == 0) { startIndex++; } //incorporate the context switch cost when switching between processes counter += contextSwitchCost; totalContextSwitch += contextSwitchCost; } timeCounter += counter; var throughput = numProcesses - nonEmptyProcesses.Count; throughputList[6] += throughput; Console.WriteLine(data.outroAlgString(data.algorithms[6], counter, throughput, nonEmptyProcesses.Count, finishedProcesses.Count, timeCounter)); return(nonEmptyProcesses); }