Prévia do material em texto
Aluna: Ellen Cristina Torres Cardosos / Matrícula: 04164893 Curso: Análise e Desenvolvimento de Sistemas Turma: 3° Semestre / Noite Segue uma breve explicação de como funciona a variação dos código a seguir: Na primeira variação, chamada Round-Robin com Controle de CPU (Lock), cada processo é executado como uma thread concorrente, mas o acesso à CPU é controlado por um Lock (mutex), garantindo que apenas um processo rode por vez. Cada processo possui um quantum fixo de 2 segundos antes de liberar a CPU para outro, simulando um sistema multitarefa com alternância obrigatória. Na segunda variação, Round-Robin com Threads Concorrentes, os processos continuam sendo threads, mas sem bloqueio explícito. Cada processo inicia sua execução de forma independente, e o escalonamento ocorre automaticamente. Isso permite uma execução mais dinâmica, sem um controle rígido da CPU, simulando um ambiente multitarefa mais realista. Já na terceira variação, Escalonamento por Prioridade, os processos são ordenados por níveis de prioridade, onde os mais importantes recebem mais tempo de CPU. Cada processo recebe uma prioridade aleatória, ajustando o tempo de execução de acordo com essa hierarquia. Essa abordagem simula um sistema operacional mais sofisticado, garantindo que tarefas críticas sejam executadas primeiro, sem impedir a execução de processos menos prioritários. Segue abaixo os códigos e suas variações: Codigo 1 Uma abordagem simples é o Round-Robin, onde cada processo recebe um quantum fixo de tempo antes de ceder a CPU para o próximo. Isso impede que um único processo monopolize a execução, garantindo uma distribuição mais justa do tempo de processamento. Outra variação dessa estratégia utiliza threads concorrentes junto a um mecanismo de sincronização (Lock), garantindo que apenas um processo utilize a CPU por vez, imitando um ambiente multitarefa real. Além disso, podemos implementar um escalonador por prioridade, onde processos com maior prioridade recebem mais tempo de CPU antes dos menos prioritários. Isso simula um cenário mais realista, onde tarefas críticas do sistema são executadas antes de processos menos urgentes. Com essas abordagens, conseguimos representar de forma simplificada como os sistemas operacionais lidam com múltiplos processos, garantindo eficiência e organização na execução dos programas. Código 2 Nesta variação da simulação de multiprogramação, utilizamos threads para executar os processos simultaneamente, com um gerente de CPU controlando o escalonamento. Dessa forma, o processador alterna entre os processos, garantindo que apenas um possa executar por vez, graças a um mecanismo de sincronização (Lock). Cada processo é representado por uma Thread, permitindo a execução concorrente. No entanto, para evitar que múltiplos processos usem a CPU ao mesmo tempo, um bloqueio (mutex) é utilizado, garantindo que apenas um processo tenha acesso ao processador por vez, imitando o funcionamento de um sistema real. A execução é baseada em um quantum fixo de 2 segundos, após os quais o processo libera a CPU para outro. O loop dentro de run() verifica constantemente se o processo ainda tem tempo restante, e, caso tenha, ele volta a competir pelo processador. Essa abordagem traz algumas melhorias em relação à versão anterior. Agora, os processos realmente competem entre si de forma concorrente, e o gerente de CPU (Lock) decide quem pode rodar, garantindo que nenhum processo fique "preso" monopolizando a CPU. Dessa forma, conseguimos simular de maneira mais fiel um sistema operacional multitarefa, onde os processos compartilham os recursos do processador de maneira organizada e eficiente. Código 3 Nesta variação da simulação de multiprogramação, implementamos um escalonador baseado em prioridades, onde os processos possuem diferentes níveis de prioridade, determinando a quantidade de tempo de CPU que cada um recebe. Os processos com maior prioridade têm preferência na execução e ganham mais tempo de CPU antes dos demais. O sistema ordena os processos com base em sua prioridade antes de iniciar a execução. Cada processo recebe um quantum proporcional à sua prioridade, garantindo que tarefas mais importantes sejam concluídas mais rapidamente. Isso simula um cenário mais realista, onde tarefas críticas do sistema operacional recebem mais recursos do que processos menos urgentes. Essa abordagem melhora a eficiência do uso da CPU, permitindo que processos mais prioritários sejam atendidos primeiro, ao mesmo tempo em que processos de menor prioridade ainda conseguem ser executados, mas com menos tempo de CPU por ciclo. Assim, conseguimos representar um sistema operacional que gerencia múltiplos processos de maneira organizada, garantindo um balanceamento entre eficiência e equidade na distribuição dos recursos.