public Processo PegaProximo()
{
if (this.ListaFila.Count == 0)
{
return(null);
}
else
{
Processo Retorno = this.ListaFila[0];
this.ListaFila.RemoveAt(0);
return(Retorno);
}
}
private static void LerArquivos()
{
string[] arquivo = File.ReadAllLines("processos.txt");
foreach (string linha in arquivo)
{
string[] aux = linha.Split(';');
int pid = int.Parse(aux[0]);
string nome = aux[1];
int prioridade = int.Parse(aux[2]);
int numciclos = int.Parse(aux[3]);
Processo NovoProcesso = new Processo(pid, nome, prioridade, numciclos);
FilasPrioridade[prioridade - 1].InserirUltimo(NovoProcesso);
Console.WriteLine($@"Processo de id {pid} inserido na fila de prioridade {prioridade}");
}
}
void executaThread()
{
//3 - Cria os processos
List <Processo> processos = new List <Processo>();
List <TextBox> textboxes = new List <TextBox>();
List <Label> labels = new List <Label>();
Processo processo1 = new Processo();
processo1.setInput(textBox2.Text);
processos.Add(processo1);
textboxes.Add(textBox5);
labels.Add(label4);
processo1.ciclos = Convert.ToInt32(textBox8.Text);
finalizado(processos[0].finalizado);
Processo processo2 = new Processo();
processo2.setInput(textBox3.Text);
processos.Add(processo2);
textboxes.Add(textBox6);
labels.Add(label5);
processo2.ciclos = Convert.ToInt32(textBox9.Text);
finalizado(processos[1].finalizado);
Processo processo3 = new Processo();
processo3.setInput(textBox4.Text);
processos.Add(processo3);
textboxes.Add(textBox7);
labels.Add(label6);
processo3.ciclos = Convert.ToInt32(textBox10.Text);
finalizado(processos[2].finalizado);
//4 - Calcula a matriz de saída para o txt
qntProcessos = processos.Count() + 1;
qntColunas = calculaTamanhoTotal(processos) + 1;
matriz = new string[qntProcessos, qntColunas];
escalonaProcessos(processos, Convert.ToInt32(textBox1.Text), 0, textboxes);
controlesDesbloquear();
}
public void InserirUltimo(Processo x)
{
Nodo NovoNodo = new Nodo();
NovoNodo.dado = x;
if (raiz == null)
{
NovoNodo.seguinte = NovoNodo;
NovoNodo.anterior = NovoNodo;
raiz = NovoNodo;
}
else
{
Nodo ultimo = raiz.anterior;
NovoNodo.seguinte = raiz;
NovoNodo.anterior = ultimo;
raiz.anterior = NovoNodo;
ultimo.seguinte = NovoNodo;
}
}
/// <summary>
/// Simula a execução do escalonador
/// </summary>
public void Run()
{
int pos = 0;
while (!TodosVazia() && pos < Todos.Length) // Enquanto todas as filas de processos não estiverem vazias
{
Console.WriteLine("\t\tProcessando Lista de Processos com Prioridade " + (pos + 1));
while (!Todos[pos].Vazio()) // Enquanto uma fila especifica não estiver vazia
{
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.WriteLine("\nTroca de contexto...");
Console.ForegroundColor = ConsoleColor.White;
Thread.Sleep(tContexto); // Simulando o tempo gasto pela troca de contexto
Processo processo = (Processo)(Todos[pos].Retirar()); // Retira o processo em execução da fila de processos
Console.WriteLine("Processando: " + processo.ToString());
if (CPU(processo) > 0) // Se o retorno da CPU for maior que 0, o processo foi finalizado
{
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.WriteLine("Processo Finalizado");
Console.ForegroundColor = ConsoleColor.White;
}
else // O processo não terminou
{
AdicionarProcesso(processo); // Adiciona o processo em uma nova fila de prioridade (prioridade -1)
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine("Processo REBAIXADO para prioridade {0}", processo.Prioridade);
Console.ForegroundColor = ConsoleColor.White;
}
Console.WriteLine("\n\t\tProcessando Lista de Processos com Prioridade " + (pos + 1));
Console.WriteLine("\n" + Todos[pos].ToString());
}
pos++;
}
}
public Processo Remover(int pos)
{
if (pos <= Contar())
{
if (pos == 1)
{
if (Contar() == 1)
{
Processo aux = raiz.dado;
raiz = null;
return(aux);
}
else
{
Processo aux = raiz.dado;
Nodo ultimo = raiz.anterior;
raiz = raiz.seguinte;
ultimo.seguinte = raiz;
raiz.anterior = ultimo;
return(aux);
}
}
else
{
Nodo aux = raiz;
for (int f = 1; f <= pos - 1; f++)
{
aux = aux.seguinte;
}
Processo auxp = aux.dado;
Nodo anterior = aux.anterior;
aux = aux.seguinte;
anterior.seguinte = aux;
aux.anterior = anterior;
return(auxp);
}
}
return(null);
}
/// <summary>
/// Simulation of the process execution
/// </summary>
/// <param name="p">Process to be executed</param>
/// <returns>Returns 1, if the process was completed;
/// Returns -1, if the process was not completed.</returns>
private int CPU(Processo p)
{
int aux = 1; // represents how much of the quantum was completed
while (aux <= Quantum && p.QtdeCiclos > 0)
{
p.DiminuirQtdeCiclos();
Thread.Sleep(sleep); // Simula o tempo gasto pela CPU
aux++;
}
if (p.QtdeCiclos == 0)
{
return(1);
}
else
{
p.DiminuirPrioridade();
}
return(-1);
}
private static void Processar()
{
for (int i = 0; i < FilasPrioridade.Length; i++)
{
for (int j = 0; j < 20 - i && j < FilasPrioridade[i].Contar(); j++)
{
Processo processo = FilasPrioridade[i].Remover(1);
ExecutarProcesso(processo);
if (processo.Numciclos > 0)
{
Console.WriteLine($@"Processo {processo.Pid} retornado para fila de espera de prioridade {processo.Prioridade}");
FilasPrioridade[processo.Prioridade - 1].InserirUltimo(processo);
}
else
{
Console.WriteLine($@"Processo {processo.Pid} encerrou sua execução");
}
}
}
Console.WriteLine("Todos os processos encerraram sua execução");
}
private static void PromoverProcesso(Processo processo)
{
processo.Prioridade--;
FilasPrioridade[processo.Prioridade - 1].InserirUltimo(processo);
Console.WriteLine($@"Processo {processo.Pid} promovido para fila de prioridade {processo.Prioridade}");
}
private static void RebaixarProcesso(Processo processo)
{
processo.Prioridade++;
FilasPrioridade[processo.Prioridade - 1].InserirUltimo(processo);
Console.WriteLine($@"Processo {processo.Pid} rebaixado para fila de prioridade {processo.Prioridade}");
}
private static void ExecutarProcesso(Processo processo)
{
Console.WriteLine($@"Executando processo {processo.Pid}");
Thread.Sleep(100);
processo.Numciclos--;
}
public void Insere(Processo Processo)
{
this.ListaFila.Add(Processo);
}
