Esempio n. 1
0
 /// <summary>
 /// Reads a file containing processes to be executed and converts it to a list of processes
 /// </summary>
 /// <returns>a list of processes with two properties given in the file</returns>
 public List<ProcessElement> GetData()
 {
     string[] lines = File.ReadAllLines(FILENAME);
     string[] fields;
     string input;
     List<ProcessElement> processList = new List<ProcessElement> { };
     foreach (string line in lines) // parse each line in file
     {
         try
         {
             if (line != "" && !line.StartsWith("#")) // empty lines and comments are ignored
             {
                 ProcessElement process = new ProcessElement();
                 input = line.Trim();
                 input = Regex.Replace(input, @"\s+", " ");
                 fields = input.Split(' ');
                 process.ArriveTime = Convert.ToInt32(fields[0]); // the first number is the arrival time
                 process.ExeTime = Convert.ToInt32(fields[1]); // the second number is the service time
                 processList.Add(process);
             }
         }
         catch (FormatException e)
         {
             Console.WriteLine("Format error: " + e.Message);
         }
     }
     return processList;
 }
Esempio n. 2
0
 /// <summary>
 /// The method implements the shorted remain time scheduling algorithm. A process is preempted when
 /// the newly arrived process has shorter remaining service time. When a process is finished, the 
 /// processor then chooses the next process with the shortest remaining time
 /// </summary>
 /// <param name="processList">a list of processes to be executed</param>
 public void SRT_Schedule(List<ProcessElement> processList)
 {
     int totalWaitTime = 0; // keeps track of the total wait time of all jobs
     int totalTurnAroundTime = 0; // keeps track of he total turnaround time of all jobs
     double avgWaitTime = 0; // average wait time of all jobs
     double avgTurnAroundTime = 0; // average turnaround time of all jobs
     double wTDeviation = 0; // wait time standard deviation
     double taTDeviation = 0; // turnaround time standard deviation
     double sumOfWTSquares = 0; // temp values to use in calculating
     double sumOfTATSquares = 0; // the standard deviations
     int numOfJobs = processList.Count; // stores the number of job in the list
     int count = 0; // keeps track of how many processes have been completed
     int timer = 0; // keeps track of time
     ProcessElement current = new ProcessElement(); // process currently being
     ProcessElement next = new ProcessElement(); // the next process in the ready queue
     List<ProcessElement> waitlist = new List<ProcessElement> { };
     // if there is no process, exit the method
     if (processList.Count == 0)
     {
         logger.Log("There are no processes to be executed.");
         return;
     }
     // while there are incomplete processes
     while (count < processList.Count-1)
     {
         // get a sublist of processes that have arrived and uncompleted
         List<ProcessElement> sublist = processList.Where(p => (p.RemainTime > 0 && p.ArriveTime <= timer)).ToList();
         // if sublist is not empty
         if (sublist.Count != 0)
         {
             current = sublist.First(); // set the first element to be the current process
             // go through each process in the sublist
             foreach (ProcessElement p in sublist)
             {
                 // and find the process with the shorted remaining time
                 if (p.RemainTime < current.RemainTime)
                 {
                     current = p; // set that to be the next process executed
                     if (current.RemainTime == current.ExeTime)
                         current.WaitTime = timer - current.ArriveTime;
                 }
             }
             current.RemainTime--; // execute the process
             timer++; // update the timer
             current.TurnAroundTime = timer - current.ArriveTime; // update the turnaround time
             if (current.RemainTime == 0) // if the process is finished
             {
                 count++; // increment the count value
                 processList.ElementAt(current.JobNumber - 1).TurnAroundTime = current.TurnAroundTime;
                 // copy the turnaround time to the process list
             }
         }
         else
         {
             while (processList.ElementAt(count).ArriveTime > timer && count!=processList.Count-1)
                 timer++; // if no sublist is generated, increment the timer while waiting for a new process to arrive
         }
     }
     //logging data in file
     logger.Log("Shortest Remaining Time Algorithm\n");
     logger.DisableFileLogging();
     logger.Log("Data has been logged to file SRT.csv\n\n");
     logger.DisableConsoleLogging();
     logger.EnableFileLogging();
     logger.Log("Arrival Time,Wait Time,Turnaround Time,\n");
     try
     {
         foreach (ProcessElement p in processList)
         {
             //p.WaitTime = p.TurnAroundTime - p.ExeTime; // wait time is equal to the difference between the turnaround time and execution time
             logger.Log(p.ArriveTime.ToString() + "," + p.WaitTime.ToString() + "," + p.TurnAroundTime + ",\n");
             totalWaitTime += p.WaitTime;
             totalTurnAroundTime += p.TurnAroundTime;
         }
         // standard deviation = the square root of (the (the sum of the square of the difference between each item and the mean)/number of elements)
         avgWaitTime = (double)totalWaitTime / (double)numOfJobs; // calculate average wait time
         avgTurnAroundTime = (double)totalTurnAroundTime / (double)numOfJobs; // calculate average turnaround time
         foreach (ProcessElement p in processList)
         {
             sumOfWTSquares += Math.Pow(p.WaitTime - avgWaitTime, 2);
             sumOfTATSquares += Math.Pow(p.TurnAroundTime - avgTurnAroundTime, 2);
         }
         wTDeviation = Math.Sqrt(sumOfWTSquares / count);
         taTDeviation = Math.Sqrt(sumOfTATSquares / count);
         logger.Log("\n\nAvg WaitTime,Avg TurnaroundTime,Std Dev of WaitTime, Std Dev of TurnaroundTime,\n");
         logger.Log(avgWaitTime.ToString("f2") + "," + avgTurnAroundTime.ToString("f2") + "," + wTDeviation.ToString("f2") + "," + taTDeviation.ToString("f2") + ",\n");
     }
     catch (DivideByZeroException de)
     {
         logger.EnableConsoleLogging();
         logger.Log(de.Message);
     }
 }
