Trabalho de Simulação de Gerência de Processos

[pic 1][pic 2][pic 3][pic 4]

Trabalho Prático I

*** Data de entrega: até 13/11/2020 ***

Este trabalho prático envolve uma simulação de gerência de processo e programação concorrente. O objetivo do trabalho é familiarizar os alunos com os conceitos de gerência de processos, escalonamento de processos, comunicação entre processos por meio de compartilhamento de memória, programação usando threads e o controle de concorrência usando semáforos. Considere no texto abaixo os termos processo e thread como equivalentes.

1. Simulação de gerência de processos

Implemente um simulador de um gerenciador de processos simplificado com duas técnicas de escalonamento: fila simples (FIFO) e Round-Robin. Considere uma determinada quantidade de processos (pode ser lido pelo teclado). Os processos deverão se escalonados conforme a técnica selecionada para simular a execução na CPU. Serão simuladas também chamadas para operações de entrada e saída (disco e impressora). Os processos podem estar em 3 estados: pronto para execução, em execução e bloqueado. As seguintes estruturas devem ser implementadas:

• lista de processos ativos (lista de bloco de controle de processos - PCB) (procs) com os seguintes dados:

• pid - identificador do processo
• nome do processo
• estado
• q_CPU - quantidade de fatias de tempo de CPU para execução
• q_disco – quantidade de fatias de tempo de uso do disco
• q_impressora – quantidade de fatias de tempo de uso da impressora

• lista de processos prontos para usar a CPU (procs_prontos).
• referência para o PCB do processo em execução, ou seja, o que está ocupando a CPU (usando_cpu).
• fila de espera para uso da impressora (espera_impressora) contendo as referências para os PCBs dos processos que aguardam a impressora.
• referência para o PCB do processo que está ocupando a impressora (usando_impressora).
• fila de espera para uso do disco (espera_disco) contendo as referências para os PCBs dos processos que aguardam para utilizar o disco.
• referência para o PCB do processo que está ocupando o disco (usando_disco).
• A equipe pode acrescentar quaisquer estruturas de dados que achar necessárias para facilitar a implementação.

O programa deverá:

• Inicializar as estruturas de dados, gerando os processos com dados lidos do teclado ou gerados aleatoriamente;
• Inicialmente considerar que todos os processos estão no estado “pronto para execução” e, portanto, fazendo parte da estrutura procs_prontos;
• Mostrar graficamente ou em modo texto a situação de cada uma das estruturas de dados, indicando os estados e quais processos se encontram em cada estrutura a cada instante de tempo;
• Simular ciclos de máquina, sendo que:

• a passagem do tempo se dá a cada vez que o usuário pressiona uma tecla (opcionalmente pode mostrar sem esperar);
• a visualização das estruturas de dados é atualizada a cada unidade de tempo;
• a cada unidade de tempo, existe 30% de chance de um novo processo ser criado (pode preencher os dados aleatoriamente ou ler pelo teclado).
• a cada unidade de tempo, os descritores em uso e as estruturas de dados são atualizadas;

o No caso do escalonamento Round-Robin, um processo só pode ocupar a CPU por, no máximo, 3 fatias de tempo corridos. Se ao final deste tempo o processo não estiver concluído, deverá ceder a CPU ao primeiro processo na lista procs_prontos e retorna para o final da mesma;

• Cada processo deverá possuir um ciclo de CPU, um ciclo de disco, outro ciclo de CPU, um opcional de impressora (50% de chance) e um ciclo de CPU. Cada ciclo contém uma quantidade de fatias de tempo, que somadas dão o total das fatias de tempo informadas para CPU, disco e impressora.

1. Problema de Processos Leitores × Escritores

Crie uma variável (ex: um registro com dados, uma variável com um valor numérico, etc), que será compartilhada por várias threads, algumas do tipo leitor e outras do tipo escritor. As threads leitoras devem exibir os dados lidos e as threads escritoras devem atualizar e exibir os dados após a atualização.

O trabalho pode ter um “tema” como o problema do banco, portal do aluno, banco de dados de clientes de uma loja, registro de compras, etc.

Implemente duas (3) versões:

1. Leitores e escritores com mesma prioridade. Pode ocorrer “leitura suja”.
2. Escritores com prioridade sobre leitores. Nesse caso, leitores somente têm acesso aos dados quando não há nenhum escritor ativo. Não ocorre “leitura suja”.

O programa deve receber como entrada a definição dos processos (ex: via teclado, arquivo de entrada ou gerados alatoriamente) com a quantidade de threads leitoras e escritoras e os valores que serão atualizados pelos escritores.

A saída do programa deve ilustrar o funcionamento do sistema, mostrando quando cada processo é criado, quando eles entram e saem da região crítica, quando eles são bloqueados, seu tipo (leitor ou escritor), o que fizeram e o momento em que ele é finalizado.

...