예제 #1
0
        //Metódo que monta um novo processo e retorna esse processo
        private Processo MontaNovoProcesso()
        {
            string linha = reader.ReadLine();

            string[] celula = linha.Split(';', ',');

            int    PID = 0, prioridade = 0, numeroCiclos = 0;
            string nome = "VAZIO";


            PID          = int.Parse(celula[0]);
            nome         = celula[1];
            prioridade   = int.Parse(celula[2]);
            numeroCiclos = int.Parse(celula[3]);

            Processo p = new Processo(PID, nome, prioridade, numeroCiclos);

            return(p);
        }
예제 #2
0
        // Enfileira um novo processo, ou seja, aloca um processo na ultima posição
        public void EnfileirarProcesso(Processo processo)
        {
            mutex.WaitOne();
            ProcessoUnidade processoNovo = new ProcessoUnidade(processo);

            // Caso o tempo de espera não esteja acontecendo, será iniciado
            if (!processoNovo.Processo.TempoEspera.IsRunning)
            {
                processoNovo.Processo.TempoEspera.Start();
            }

            if (FilaVazia())
            {
                Frente.Proximo = processoNovo;
            }

            Atras.Proximo = processoNovo;
            Atras         = processoNovo;

            ContadorProcesso++;
            mutex.ReleaseMutex();
        }
예제 #3
0
        // @TODO
        public static void ControlePrioridadeEspera(ProcessoFila[] filaProcessos, int TempoMaximoDeEspera)
        {
            while (true)
            {
                // Thread dorme para não verificar a todo instante
                Thread.Sleep(TempoMaximoDeEspera);

                // Fila auxiliar
                ProcessoFila[] FilasAux = new ProcessoFila[32];

                // Instânciando as filas
                for (int p = 0; p < FilasAux.Length; p++)
                {
                    FilasAux[p] = new ProcessoFila();
                }

                Monitor.Enter(filaProcessos);

                // Percorre a fila prioridade
                for (int x = 0; x < filaProcessos.Length - 1; x++)
                {
                    // Captura o número de processos na fila
                    int nProcs = filaProcessos[x].ContadorProcesso;

                    // Define a prioridade
                    int prioridadeFila = x;

                    for (int u = 0; u < nProcs; u++)
                    {
                        // Retira o processo da fila
                        Processo processoEmAnalise = filaProcessos[prioridadeFila].DesenfileirarProcesso();

                        // Verifica necessidade de subir prioridade
                        if (processoEmAnalise.TempoEspera.ElapsedMilliseconds > TempoMaximoDeEspera)
                        {
                            // Eleva a prioridade do processo e altera o valor da variavel prioridade
                            prioridadeFila = processoEmAnalise.ElevarPrioridade() - 1;
                            // Coloca o processo na fila auxiliar
                            FilasAux[prioridadeFila - 1].EnfileirarProcesso(processoEmAnalise);
                        }

                        else
                        {
                            // Coloca o processo de volta na mesma fila
                            filaProcessos[prioridadeFila].EnfileirarProcesso(processoEmAnalise);
                        }

                        // Altera o valor da prioridade para evitar bugs
                        prioridadeFila = x;
                    }
                }

                // Percorre as filas para adicionar os processos em suas devidas filas

                for (int i = 1; i < filaProcessos.Length; i++)
                {
                    while (!FilasAux[i - 1].FilaVazia())
                    {
                        filaProcessos[i].EnfileirarProcesso(FilasAux[i - 1].DesenfileirarProcesso());
                    }
                }

                Monitor.Exit(filaProcessos);
            }
        }
예제 #4
0
 // Construtor
 public ProcessoUnidade(Processo processo)
 {
     Processo = processo;
 }