public override void addQueue(Process p)
{
if (remainingSize > p.getSize())
{
queue.Insert(0, p);
remainingSize -= p.getSize();
}
else
{
throw new System.ArgumentException("Parameter cannot be null", "original");
}
}
public override void addQueue(Process p)
{
if (remainingSize > p.getSize())
{
queue.Insert(0, p);
remainingSize -= p.getSize();
Console.WriteLine("successfully added");
}
else
{
Console.WriteLine("not enough space process size : " + p.getSize() + " remain : " + Program.readyQueue.getRemainingSize());
throw new System.ArgumentException("Parameter cannot be null", "original");
}
}
public void IOFInishedEventHandler(Process p)
{
if (Program.waitingQueue.getQueue().Contains(p))
{
Program.waitingQueue.removeProcess(p);
if (p.getIsDuplicateForIO())
{
}
else
{
if (Program.readyQueue.getRemainingSize() > p.getSize())
{
Program.readyQueue.addQueue(p);
}
else
{
Program.suspendedReadyQueue.addQueue(p);
}
}
}
else
{
Program.suspendedWaitingQueue.getQueue().Remove(p);
if (p.getIsDuplicateForIO())
{
}
else
{
Program.suspendedReadyQueue.addQueue(p);
}
}
}
public void runningToBlockedHandler(Process p)
{
Console.WriteLine("running to Blocked");
Console.WriteLine(p.getProcessedTime());
if (p.getSize() < Program.waitingQueue.getRemainingSize())
{
Program.waitingQueue.addQueue(p);
}
else
{
bool temp = false;
for (int i = 0; i < Program.waitingQueue.getQueue().Count(); i++)
{
if (Program.waitingQueue.getQueue().ElementAt(i).getMeasuredPriority() < p.getMeasuredPriority())
{
if (Program.waitingQueue.getQueue().ElementAt(i).getSize() <= p.getSize())
{
Process tempProcess = Program.waitingQueue.getQueue().ElementAt(i);
blockedToSuspendedBlockedHandler(tempProcess);
Program.waitingQueue.addQueue(p);
temp = true;
break;
}
}
}
if (!temp)
{
Program.suspendedWaitingQueue.addQueue(p);
}
}
if (!p.getIsDuplicateForIO())
{
Program.cpu.setIdle();
}
}
public void runningToReadyHandler()
{
Console.WriteLine("in running to ready");
Process temp = Program.cpu.getProcess();
if (Program.readyQueue.getRemainingSize() > temp.getSize())
{
Program.readyQueue.addQueue(temp);
}
else
{
runningToReadySuspendedHandler(temp);
}
Program.cpu.setIdle();
}
public override void removeProcess(Process p)
{
remainingSize += p.getSize();
queue.Remove(p);
}
public void perfomeCPU()
{
while (true)
{
lock (Program.o)
{
if (!isIdle())
{
if (currentProcess.getIORequiredTimesQueue().Count() > 0)
{
if (currentProcess.getIORequiredTimesQueue().ElementAt(0) <= currentProcess.getProcessedTime() + count)
{
if (currentProcess.getThreadEnabled())
{
currentProcess.getIORequiredTimesQueue().RemoveAt(0);
Process thread = new Process(currentProcess.getName() + " t", currentProcess.getPriority(), currentProcess.getMeasuredTime(), currentProcess.getSize(), 0, true, true);
Program.os.runningToBlockedHandler(thread);
Program.newIOHandler.addToIOWaitingProcessesQueue(thread);
}
else
{
newTimer.Enabled = false;
Console.WriteLine("Blocked");
Program.os.runningToBlockedHandler(currentProcess);
currentProcess.setProcessedTime(currentProcess.getProcessedTime() + count);
count = 0;
Program.newIOHandler.addToIOWaitingProcessesQueue(currentProcess);
setIdle();
}
}
else
{
if (currentProcess.getProcessedTime() + count >= currentProcess.getMeasuredTime())
{
newTimer.Enabled = false;
Program.finishedProcesses.addProcess(currentProcess);
Program.agingHandler.removeProcess(currentProcess);
currentProcess.setProcessedTime(currentProcess.getProcessedTime() + count);
Console.WriteLine("process finished and processed time = " + currentProcess.getProcessedTime());
count = 0;
setIdle();
}
else if (count >= cPUBreakTimeIntervel)
{
newTimer.Enabled = false;
Console.WriteLine("time out****************************************** process getout processed time = " + currentProcess.getProcessedTime());
currentProcess.setProcessedTime(currentProcess.getProcessedTime() + count);
count = 0;
Program.os.runningToReadyHandler();
setIdle();
}
}
}
else
{
if (currentProcess.getProcessedTime() + count >= currentProcess.getMeasuredTime())
{
newTimer.Enabled = false;
Console.WriteLine("finished process");
Program.finishedProcesses.addProcess(currentProcess);
currentProcess.setProcessedTime(currentProcess.getProcessedTime() + count);
count = 0;
setIdle();
}
else if (count >= cPUBreakTimeIntervel)
{
currentProcess.setProcessedTime(currentProcess.getProcessedTime() + count);
Console.WriteLine("time out******************************************process getout processed time = " + currentProcess.getProcessedTime());
newTimer.Enabled = false;
count = 0;
Program.os.runningToReadyHandler();
setIdle();
}
}
if (newTimer.Enabled == false)
{
currentProcess.setTimeInQueue();
setIdle();
}
}
}
}
}
public void suspendedReadyToReadyHandler()
{
while (true)
{
lock (Program.o)
{
//Console.WriteLine("suspendedReadytoready working");
if (Program.suspendedReadyQueue.getQueue().Count() > 0)
{
for (int i = Program.suspendedReadyQueue.getQueue().Count() - 1; i >= 0; i--)
{
if (Program.suspendedReadyQueue.getQueue().ElementAt(i).getSize() < Program.readyQueue.getRemainingSize())
{
Console.WriteLine("swapping process from suspended ready to readyhandler ");
Process tempP = Program.suspendedReadyQueue.getQueue().ElementAt(i);
Program.suspendedReadyQueue.getQueue().Remove(tempP);
Program.readyQueue.addQueue(tempP);
break;
}
else if (Program.readyQueue.getQueue().Count() > 0)
{
int tempTotalSize = 0;
for (int k = 0; k < Program.readyQueue.getQueue().Count(); k++)
{
if (Program.suspendedReadyQueue.getQueue().ElementAt(i).getMeasuredPriority() <= Program.readyQueue.getQueue().ElementAt(k).getMeasuredPriority())
{
break;
}
tempTotalSize += Program.readyQueue.getQueue().ElementAt(k).getSize();
if (tempTotalSize >= Program.suspendedReadyQueue.getQueue().ElementAt(i).getSize())
{
Process temp = Program.suspendedReadyQueue.getQueue().ElementAt(i);
int tempInt = k;
while (tempInt >= 0)
{
readyToReadySuspendedHandler(Program.readyQueue.getQueue().ElementAt(0));
tempInt--;
Console.WriteLine("inside suspended to ready while readyQueue remaining size: " + Program.readyQueue.getRemainingSize());
}
Program.suspendedReadyQueue.getQueue().Remove(temp);
Console.WriteLine("argument was : " + (tempTotalSize >= Program.suspendedReadyQueue.getQueue().ElementAt(i).getSize()) + " total memory to be swapped : " + tempTotalSize + " this process size: " + temp.getSize() + "readyQueue remaining size: " + Program.readyQueue.getRemainingSize());
Program.readyQueue.addQueue(temp);
break;
}
}
}
}
}
}
}
}