Esempio n. 3
0
 // a method that schedules processes based on the order of their entries.
 // accept a process list
 // return nothing
 public void FCFS_Schedule(List<ProcessElement> processList)
 {
     int totalWaitTime = 0; // keeps track of the total wait time of all jobs
     int totalTurnAroundTime = 0; // keeps track of he total turnaround time of all jobs
     double avgWaitTime = 0; // average wait time of all jobs
     double avgTurnAroundTime = 0; // average turnaround time of all jobs
     double wTDeviation = 0; // wait time standard deviation
     double taTDeviation = 0; // turnaround time standard deviation
     double sumOfWTSquares = 0; // temp values to use in calculating
     double sumOfTATSquares = 0; // the standard deviations
     int numOfJobs = processList.Count; // stores the number of job in the list
     int count = 0; // index variable
     int timer = 0; // a variable to keep track of time
     if (processList.Count == 0)
     {
         logger.Log("There are no processes to be executed.");
         return;
     }
     // for each element in processList, calculate its data
     while (count < processList.Count)
     {
         process = processList.ElementAt(count); // each of the element in the list
         while (timer < process.ArriveTime) // if the process has not yet arrive, wait till it arrives
             timer++;
         timer += process.ExeTime; // update the timer after the execution of the process
         process.TurnAroundTime = timer - process.ArriveTime; // each process's turnaround time equals exe time + wait time
         count++; // increment the index variable to get the next process
     }
     // logging data to file
     logger.Log("First Come First Served Algorithm\n");
     logger.DisableFileLogging();
     logger.Log("Data has been logged to file RoundRobin.csv\n\n");
     logger.DisableConsoleLogging();
     logger.EnableFileLogging();
     logger.Log("Arrival Time,Wait Time,Turnaround Time,\n");
     try
     {
         foreach (ProcessElement p in processList)
         {
             p.WaitTime = p.TurnAroundTime - p.ExeTime; // wait time is equal to the difference between the turnaround time and execution time
             logger.Log(p.ArriveTime.ToString() + "," + p.WaitTime.ToString() + "," + p.TurnAroundTime + ",\n");
             totalWaitTime += p.WaitTime;
             totalTurnAroundTime += p.TurnAroundTime;
         }
         // standard deviation = the square root of (the (the sum of the square of the difference between each item and the mean)/number of elements)
         avgWaitTime = (double)totalWaitTime / (double)numOfJobs; // calculate average wait time
         avgTurnAroundTime = (double)totalTurnAroundTime / (double)numOfJobs; // calculate average turnaround time
         foreach (ProcessElement p in processList)
         {
             sumOfWTSquares += Math.Pow(p.WaitTime - avgWaitTime, 2);
             sumOfTATSquares += Math.Pow(p.TurnAroundTime - avgTurnAroundTime, 2);
         }
         wTDeviation = Math.Sqrt(sumOfWTSquares / count);
         taTDeviation = Math.Sqrt(sumOfTATSquares / count);
         logger.Log("\n\nAvg WaitTime,Avg TurnaroundTime,Std Dev of WaitTime, Std Dev of TurnaroundTime,\n");
         logger.Log(avgWaitTime.ToString("f2") + "," + avgTurnAroundTime.ToString("f2") + "," + wTDeviation.ToString("f2") + "," + taTDeviation.ToString("f2") + ",\n");
     }
     // catch any error caused by dividing 0
     catch (DivideByZeroException de)
     {
         logger.EnableConsoleLogging();
         logger.Log(de.Message);
     }
 }
