Esempio n. 1
0
        public static void OrdenarFCFS()
        {
            int  qtdeProcessos  = 0;
            bool validarInteiro = false;

            Console.WriteLine("Você escolheu:");
            Console.WriteLine("1 - First come, first served (FCFS)");
            Console.WriteLine("Quantos processos serão analisados?");

            while (validarInteiro == false)
            {
                try
                {
                    qtdeProcessos  = Convert.ToInt32(Console.ReadLine());
                    validarInteiro = true;
                }
                catch (Exception)
                {
                    Console.WriteLine("Insira um valor numérico.");
                }
            }

            var processos = new List <Processo> {
            };

            Console.WriteLine("Insira os nomes dos processos que serão analisados");

            for (int i = 0; i < qtdeProcessos; i++)
            {
                Processo _processo = new Processo();
                Console.WriteLine("\nProcesso {0}", i + 1);
                _processo.nome = Console.ReadLine();
                processos.Add(_processo);
            }

            //ordenar processos
            //fcfs ou fifo os processos são listados por ordem de entrada
            Console.WriteLine("\nOrdem de Execução:\n");

            for (int i = 0; i < qtdeProcessos; i++)
            {
                Console.WriteLine("Processo {0}: {1}", i + 1, processos[i].nome);
            }
        }
Esempio n. 2
0
        public static void OrdenarSJF()
        {
            int  qtdeProcessos  = 0;
            bool validarInteiro = false;

            Console.WriteLine("Você escolheu:");
            Console.WriteLine("2 - Shortest Job First (SJF)");
            Console.WriteLine("Quantos processos serão analisados?");

            while (validarInteiro == false)
            {
                try
                {
                    qtdeProcessos  = Convert.ToInt32(Console.ReadLine());
                    validarInteiro = true;
                }
                catch (Exception)
                {
                    Console.WriteLine("Insira um valor numérico.");
                }
            }

            var processos = new List <Processo> {
            };

            Console.WriteLine("Insira o nome e tempo médio de execução de cada processo que será analisado:");

            for (int i = 0; i < qtdeProcessos; i++)
            {
                Processo _processo = new Processo();
                Console.WriteLine("\nNome do Processo:");
                _processo.nome = Console.ReadLine();
                Console.WriteLine("Tempo Médio de processamento:");

                validarInteiro = false;
                while (validarInteiro == false)
                {
                    try
                    {
                        _processo.tempoProcesso = Convert.ToDouble(Console.ReadLine());
                        validarInteiro          = true;
                    }
                    catch (Exception)
                    {
                        Console.WriteLine("Insira um valor numérico.");
                    }
                }

                processos.Add(_processo);
            }

            //ordenar processos
            //sjf os processos são ordenados por tempo de processamento crescente

            for (int i = 0; i < qtdeProcessos; i++)
            {
                for (int j = 0; j < qtdeProcessos; j++)
                {
                    if (processos[i].tempoProcesso < processos[j].tempoProcesso)
                    {
                        Processo aux = new Processo();
                        aux          = processos[i];
                        processos[i] = processos[j];
                        processos[j] = aux;
                    }
                }
            }

            //Listar processos
            Console.WriteLine("\nOrdem de Execução:\n");

            for (int i = 0; i < qtdeProcessos; i++)
            {
                Console.WriteLine("Processo {0}: {1}, Tempo de execução: {2}", i + 1, processos[i].nome, processos[i].tempoProcesso);
            }
        }
        public static void PaginarSegundaChance()
        {
            int  qtdeProcessos  = 0;
            bool validarInteiro = false;

            Console.WriteLine("Você escolheu:");
            Console.WriteLine("5 - Gerenciamento de Memória - Segunda Chance");
            Console.WriteLine("Qual a quantidade de páginas disponíveis?");

            while (validarInteiro == false)
            {
                try
                {
                    qtdeProcessos  = Convert.ToInt32(Console.ReadLine());
                    validarInteiro = true;
                }
                catch (Exception)
                {
                    Console.WriteLine("Insira um valor numérico.");
                }
            }

            var processos = new List <Processo> {
            };

            Console.WriteLine("Insira os nomes dos processos que serão analisados e se foram executados recentemente.");

            for (int i = 0; i < qtdeProcessos; i++)
            {
                Processo _processo = new Processo();
                Console.WriteLine("\nPágina {0}", i + 1);
                _processo.nome = Console.ReadLine();
                Console.WriteLine("\nO página {0} foi utlizado recentement? S/N", _processo.nome);
                _processo.isRemovable = Console.ReadLine().ToLower().Equals("s") ? false : true;
                processos.Add(_processo);
            }

            //ordenar processos
            //fcfs ou fifo os processos são listados por ordem de entrada
            Console.WriteLine("\nOrdem de Paginação:\n");

            for (int i = 0; i < qtdeProcessos; i++)
            {
                Console.WriteLine("Página {0}: {1} / Remover: {2}", i + 1, processos[i].nome, processos[i].isRemovable);
            }

            var novosProcessos = new List <Processo> {
            };

            foreach (var processo in processos)
            {
                if (processo.isRemovable == false)
                {
                    novosProcessos.Add(processo);
                }
            }

            //listar processos após gerenciamento
            Console.WriteLine("\nOrdem de Paginação:\n");

            for (int i = 0; i < novosProcessos.Count; i++)
            {
                Console.WriteLine("Página {0}: {1} / Remover: {2}", i + 1, novosProcessos[i].nome, novosProcessos[i].isRemovable);
            }
        }
