AVA 2 - UVA - Sistemas Operacionais I

Prévia do material em texto

Alocação de recursos 
É objetivo da disciplina sistemas operacionais “descrever como funciona a 
prevenção de impasses”. Com base neste objetivo é definido o trabalho da 
unidade 4 que consistirá na verificação de um programa com três threads que 
executam concorrentemente, competido por recursos do sistema. 
O trabalho é importante para que você compreenda os problemas que podem 
ocorrer em um sistema quando existe a concorrência por seus recursos. 
Foi desenvolvido um sistema que possui 3 procedimentos que executaram 
concorrentemente dentro de um processo. Tais procedimentos são 
denominados Proc_A, Proc_B e Proc_C. A listagem com o programa em 
português estruturado encontra-se no final deste texto. 
Os procedimentos citados concorrem pela utilização de três recursos: 
• Impressora 
• Plotter 
• Scanner 
Cada um destes recursos pode estar alocado a somente um procedimento por 
vez. O controle do acesso aos recursos é realizado por intermédio de 
semáforos. Como você sabe, a utilização de semáforos faz com que, se um 
recurso estiver em uso por um procedimento, e um segundo procedimento 
tentar alocá-lo, este segundo procedimento ficará bloqueado até que o 
procedimento que detém o recurso o libere. 
O procedimento “aloca_impressora()” permitirá que o procedimento continue 
sua execução e a alocará para ele se a impressora estiver disponível, caso 
contrário o procedimento será bloqueado até que a impressora esteja 
disponível para alocação. Realiza a operação “down” no semáforo da 
impressora. 
Os procedimentos “aloca_plotter()” e “aloca_scanner()” funcionam de forma 
semelhante para o plotter e o scanner. 
O procedimento “libera_impressora()” faz a liberação da impressora para que 
possa ser utilizada por outro procedimento. Caso algum procedimento esteja 
bloqueado aguardando pela liberação da impressora, ele será desbloqueado e 
a impressora sela alocada para ele. Realiza a operação “up” no semáforo da 
impressora. 
Os procedimentos “libera_plotter()” e “libera_scanner()” funcionam de forma 
semelhante para o plotter e o scanner. 
Os procedimentos “processa_algo()” realiza um processamento qualquer. 
Os procedimentos “processa_algo_utilizando_xxxxxxxx()” representa alguma 
tarefa que é realiza em determinados momentos, utilizando os recursos que 
constam no nome no procedimento. Por exemplo, 
“processa_algo_utilizando_scanner_impressora()” necessita tanto do scanner 
quanto da impressora para ser executado. 
As linhas de comando: 
pthread_create(thread_A, Proc_A); 
pthread_create(thread_B, Proc_B); 
 pthread_create(thread_C, Proc_C); 
colocam os procedimentos Proc_A, Proc_B e Proc_C executando 
concorrentemente, cada um em uma thread diferente. 
O trabalho consiste em verificar o código abaixo procurando por problemas que 
possam levar ao funcionamento incorreto do sistema. 
Elabore um documento texto em formato PDF contendo: 
• A identificação das linhas do sistema que podem causar problemas durante 
sua execução. 
• A explicação dos problemas que podem ocorrer. 
• Uma proposta de correção no algoritmo para que os problemas sejam 
corrigidos e o sistema execute sem erros. 
IMPORTANTE: A solução não pode alterar a ordem de execução dos 
procedimentos “processa_algo_utilizando_xxxxxxxx()”, pois isso afetaria o 
funcionamento do algoritmo. 
--------- 
Algoritmo "concorrentes" 
 
Var 
 // Variaveis de controle das threads 
 thread thread_A, thread_B, thread_C: thread; 
 // Semaforos de controle 
 sema_impressora, sema_plotter, sema_scanner: semaforo; 
 
Procedimento Proc_A() 
Início 
 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
 processa_algo(); 
 aloca_plotter(); 
 processa_algo_utilizando_plotter(); 
 libera_plotter(); 
 Fim Enquanto; 
Fim; 
 
Procedimento Proc_B() 
Início 
 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
 processa_algo(); 
 aloca_scanner(); 
 processa_algo_utilizando_scanner(); 
 aloca_impressora(); 
 processa_algo_utilizando_scanner_impressora(); 
 aloca_plotter(); 
 processa_algo_utilizando_scanner_impressora_plotter(); 
 libera_plotter(); 
 libera_impressora(); 
 libera_scanner(); 
 Fim Enquanto; 
Fim; 
 
