public SchedulerBase(List<Process> p)
{
ProcessList = p;
ReadyQueue = new Queue<Process>(p);
ProcessesInIO = new List<Process>();
processInCPU = new Process();
CPUOrder = new List<Process>();
timer = 0;
}
public FCFS(ProcessList processList, StreamWriter output)
{
Ready_Queue = new Queue<Process>();
foreach (Process item in processList.processes) {
Ready_Queue.Enqueue (item);
}
IO_Queue = new Queue<Process>();
RunningJob = new Process (-1,0,0,0,0);
IO_Job = new Process (-1, 0, 0, 0,0);
Final_List = new Queue<Process> ();
//StreamWriter output = new StreamWriter ("../../output.txt");
simulate (10, output);
}
public Process clone()
{
Process temp = new Process();
temp.pid = this.pid;
temp.CPU_burst1 = this.CPU_burst1;
temp.CPU_burst2 = this.CPU_burst2;
temp.IO_burst = this.IO_burst;
temp.priority = this.priority;
temp.period = this.period;
temp.activePeriod = this.period;
return temp;
}
public SJF(ProcessList processList, StreamWriter output)
{
Ready_Queue = new Queue<Process>();
PreSortedList = processList.processes.ToList ();
PreSortedList.Sort ((p,q) => (p.getCPU_burst1 ()+p.getCPU_burst2 ()).CompareTo ((q.getCPU_burst1 ()+q.getCPU_burst2 ())));
foreach (Process item in PreSortedList) {
Ready_Queue.Enqueue (item);
}
IO_Queue = new Queue<Process>();
RunningJob = new Process (-1,0,0,0,0);
IO_Job = new Process (-1, 0, 0, 0,0);
Final_List = new List<Process> ();
//StreamWriter output = new StreamWriter ("../../output.txt");
simulate (10, output);
}
public Priority(ProcessList processList, StreamWriter output)
{
PreSortedList = processList.processes.ToList ();
PreSortedList.Sort ((p,q) => p.getPriority ().CompareTo (q.getPriority ()));
Ready_Queue = new Queue<Process>();
foreach (Process item in PreSortedList) {
Ready_Queue.Enqueue (item);
}
Temp_Job = new Process (0,0,0,0,0);
IO_Queue = new Queue<Process>();
RunningJob = new Process (-1,0,0,0,0);
IO_Job = new Process (-1, 0, 0, 0,0);
Final_List = new List<Process> ();
simulate (10, output);
}
public override void simulate(int snapshot, StreamWriter pa)
{
// TODO Auto-generated method stub
pa.WriteLine ("**************************************RR STARTED**************************");
quantum = RRprocessList.getQuantum();
//add all processes to queue
foreach (Process process in RRprocessList.processes) {
ReadyQueue.Enqueue(process);
//pa.WriteLine (process.getCPU_burst1 ());
}
//initialize currents
currentProcess = ReadyQueue.Dequeue ();
currentIO = new Process(-1,-1,-1,-1,-1);
//main RR while loop
while (ReadyQueue.Count > 0) {
//quantum for loop
for (int i = 0; i < quantum; i++) {
//cpu processing
//pa.WriteLine (currentProcess.getPID ());
foreach (Process p in ReadyQueue) {
p.period++;
}
if (currentProcess.getCPU_burst1 () > 0) {
currentProcess.decrementCPUBurst1 ();
} else if (currentProcess.getCPU_burst1 () == 0 && currentProcess.getIO_burst () > 0) {
IOQueue.Enqueue (currentProcess);
break;
} else if (currentProcess.getCPU_burst1 () == 0 && currentProcess.getIO_burst () == 0 && currentProcess.getCPU_burst2 () > 0) {
currentProcess.decrementCPUBurst2 ();
} else {
break;
}
currentProcess.activePeriod++;
//io processing
if (currentIO.getIO_burst () > 0) {
currentIO.decrementIO_burst ();
} else if (currentIO.getIO_burst () == 0) {
ReadyQueue.Enqueue (currentIO);
if (IOQueue.Count > 0) {
currentIO = IOQueue.Dequeue ();
} else {
currentIO = new Process (-1, -1, -1, -1, -1);
}
} else {
if (IOQueue.Count > 0) {
currentIO = IOQueue.Dequeue ();
}
}
//increment time
time++;
//POKEMON SNAP
if (time % snapshot == 0) {
pa.WriteLine ("Taking Snap at time: " + time);
this.snapshot (pa);
}
}
if (currentProcess.getCPU_burst1 () > 0 || (currentProcess.getCPU_burst2 () > 0 && currentProcess.getIO_burst () == 0)) {
ReadyQueue.Enqueue (currentProcess);
} else if (currentProcess.getCPU_burst1 () == 0 && currentProcess.getIO_burst () > 0 && !IOQueue.Contains(currentProcess)){
IOQueue.Enqueue (currentProcess);
//pa.WriteLine ("into IO2:"+ currentProcess.getPID ());
} else if(currentProcess.getCPU_burst1 () == 0 && currentProcess.getCPU_burst2() == 0 && currentProcess.getIO_burst() == 0){
currentProcess.activePeriod--;
Final_List.Add (currentProcess);
}
if (ReadyQueue.Count>0) currentProcess = ReadyQueue.Dequeue ();
}
Final_List.Add(currentProcess); foreach (Process item in Final_List) item.period--; time += 10;
finalReport (pa);
pa.WriteLine ("**************************************RR ENDED**************************");
}
public override void simulate(int snapshot, StreamWriter pa)
{
int i;
List<Process> TempList = new List<Process> ();
pa.WriteLine ("**************************************PRIORITY STARTED**************************");
foreach (Process item in Ready_Queue) {
item.period = 0;
item.activePeriod = 0;
}
while ((Ready_Queue.Count != 0 || IO_Queue.Count != 0) || (RunningJob.getCPU_burst1 () > 0 || RunningJob.getCPU_burst2 () > 0)||(IO_Job.getIO_burst()>0)) {
//Get the running job
if (RunningJob.getPID () == -1) {
//OH GEEZ RICK, Were on the fist iteration
RunningJob = Ready_Queue.Dequeue ();
}
//RUNNING JOB LOGIC START
if (RunningJob.getCPU_burst1 () == 1) {
IO_Queue.Enqueue (RunningJob);
if (Ready_Queue.Count != 0) {
RunningJob.activePeriod++;
RunningJob = Ready_Queue.Dequeue ();
RunningJob.period++;
}
} else if (RunningJob.getCPU_burst1 () < 1) {
if (RunningJob.getCPU_burst2 () != 0) {
RunningJob.decrementCPUBurst2 ();
RunningJob.activePeriod++;
} else {
if (Ready_Queue.Count != 0) {
Final_List.Add (RunningJob);
RunningJob = Ready_Queue.Dequeue ();
}
}
} else if (RunningJob.getCPU_burst1 () > 1) {
RunningJob.decrementCPUBurst1 ();
RunningJob.activePeriod++;
}
//RUNNING JOB LOGIC END
//IO JOB LOGIC START
if (IO_Job.getPID () == -1) {
if (IO_Queue.Count != 0) {
IO_Job = IO_Queue.Dequeue ();
}
} else {
if (IO_Job.getIO_burst () <= 1) {
IO_Job.decrementCPUBurst1 ();
Ready_Queue.Enqueue (IO_Job);
if (IO_Queue.Count != 0) {
IO_Job = IO_Queue.Dequeue ();
} else {
IO_Job = new Process (-1, 0, 0, 0, 0);
}
} else {
IO_Job.decrementCPUBurst1 ();//Cuz F**K U
IO_Job.decrementIO_burst ();
//IO_Job.period++;
}
}
//IO JOB LOGIC END
//Count waiting time
foreach (Process item in Ready_Queue) {
if (item.getPID () <= time) {
item.period++;
}
}
foreach (Process item in IO_Queue) {
//item.period++;
}
//End waiting time count
time++;
//POKEMON SNAP
if (time % snapshot == 0) {
pa.WriteLine ("Taking Snap at time: " + time);
this.snapshot (pa);
}
TempList.Clear ();
PreSortedList.Clear ();
foreach (Process item in Ready_Queue) {
PreSortedList.Add (item);
TempList.Add (item);
}
i = PreSortedList.Count - 1;
foreach (Process item in PreSortedList) {
if ((item.getPriority () < RunningJob.getPriority ()) ) {
Temp_Job = RunningJob;
RunningJob = item;
TempList.Remove (item);
TempList.Add (Temp_Job);
}
i--;
}
PreSortedList.Clear ();
foreach (Process item in TempList) {
PreSortedList.Add (item);
}
Ready_Queue.Clear ();
PreSortedList.Sort ((p,q) => p.getPriority ().CompareTo (q.getPriority ()));
foreach (Process item in PreSortedList) {
Ready_Queue.Enqueue (item);
}
}
Final_List.Add (RunningJob); foreach (Process item in Final_List) item.period--;
finalReport (pa);
pa.WriteLine ("**************************************PRIORITYENDED**************************");
}
public override void simulate(int snapshot, StreamWriter pa)
{
pa.WriteLine ("**************************************FCFS STARTED**************************");
foreach (Process item in Ready_Queue) {
item.period = 0;
item.activePeriod = 0;
}
while ((Ready_Queue.Count != 0 || IO_Queue.Count != 0) || (RunningJob.getCPU_burst1 () > 0 || RunningJob.getCPU_burst2 () > 0)||(IO_Job.getIO_burst()>0)) {
//Get the running job
if (RunningJob.getPID () == -1) {
//OH GEEZ RICK, Were on the fist iteration
RunningJob = Ready_Queue.Dequeue ();
}
//RUNNING JOB LOGIC START
if (RunningJob.getCPU_burst1 () == 1) {
IO_Queue.Enqueue (RunningJob);
if (Ready_Queue.Count != 0) {
RunningJob.activePeriod++;
RunningJob = Ready_Queue.Dequeue ();
RunningJob.period++;
}
} else if (RunningJob.getCPU_burst1 () < 1) {
if (RunningJob.getCPU_burst2 () != 0) {
RunningJob.decrementCPUBurst2 ();
RunningJob.activePeriod++;
} else {
if (Ready_Queue.Count != 0) {
Final_List.Enqueue (RunningJob);
RunningJob = Ready_Queue.Dequeue ();
}
}
} else if (RunningJob.getCPU_burst1 () > 1) {
RunningJob.decrementCPUBurst1 ();
RunningJob.activePeriod++;
}
//RUNNING JOB LOGIC END
//IO JOB LOGIC START
if (IO_Job.getPID () == -1) {
if (IO_Queue.Count != 0) {
IO_Job = IO_Queue.Dequeue ();
}
} else {
if (IO_Job.getIO_burst () <= 1) {
IO_Job.decrementCPUBurst1 ();
Ready_Queue.Enqueue (IO_Job);
if (IO_Queue.Count != 0) {
IO_Job = IO_Queue.Dequeue ();
} else {
IO_Job = new Process (-1, 0, 0, 0, 0);
}
} else {
IO_Job.decrementCPUBurst1 ();//Cuz F**K U
IO_Job.decrementIO_burst ();
//IO_Job.period++;
}
}
//IO JOB LOGIC END
//Count waiting time
foreach (Process item in Ready_Queue) {
if (item.getPID () <= time) {
item.period++;
}
}
foreach (Process item in IO_Queue) {
//item.period++;
}
//End waiting time count
time++;
//POKEMON SNAP
if (time % snapshot == 0) {
pa.WriteLine ("Taking Snap at time: " + time);
this.snapshot (pa);
}
}
Final_List.Enqueue (RunningJob); foreach (Process item in Final_List) item.period--;
finalReport (pa);
pa.WriteLine ("**************************************FCFS ENDED**************************");
}
public override void simulate(int snapshot, StreamWriter pa)
{
// TODO Auto-generated method stub
pa.WriteLine("**************************************MFQ STARTED**************************");
//quantum = 1;//RRprocessList.getQuantum();
//add all processes to queue
foreach (Process process in RRprocessList.processes)
{
ReadyQueue1.Enqueue(process);
//pa.WriteLine (process.getCPU_burst1 ());
}
//initialize currents
ReadyQueue1.Enqueue(new Process(-1, -1, -1, -1, -1));//dummy value, will check for this later
currentProcess = ReadyQueue1.Dequeue();
currentIO = new Process(-1, -1, -1, -1, -1);
//main RR while loop
while (ReadyQueue1.Count > 0)
{
if (currentProcess.getPID() == -1)
{
ReadyQueue2.Enqueue(currentProcess);
currentProcess = ReadyQueue2.Dequeue();
continue;
}
//quantum for loop
for (int i = 0; i < (quantum = 3); i++)
{
time++;
//cpu processing
//pa.WriteLine (currentProcess.getPID ());
foreach (Process p in ReadyQueue2)
{
p.period++;
}
if (currentProcess.getCPU_burst1() > 0)
{
currentProcess.decrementCPUBurst1();
}
else if (currentProcess.getCPU_burst1() == 0 && currentProcess.getIO_burst() > 0)
{
IOQueue.Enqueue(currentProcess);
break;
}
else if (currentProcess.getCPU_burst1() == 0 && currentProcess.getIO_burst() == 0 && currentProcess.getCPU_burst2() > 0)
{
currentProcess.decrementCPUBurst2();
}
else
{
break;
}
currentProcess.activePeriod++;
//io processing
if (currentIO.getIO_burst() > 0)
{
currentIO.decrementIO_burst();
}
else if (currentIO.getIO_burst() == 0)
{
ReadyQueue2.Enqueue(currentIO);
if (IOQueue.Count > 0)
{
currentIO = IOQueue.Dequeue();
}
else
{
currentIO = new Process(-1, -1, -1, -1, -1);
}
}
else
{
if (IOQueue.Count > 0)
{
currentIO = IOQueue.Dequeue();
}
}
//increment time
//POKEMON SNAP
if (time % snapshot == 0)
{
pa.WriteLine("Taking Snap at time: " + time);
ReadyQueue = ReadyQueue1;
this.snapshot(pa);
pa.WriteLine("queue2");
ReadyQueue = ReadyQueue2;
this.snapshot(pa);
}
}
if (currentProcess.getCPU_burst1() > 0 || (currentProcess.getCPU_burst2() > 0 && currentProcess.getIO_burst() == 0))
{
ReadyQueue2.Enqueue(currentProcess);
}
else if (currentProcess.getCPU_burst1() == 0 && currentProcess.getIO_burst() > 0 && !IOQueue.Contains(currentProcess))
{
IOQueue.Enqueue(currentProcess);
}
else if (currentProcess.getCPU_burst1() == 0 && currentProcess.getCPU_burst2() == 0 && currentProcess.getIO_burst() == 0)
{
currentProcess.activePeriod-=2;
Final_List.Add(currentProcess);
}
if (ReadyQueue1.Count > 0) currentProcess = ReadyQueue1.Dequeue();
}
/////////////////////////////////////////////////////////////////////////////////
////////start of queue 2/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
if (ReadyQueue2.Count > 0) currentProcess = ReadyQueue2.Dequeue();
while (ReadyQueue2.Count > 0)
{
time++;
if (currentProcess.getPID() == -1)
{
ReadyQueue3.Enqueue(currentProcess);
currentProcess = ReadyQueue3.Dequeue();
break;
}
//quantum for loop
for (int i = 0; i < (quantum = 8); i++)
{
//cpu processing
//pa.WriteLine (currentProcess.getPID ());
foreach (Process p in ReadyQueue2)
{
p.period++;
}
if (currentProcess.getCPU_burst1() > 0)
{
currentProcess.decrementCPUBurst1();
}
else if (currentProcess.getCPU_burst1() == 0 && currentProcess.getIO_burst() > 0)
{
IOQueue.Enqueue(currentProcess);
//pa.WriteLine ("into IO:"+ currentProcess.getPID ());
break;
}
else if (currentProcess.getCPU_burst1() == 0 && currentProcess.getIO_burst() == 0 && currentProcess.getCPU_burst2() > 0)
{
currentProcess.decrementCPUBurst2();
}
else
{
//Final_List.Enqueue (currentProcess);
break;
}
currentProcess.activePeriod++;
//io processing
if (currentIO.getIO_burst() > 0)
{
currentIO.decrementIO_burst();
}
else if (currentIO.getIO_burst() == 0)
{
ReadyQueue3.Enqueue(currentIO);
if (IOQueue.Count > 0)
{
currentIO = IOQueue.Dequeue();
}
else
{
currentIO = new Process(-1, -1, -1, -1, -1);
}
}
else
{
if (IOQueue.Count > 0)
{
currentIO = IOQueue.Dequeue();
}
}
//increment time
//POKEMON SNAP
if (time % snapshot == 0)
{
pa.WriteLine("Taking Snap at time: " + time);
ReadyQueue = ReadyQueue1;
this.snapshot(pa);
}
}
if (currentProcess.getCPU_burst1() > 0 || (currentProcess.getCPU_burst2() > 0 && currentProcess.getIO_burst() == 0))
{
ReadyQueue3.Enqueue(currentProcess);
}
else if (currentProcess.getCPU_burst1() == 0 && currentProcess.getIO_burst() > 0 && !IOQueue.Contains(currentProcess))
{
IOQueue.Enqueue(currentProcess);
//pa.WriteLine ("into IO2:"+ currentProcess.getPID ());
}
else if (currentProcess.getCPU_burst1() == 0 && currentProcess.getCPU_burst2() == 0 && currentProcess.getIO_burst() == 0)
{
currentProcess.activePeriod-=2;
Final_List.Add(currentProcess);
}
if (ReadyQueue2.Count > 0) currentProcess = ReadyQueue2.Dequeue();
}
/////////////////////////////////////////////////////////////////////////////////
////////start of queue 3/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
while ((ReadyQueue3.Count != 0 || IOQueue.Count != 0) || (currentProcess.getCPU_burst1() > 0 || currentProcess.getCPU_burst2() > 0) || (currentIO.getIO_burst() > 0))
{
time++;
//Get the running job
if (currentProcess.getPID() == -1)
{
//OH GEEZ RICK, Were on the fist iteration
currentProcess = ReadyQueue3.Dequeue();
}
//RUNNING JOB LOGIC START
if (currentProcess.getCPU_burst1() == 1)
{
IOQueue.Enqueue(currentProcess);
if (ReadyQueue3.Count != 0)
{
currentProcess.activePeriod++;
currentProcess = ReadyQueue3.Dequeue();
currentProcess.period++;
}
}
else if (currentProcess.getCPU_burst1() < 1)
{
if (currentProcess.getCPU_burst2() != 0)
{
currentProcess.decrementCPUBurst2();
currentProcess.activePeriod++;
}
else
{
if (ReadyQueue3.Count != 0)
{
Final_List.Add(currentProcess);
currentProcess = ReadyQueue3.Dequeue();
}
}
}
else if (currentProcess.getCPU_burst1() > 1)
{
currentProcess.decrementCPUBurst1();
currentProcess.activePeriod++;
}
//RUNNING JOB LOGIC END
//IO JOB LOGIC START
if (currentIO.getPID() == -1)
{
if (IOQueue.Count != 0)
{
currentIO = IOQueue.Dequeue();
}
}
else
{
if (currentIO.getIO_burst() <= 1)
{
currentIO.decrementCPUBurst1();
ReadyQueue3.Enqueue(currentIO);
if (IOQueue.Count != 0)
{
currentIO = IOQueue.Dequeue();
}
else
{
currentIO = new Process(-1, 0, 0, 0, 0);
}
}
else
{
currentIO.decrementCPUBurst1();//Cuz F**K U
currentIO.decrementIO_burst();
//currentIO.period++;
}
}
//IO JOB LOGIC END
//Count waiting time
foreach (Process item in ReadyQueue3)
{
if (item.getPID() <= time)
{
item.period++;
}
}
foreach (Process item in IOQueue)
{
//item.period++;
}
//End waiting time count
//POKEMON SNAP
if (time % snapshot == 0)
{
pa.WriteLine("Taking Snap at time: " + time);
ReadyQueue = ReadyQueue3;
this.snapshot(pa);
}
}
Final_List.Add(currentProcess);
foreach (Process item in Final_List) { item.period--; item.activePeriod--; }
finalReport(pa);
pa.WriteLine("**************************************MFQ ENDED**************************");
}