Esempio n. 4
0
 /// <summary>
 /// This method is an implementation of the shorted process next scheduling algorithm.
 /// It executes the ready process with the shorted processing time first without preempting it.
 /// </summary>
 /// <param name="processList">A list of processes to be executed</param>
 public void SPN_Schedule(List<ProcessElement> processList)
 {
     int totalWaitTime = 0; // keeps track of the total wait time of all jobs
     int totalTurnAroundTime = 0; // keeps track of he total turnaround time of all jobs
     double avgWaitTime = 0; // average wait time of all jobs
     double avgTurnAroundTime = 0; // average turnaround time of all jobs
     double wTDeviation = 0; // wait time standard deviation
     double taTDeviation = 0; // turnaround time standard deviation
     double sumOfWTSquares = 0; // temp values to use in calculating
     double sumOfTATSquares = 0; // the standard deviations
     int numOfJobs = processList.Count; // stores the number of job in the list
     int count = 0; // keeps track of how many processes have been executed
     int timer = 0; // keeps track of time
     int minExeTime = 0; // stores the shorted processing time
     ProcessElement current = new ProcessElement(); // process currently being executed
     // if there is no process, exit the method
     if (processList.Count == 0)
     {
         logger.Log("There are no processes to be executed.");
         return;
     }
     current = processList.First(); // otherwise, set the first process in the list to current
     // if current process has not arrived yet, increment the timer until it arrives.
     while (current.ArriveTime > timer)
         timer++;
     // while there are still processes in the process list
     while (count < processList.Count-1)
     {
         // if current process is incomplete
         if (current.RemainTime != 0)
         {
             count++; // increment the count value
             timer += current.ExeTime; // update the timer
             current.RemainTime -= current.ExeTime; // execute the program
             current.TurnAroundTime = timer - current.ArriveTime; // update its turnaround time
             processList.ElementAt(current.JobNumber - 1).TurnAroundTime = current.TurnAroundTime;
             //copy the TAT info back into the processList
         }
         // query for a sublist that contains the ready processes that are to be executed
         List<ProcessElement> sublist = processList.Where(p => (p.RemainTime > 0 && p.ArriveTime <= timer)).ToList();
         // if sublist is not empty
         if (sublist.Count != 0)
         {
             minExeTime = sublist.First().ExeTime; // set the minimum service time to the first element in the sublist
             current = sublist.First(); // set current process to the first element in the sublist
             // go through each process in the sublist
             for (int i = 0; i < sublist.Count; i++)
             {
                 // find the process with the shortest processing time and set that to the next process to be executed
                 if (minExeTime > sublist.ElementAt(i).ExeTime)
                 {
                     minExeTime = sublist.ElementAt(i).ExeTime;
                     current = sublist.ElementAt(i);
                 }
             }
         }
         else // if no sublist is found, increment the timer until a new process arrives
         {
             while (processList.ElementAt(count).ArriveTime > timer)
                 timer++;
         }
     }
     //logging data in file
     logger.Log("Shortest Process Next Algorithm\n");
     logger.DisableFileLogging();
     logger.Log("Data has been logged to file SPN.csv\n\n");
     logger.DisableConsoleLogging();
     logger.EnableFileLogging();
     logger.Log("Arrival Time,Wait Time,Turnaround Time,\n");
     try
     {
         foreach (ProcessElement p in processList)
         {
             p.WaitTime = p.TurnAroundTime - p.ExeTime; // wait time is equal to the difference between the turnaround time and execution time
             logger.Log(p.ArriveTime.ToString() + "," + p.WaitTime.ToString() + "," + p.TurnAroundTime + ",\n");
             totalWaitTime += p.WaitTime;
             totalTurnAroundTime += p.TurnAroundTime;
         }
         // standard deviation = the square root of (the (the sum of the square of the difference between each item and the mean)/number of elements)
         avgWaitTime = (double)totalWaitTime / (double)numOfJobs; // calculate average wait time
         avgTurnAroundTime = (double)totalTurnAroundTime / (double)numOfJobs; // calculate average turnaround time
         foreach (ProcessElement p in processList)
         {
             sumOfWTSquares += Math.Pow(p.WaitTime - avgWaitTime, 2);
             sumOfTATSquares += Math.Pow(p.TurnAroundTime - avgTurnAroundTime, 2);
         }
         wTDeviation = Math.Sqrt(sumOfWTSquares / count);
         taTDeviation = Math.Sqrt(sumOfTATSquares / count);
         logger.Log("\n\nAvg WaitTime,Avg TurnaroundTime,Std Dev of WaitTime, Std Dev of TurnaroundTime,\n");
         logger.Log(avgWaitTime.ToString("f2") + "," + avgTurnAroundTime.ToString("f2") + "," + wTDeviation.ToString("f2") + "," + taTDeviation.ToString("f2") + ",\n");
     }
     catch (DivideByZeroException de)
     {
         logger.EnableConsoleLogging();
         logger.Log(de.Message);
     }
 }
