Example #1
0
        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**************************");
        }
Example #2
0
        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**************************");
        }