//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);
}
