public override void Schedule(SimulatorModel simulator)
{
int sigmaBurstTime = 0;
int[] compTime = new int[simulator.NumProcBigThanZero];
int[] waitingTime = new int[simulator.NumProcBigThanZero];
waitingTime[0] = 0;
//sort in ascending order
Array.Sort(simulator.ProcessArrivingTime, (x, y) => x.Item1.CompareTo(y.Item1));
// calculating waiting time
for (int i = 0; i < simulator.NumProcBigThanZero; i++)
{
sigmaBurstTime += simulator.ProcessArrivingTime[i].Item2;
compTime[i] = simulator.ProcessArrivingTime[0].Item1 + sigmaBurstTime;
if (i > 0)
{
// Add burst time of previous processes
// Find waiting time for current process
waitingTime[i] = compTime[i - 1] - simulator.ProcessArrivingTime[i].Item1;
// If waiting time for a process is negative
// that means the process does not wait at all
if (waitingTime[i] < 0)
{
waitingTime[i] = 0;
}
}
turnAroundTime += simulator.ProcessArrivingTime[i].Item2 + waitingTime[i];
}
this.PrintResult("FCFS", turnAroundTime, simulator.NumProc);
}
public override void Schedule(SimulatorModel simulator)
{
// sort all the proceeses
Array.Sort(simulator.ProcessArrivingTime, (x, y) => x.Item1.CompareTo(y.Item1));
//array initialize
int[] restBurstTime = new int[simulator.NumProcBigThanZero];
//var's init
int currentTime = simulator.ProcessArrivingTime[0].Item1;
const int timeQuantom = 2;
int activeProcesses = simulator.NumProcBigThanZero;
bool isProcessFinished = false;
for (int i = 0; i < simulator.NumProcBigThanZero; i++)
{
restBurstTime[i] = simulator.ProcessArrivingTime[i].Item2;
}
for (int i = 0; activeProcesses > 0;)
{
if (restBurstTime[i] <= timeQuantom && restBurstTime[i] > 0)
{
currentTime += restBurstTime[i];
restBurstTime[i] = 0;
isProcessFinished = true;
}
else if (restBurstTime[i] > 0)
{
restBurstTime[i] = restBurstTime[i] - timeQuantom;
currentTime = currentTime + timeQuantom;
}
if (restBurstTime[i] == 0 && isProcessFinished)
{
activeProcesses--;
turnAroundTime += currentTime - simulator.ProcessArrivingTime[i].Item1;
isProcessFinished = false;
}
//end of the cycle
if (i == simulator.NumProcBigThanZero - 1)
{
i = 0;
}
else if (simulator.ProcessArrivingTime[i + 1].Item1 <= currentTime) //continue to next process if arrived
{
i++;
}
else //back to the beginning if new process ain't arrived
{
currentTime++;
i = 0;
}
}
this.PrintResult("Round Robin", turnAroundTime, simulator.NumProc);
}
static void Main(string[] args)
{
if (!Validations.IsRightNumberOfArguments(args.Length))
{
return;
}
StreamReader InputFile;
if (!Validations.IsFileExists(out InputFile, args[0]))
{
return;
}
if (InputFile == null)
{
return;
}
//Read the first line, that should present the number of processes in the input file
string firstLine = InputFile.ReadLine();
int amountOfProcesses = int.Parse(firstLine);
List <Tuple <int, int> > ProcessArrivingTime = new List <Tuple <int, int> >();
//Read all the lines with the details of the processes
string readLine;
string[] processesArgs = new string[2];
for (int i = 0; i < amountOfProcesses; i++)
{
readLine = InputFile.ReadLine();
processesArgs = readLine.Split(',');
if (int.Parse(processesArgs[1]) == 0)
{
continue;
}
ProcessArrivingTime.Add(new Tuple <int, int>(int.Parse(processesArgs[0]), int.Parse(processesArgs[1])));
}
SimulatorModel simulatorModel = new SimulatorModel(ProcessArrivingTime.Count, ProcessArrivingTime.ToArray(), amountOfProcesses);
List <Scheduler> schedulers = new List <Scheduler>();
schedulers.Add(new FCFS());
schedulers.Add(new LCFSNotPreemptive());
schedulers.Add(new LCFSPreemptive());
schedulers.Add(new RoundRobin());
schedulers.Add(new SJF());
foreach (var scheduler in schedulers)
{
scheduler.Schedule(simulatorModel);
}
}
public override void Schedule(SimulatorModel simulator)
{
Array.Sort(simulator.ProcessArrivingTime, (x, y) => x.Item1.CompareTo(y.Item1));
if (simulator.ProcessArrivingTime.Length == 0)
{
return;
}
int totalRunningTime = simulator.ProcessArrivingTime[0].Item1;
int waitingTime = 0;
List <Tuple <int, int> > processesList = simulator.ProcessArrivingTime.ToList();
List <Tuple <int, int> > arrivingProcessesList = processesList;
Tuple <int, int> currentProcess;
while (processesList.Count != 0)
{
if (arrivingProcessesList.Count != 0)
{
currentProcess = arrivingProcessesList.FirstOrDefault();
}
else
{
currentProcess = processesList.FirstOrDefault();
}
turnAroundTime += currentProcess.Item2 + waitingTime;
totalRunningTime += currentProcess.Item2;
processesList.Remove(currentProcess);
arrivingProcessesList = (from nextProcess in processesList
where nextProcess != null &&
nextProcess.Item1 <= totalRunningTime
select nextProcess).ToList();
if (arrivingProcessesList.Count == 0)
{
continue;
}
arrivingProcessesList.Sort((x, y) => y.Item1.CompareTo(x.Item1));
waitingTime = totalRunningTime - arrivingProcessesList.FirstOrDefault().Item1;
if (waitingTime < 0)
{
waitingTime = 0;
}
}
this.PrintResult("LCFS Not Preemptive", turnAroundTime, simulator.NumProc);
}
public override void Schedule(SimulatorModel simulator)
{
int lastBurstTime = 0;
//sort in descending order
Array.Sort(simulator.ProcessArrivingTime, (x, y) => y.Item1.CompareTo(x.Item1));
for (int i = 0; i < simulator.NumProcBigThanZero; i++)
{
if (i > 0)
{
lastBurstTime += simulator.ProcessArrivingTime[i - 1].Item2;
}
turnAroundTime += lastBurstTime + simulator.ProcessArrivingTime[i].Item2;
}
this.PrintResult("LCFS Preemptive", turnAroundTime, simulator.NumProc);
}
public abstract void Schedule(SimulatorModel simulator);
public override void Schedule(SimulatorModel simulator)
{
//sort in descending order
Array.Sort(simulator.ProcessArrivingTime, (x, y) => x.Item1.CompareTo(y.Item1));
int currentTime = simulator.ProcessArrivingTime[0].Item1;
int[] restBurstTime = new int[simulator.NumProcBigThanZero];
int[] waitingTime = new int[simulator.NumProcBigThanZero];
for (int i = 0; i < simulator.NumProcBigThanZero; i++)
{
restBurstTime[i] = simulator.ProcessArrivingTime[i].Item2;
}
int completeProc = 0, totalRunningTime = simulator.ProcessArrivingTime[0].Item1, minRemainTime = int.MaxValue;
int shortestProcIndex = 0, finishTime;
bool checkIfProcessFinished = false;
// Process until all processes gets completed
while (completeProc != simulator.NumProcBigThanZero)
{
// Find process with minimum remaining time
for (int i = 0; i < simulator.NumProcBigThanZero; i++)
{
if ((simulator.ProcessArrivingTime[i].Item1 <= totalRunningTime) &&
(restBurstTime[i] < minRemainTime) && restBurstTime[i] > 0)
{
minRemainTime = restBurstTime[i];
shortestProcIndex = i;
checkIfProcessFinished = true;
}
}
if (checkIfProcessFinished == false)
{
totalRunningTime++;
continue;
}
// Reduce remaining time by one
restBurstTime[shortestProcIndex]--;
// Update minimum
minRemainTime = restBurstTime[shortestProcIndex];
if (minRemainTime == 0)
{
minRemainTime = int.MaxValue;
}
// If a process gets completely
// executed
if (restBurstTime[shortestProcIndex] == 0)
{
// Increment completeProc
completeProc++;
checkIfProcessFinished = false;
// Find finish time of current process
finishTime = totalRunningTime + 1;
// Calculate waiting time
waitingTime[shortestProcIndex] = finishTime -
simulator.ProcessArrivingTime[shortestProcIndex].Item2 -
simulator.ProcessArrivingTime[shortestProcIndex].Item1;
if (waitingTime[shortestProcIndex] < 0)
{
waitingTime[shortestProcIndex] = 0;
}
}
// Increment time
totalRunningTime++;
}
for (int i = 0; i < simulator.NumProcBigThanZero; i++)
{
turnAroundTime += waitingTime[i] + simulator.ProcessArrivingTime[i].Item2;
}
this.PrintResult("SJF", turnAroundTime, simulator.NumProc);
}