Esempio n. 4
0
        public static void OrdenarRoundRobin()
        {
            int    qtdeProcessos = 0;
            int    contProcessos = 0;
            double quantum;
            bool   isQuantum      = false;
            bool   validarInteiro = false;

            Console.WriteLine("Você escolheu:");
            Console.WriteLine("4 - Algorítmo Round Robin");
            Console.WriteLine("Quantos processos serão analisados?");

            while (validarInteiro == false)
            {
                try
                {
                    qtdeProcessos  = Convert.ToInt32(Console.ReadLine());
                    validarInteiro = true;
                }
                catch (Exception)
                {
                    Console.WriteLine("Insira um valor numérico.");
                }
            }

            var processos = new List <Processo> {
            };

            Console.WriteLine("Insira o Nome e o Tempo médio de execução de cada processo que será analisado");

            for (int i = 0; i < qtdeProcessos; i++)
            {
                Processo _processo = new Processo();
                Console.WriteLine("\nNome do Processo:");
                _processo.nome = Console.ReadLine();
                Console.WriteLine("Tempo Médio de processamento:");

                validarInteiro = false;
                while (validarInteiro == false)
                {
                    try
                    {
                        _processo.tempoProcesso = Convert.ToDouble(Console.ReadLine());
                        validarInteiro          = true;
                    }
                    catch (Exception)
                    {
                        Console.WriteLine("Insira um valor numérico.");
                    }
                }

                processos.Add(_processo);
            }

            Console.WriteLine("\nInsira o Quantum:");
            quantum = Convert.ToDouble(Console.ReadLine());

            //ordenar processos
            //round robin os processos são listados por ordem de entrada
            //troca de contexto de acordo com o quantum

            Console.WriteLine("\nOrdem de Execução:\n");

            while (isQuantum == false)
            {
                for (int i = 0; i < qtdeProcessos; i++)
                {
                    contProcessos++;
                    if (processos[i].tempoProcesso > quantum)
                    {
                        Console.WriteLine("Processo {0}: {1}, Tempo restante de execução: {2}", contProcessos, processos[i].nome, processos[i].tempoProcesso);
                        processos[i].tempoProcesso -= quantum;
                    }
                    else
                    {
                        Console.WriteLine("Processo {0}: {1}, Tempo de execução: {2}", contProcessos, processos[i].nome, processos[i].tempoProcesso);
                        processos[i].isRemovable = true;
                    }
                }

                for (int i = 0; i < qtdeProcessos; i++)
                {
                    if (processos[i].isRemovable == true)
                    {
                        processos.RemoveAt(i);
                        qtdeProcessos--;
                    }
                }

                if (processos.Count == 0)
                {
                    isQuantum = true;
                }
            }
        }