Procedimento Proc_C() 
Início 
 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
 processa_algo(); 
 aloca_impressora(); 
 processa_algo_utilizando_impressora(); 
 aloca_scanner(); 
 processa_algo_utilizando_scanner_impressora(); 
 libera_impressora(); 
 libera_scanner(); 
 Fim Enquanto; 
Fim; 
 
Início 
 sema_impressora = 1; // Inicia semaforo de controle da impressora 
 sema_plotter = 1; // Inicia semaforo de controle do plotter 
 sema_scanner = 1; // Inicia semaforo de controle do scanner 
 // Inicia as threads colocando-as em execução paralelamente 
 pthread_create(thread_A, Proc_A); // Inicia Proc_A como uma thread 
 pthread_create(thread_B, Proc_B); // Inicia Proc_A como uma thread 
 pthread_create(thread_C, Proc_C); // Inicia Proc_A como uma thread 
 // faz com que a thread principal espere as demais acabarem 
 pthread_join(thread_A); 
 pthread_join(thread_B); 
 pthread_join(thread_C); 
Fim. 
Procedimentos para elaboração do TD 
Faça a verificação do algoritmo apresentado apontando, em um documento no 
formato PDF, os erros que possam levar ao funcionamento incorreto do 
sistema. No documento deverá constar: 
• A identificação das linhas do sistema que podem causar problemas durante 
sua execução. 
• A explicação dos problemas que podem ocorrer. 
• Uma proposta de correção no algoritmo para que os problemas sejam 
corrigidos e o sistema execute sem erros 
 
 
 
 
 
 
 
 
RESPOSTA 
Cada um desses recursos pode estar alocado a um procedimento. 
Os semáforos controlam os acessos, a utilização de semáforos faz com que, quando 
um recurso estiver em um e um segundo procedimento tentar alocá-lo, esse 
segundo procedimento ficará bloqueado até que o procedimento que detém o 
recurso libere. 
Var 
 // Variaveis de controle das threads 
 thread thread_A, thread_B, thread_C: thread; 
 // Semaforos de controle 
 sema_impressora, sema_plotter, sema_scanner: semaforo; 
 
Procedimento Proc_A() 
Início 
 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
 processa_algo(); 
 aloca_plotter(); 
 processa_algo(); 
 libera_plotter(); 
 Fim Enquanto; 
Fim; 
//Proc_A() aloca o potter, processa e depois libera 
 
Procedimento Proc_B() 
Início 
 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
 processa_algo(); 
 aloca_scanner(); 
 processa_algo(); 
 aloca_impressora(); 
 processa_algo(); 
 aloca_plotter(); 
 processa_algo(); 
 libera_plotter(); 
 libera_impressora(); 
 libera_scanner(); 
 Fim Enquanto; 
Fim; 
//Proc_B() enquanto o scanner não "libera"o sistema não conseguirá aloca a 
impressora e nem mesmo o potter. 
 
Procedimento Proc_C() 
Início 
 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
 processa_algo(); 
 aloca_impressora(); 
 processa_algo(); 
 aloca_scanner(); 
 processa_algo(); 
 libera_impressora(); 
 libera_scanner(); 
 Fim Enquanto; 
Fim; 
//Proc_C() ao alocat a impressora, processar_algo o sistema não consegue aloca o 
scaner sem ter feito o "libera_impressora", desta forma o sistema vai ficar confuso e 
não conseguirá alocar o scanner. 
 
Início 
 sema_impressora = 1; // Inicia semaforo de controle da impressora 
 sema_plotter = 1; // Inicia semaforo de controle do plotter 
 sema_scanner = 1; // Inicia semaforo de controle do scanner 
 // Inicia as threads colocando-as em execução paralelamente 
 pthread_create(thread_A, Proc_A); // Inicia Proc_A como uma thread 
 pthread_create(thread_B, Proc_B); // IniciaProc_A como uma thread 
 pthread_create(thread_C, Proc_C); // Inicia Proc_A como uma thread 
 // faz com que a thread principal espere as demais acabarem 
 pthread_join(thread_A); 
 pthread_join(thread_B); 
 pthread_join(thread_C); 
Fim. 
 
 Conclusão: 
O thread_A pode ser processado sem problemas, a thread_B alocará o scanner, 
depois de liberar o scanner ela alocará a impressora, feito isto ela irá alocar o potter 
mas o sistema só conseguirá se a thread_A já estiver finalizado e não é o caso, com 
isso o sistema ficará confuso, tentará enfileirar e entrará em deadlock. 
Em thread_C provocarão deadlocks porque causará engarrafamento ao tentar alocar 
recursos de um periférico enquanto outro periférico ainda o utiliza e o semáforo 
ainda não registrou a liberação dos recursos.