public static List <PlotableProcess> Schedulering(List <Process> processes, ProgressBar bar = null)
{
//ProgressBar em 0%
Application.Invoke((sender, e) => bar.Fraction = 0);
double iteracoes = 0;
processes.ForEach((obj) => { iteracoes = iteracoes + obj.runtime; });
double cont = 0;
List <PlotableProcess> plotableProcesses = new List <PlotableProcess>();
List <EscalonableProcess> escalonableProcesses = new List <EscalonableProcess>();
int execTime;
for (int i = 0; i < processes.Count; i++)
{
escalonableProcesses.Add(new EscalonableProcess(processes[i]));
}
execTime = escalonableProcesses[0].arrivalTime;
EscalonableProcess aux = escalonableProcesses[0];
while (escalonableProcesses.Count > 0)
{
List <EscalonableProcess> tempo = escalonableProcesses.FindAll((obj) => obj.arrivalTime <= execTime);
if (tempo.Count == 0)
{
execTime += 1;
continue;
}
int indice = escalonableProcesses.FindIndex((obj) => obj.Equals(ShortestJob(tempo, aux)));
aux = escalonableProcesses[indice];
escalonableProcesses[indice].Run();
plotableProcesses.Add(new PlotableProcess(escalonableProcesses[indice], execTime));
execTime++;
Application.Invoke((sender, e) => bar.Fraction = cont / iteracoes);
cont += 1;
if (escalonableProcesses[indice].runtime == 0)
{
tempo.RemoveAt(tempo.FindIndex((obj) => obj.name == escalonableProcesses[indice].name));
escalonableProcesses.RemoveAt(indice);
if (escalonableProcesses.Count > 0)
{
aux = escalonableProcesses[0];
}
}
}
//ProgressBar em 0%
Application.Invoke((sender, e) => bar.Fraction = 0);
return(plotableProcesses);
}
protected List <PlotableProcess> GetProcessFromCreation()
{
List <PlotableProcess> plotables = new List <PlotableProcess>();
List <EscalonableProcess> escalonables = new List <EscalonableProcess>();
ProcessCompare compare = new ProcessCompare();
List <Process> li = new List <Process>(creationController.GetItens().ToArray());
li.Sort(compare);
foreach (Process process in li)
{
EscalonableProcess eProcess = new EscalonableProcess(process);
plotables.Add(new PlotableProcess(eProcess, 0));
}
return(plotables);
}
/// <summary>
/// Escalonar uma lista especifica
/// </summary>
/// <returns>A lista escalonada.</returns>
/// <param name="list">Lista a ser escalonada.</param>
public static List <PlotableProcess> Schedulering(List <Process> list, ProgressBar bar = null)
{
//ProgressBar em 0%
Application.Invoke((sender, e) => bar.Fraction = 0);
int execTime = 0;
List <PlotableProcess> listPlotable = new List <PlotableProcess>();
Queue <EscalonableProcess> escalonableProcesses;
//Calculo de procentagem para a progessBar
double iteracoes = 0;
list.ForEach((obj) => { iteracoes = iteracoes + obj.runtime; });
double cont = 0;
//Empilihando Processos
escalonableProcesses = new Queue <EscalonableProcess>(list.ConvertAll(
(input) => { return(new EscalonableProcess(input)); }));
//Enquanto houver processos
while (escalonableProcesses.Count > 0)
{
//Desenpilhamos o processo
EscalonableProcess escalonable = escalonableProcesses.Dequeue();
//Viajamos para o futuro caso o processo esteja em um execTime a frente
if (escalonable.arrivalTime > execTime)
{
execTime = escalonable.arrivalTime;
}
//E o executamos
while (escalonable.Run())
{
Application.Invoke((sender, e) => bar.Fraction = cont / iteracoes);
cont += 1;
listPlotable.Add(new PlotableProcess(escalonable, execTime));
execTime++;
}
}
Application.Invoke((sender, e) => bar.Fraction = 0);
return(listPlotable);
}
public static EscalonableProcess ShortestJob(List <EscalonableProcess> tempo, EscalonableProcess aux)
{
for (int i = 0; i < tempo.Count; i++)
{
if (aux.runtime > tempo[i].runtime)
{
aux = tempo[i];
}
}
return(aux);
}