Esempio n. 5
0
        ProcessElement process = new ProcessElement(); // instantiate a ProcessElement

        #endregion Fields

        #region Methods

        /// <summary>
        /// This method implements the round robin scheduling technique. Each process is given a quantum
        /// to execute and is put into a ready stack when a new process arrives
        /// </summary>
        /// <param name="processList">List of processes to be executed</param>
        public void RoundRobin_Schedule(List<ProcessElement> processList)
        {
            Queue<ProcessElement> readyQueue = new Queue<ProcessElement> { };// a list of processes preempted
            ProcessElement current = new ProcessElement(); // process currently being executed
            ProcessElement next = new ProcessElement(); // the next process in the ready queue
            const int QUANTUM = 4; // time slice given each process to execute being preempted
            int numOfJobs = processList.Count; // number of jobs in the ready queue
            int count = 0; // an index to refer to the job in the list
            int timer = 0; // keeps track of time
            int timeAllocated = 0; // time allocated for each process
            int totalWaitTime = 0; // keeps track of the total wait time of all jobs
            int totalTurnAroundTime = 0; // keeps track of he total turnaround time of all jobs
            double avgWaitTime = 0; // average wait time of all jobs
            double avgTurnAroundTime = 0; // average turnaround time of all jobs
            double wTDeviation = 0; // wait time standard deviation
            double taTDeviation = 0; // turnaround time standard deviation
            double sumOfWTSquares = 0; // temp values to use in calculating
            double sumOfTATSquares = 0; // the standard deviations
            // initially, each process's remaining time is its service time

            foreach (ProcessElement p in processList)
                p.RemainTime = p.ExeTime;
            current = processList.ElementAt(count); // set the first job to be the current executing job
            // if there are jobs in the processList
            if (processList.Count != 0) // put the first job in the readyQueue
                readyQueue.Enqueue(processList.First());
            else // otherwise program terminates
            {
                logger.Log("There are no processes to be executed.");
                return;
            }
            // when there are still processes in the ready queue
            while (current.ArriveTime > timer) // if the first process has not arrived, increment the timer
                timer++;    // until it arrives
            while (readyQueue.Count != 0)
            {
                // if the process has not arrived yet, wait until it arrives
                current = readyQueue.Dequeue(); // select the first process in the queue to execute
                if (current.ExeTime == current.RemainTime)
                    processList.ElementAt(current.JobNumber - 1).WaitTime = timer - current.ArriveTime;
                // when a process arrives and it has not finished executing
                if (current.RemainTime > 0 && current.RemainTime <= QUANTUM)
                {
                    timeAllocated = current.RemainTime; // time allocated is its remain time
                    current.RemainTime -= timeAllocated; // execute the job
                }
                else
                {
                    timeAllocated = QUANTUM; // otherwise, time allocated is the quantum specified
                    current.RemainTime -= timeAllocated; // execute the job
                }
                timer += timeAllocated; // update the timer
                timeAllocated = 0; //reset the time that's been allocated
                current.TurnAroundTime = timer - current.ArriveTime; // update current process's turnaround time
                // if there are other incomplete processes in the ready queue, update their TAT
                if (readyQueue.Count != 0)
                {
                    foreach (ProcessElement p in readyQueue)
                    {
                        if (p.RemainTime != 0)
                            p.TurnAroundTime = timer - p.ArriveTime;
                    }
                }
                // if the current process is completed, copy its TAT to the process list
                if (current.RemainTime == 0)
                {
                    processList.ElementAt(current.JobNumber - 1).TurnAroundTime = current.TurnAroundTime;
                }
                // when there are still processes expected, go through each expected process
                // and find the processes that have arrived
                for (int i = count; i < numOfJobs; ++i)
                {
                    if (count < numOfJobs - 1)
                    {
                        count++; // increment the count value
                        next = processList.ElementAt(count); // set next to the next process in the list
                        // if the job arrives and its remain time is not 0
                        if (timer >= next.ArriveTime && next.RemainTime != 0)
                        {
                            readyQueue.Enqueue(next); // add it to the ready queue

                        }
                        else
                            count--; // otherwise, restore the count value
                        if (next.ExeTime == 0) // if the process does not take any time to execute, move on
                            count++;
                    }
                }
                // if current process is not finished, add it back to the ready queue
                if (current.RemainTime != 0)
                    readyQueue.Enqueue(current);
            }
            //logging data in file

            logger.Log("Round-Robin Algorithm\n");
            logger.DisableFileLogging();
            logger.Log("Data has been logged to file RoundRobin.csv\n\n");
            logger.DisableConsoleLogging();
            logger.EnableFileLogging();
            logger.Log("Arrival Time,Wait Time,Turnaround Time,\n");
            try
            {
                foreach (ProcessElement p in processList)
                {
                    //p.WaitTime = p.TurnAroundTime - p.ExeTime; // wait time is equal to the difference between the turnaround time and execution time
                    logger.Log(p.ArriveTime.ToString() + "," + p.WaitTime.ToString() + "," + p.TurnAroundTime + ",\n");
                    totalWaitTime += p.WaitTime;
                    totalTurnAroundTime += p.TurnAroundTime;
                }
                // standard deviation = the square root of (the (the sum of the square of the difference between each item and the mean)/number of elements)
                avgWaitTime = (double)totalWaitTime / (double)numOfJobs; // calculate average wait time
                avgTurnAroundTime = (double)totalTurnAroundTime / (double)numOfJobs; // calculate average turnaround time
                foreach (ProcessElement p in processList)
                {
                    sumOfWTSquares += Math.Pow(p.WaitTime - avgWaitTime, 2);
                    sumOfTATSquares += Math.Pow(p.TurnAroundTime - avgTurnAroundTime, 2);
                }
                wTDeviation = Math.Sqrt(sumOfWTSquares / count);
                taTDeviation = Math.Sqrt(sumOfTATSquares / count);
                logger.Log("\n\nAvg WaitTime,Avg TurnaroundTime,Std Dev of WaitTime, Std Dev of TurnaroundTime,\n");
                logger.Log(avgWaitTime.ToString("f2") + "," + avgTurnAroundTime.ToString("f2") + "," + wTDeviation.ToString("f2") + "," + taTDeviation.ToString("f2") + ",\n");
            }
            catch (DivideByZeroException de)
            {
                logger.EnableConsoleLogging();
                logger.Log(de.Message);
            }
        }