Alocação de Recursos em Sistemas

Prévia do material em texto

UNIVERSIDADE VEIGA DE ALMEIDA 
 SUPERIOR DE TECNOLOGIA EM ANÁLISE E 
 DESENVOLVIMENTO DE SISTEMAS 
 PROF. 
 MIGUEL ANGELO ZACCUR DE FIGUEIREDO 
 ALUNO 
 JAIME DE MELO MORAES 
 TÍTULO DO TRABALHO 
 Alocação de recursos 
 DUQUE DE CAXIAS 
 2022 
 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 
 R : Todos os recursos podem estar alocados a um procedimento. 
 Os semáforos são controladores de acessos, um semáforo pode ser visto como um 
 objeto que pode sofrer dois tipos de operação sobre ele trancando e destrancando a 
 execução de instruções, ou seja esse segundo procedimento ficará trancado 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_utilizando_plotter(); 
 libera_plotter(); 
 Fim Enquanto; 
 Fim; 
 R : //Proc_A() aloca o potter, processa e por fim é liberado 
 Procedimento Proc_B() 
 Início 
 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
 processa_algo(); 
 aloca_scanner(); 
 processa_algo_utilizando_scanner(); 
 libera_scanner(); 
 aloca_impressora(); 
 processa_algo_utilizando_scanner_impressora(); 
 libera_impressora(); 
 aloca_plotter(); 
 processa_algo_utilizando_scanner_impressora_plotter(); 
 libera_plotter(); 
 Fim Enquanto; 
 Fim; 
 R : //Proc_B() O scanner deve ser “liberado” e depois a impressora e o plotter, se não o 
 funcionamento da impressora e do potter será travado. 
 Procedimento Proc_C() 
 Início 
 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
 processa_algo(); 
 aloca_impressora(); 
 processa_algo_utilizando_impressora(); 
 libera_impressora(); 
 aloca_scanner(); 
 processa_algo_utilizando_scanner_impressora(); 
 libera_scanner(); 
 Fim Enquanto; 
 Fim; 
 R : //Proc_C() Para poder “aloca_scanner():” precisa “libera_impressora();” desta forma o 
 sistema não ficará confuso e conseguirá “aloca_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çãoparalelamente 
 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. 
 Conclusão: 
 O thread_A pode ser processado. 
 A thread_B “aloca_scanner();” depois de “libera_scanner();” ela 
 “aloca_impressora();” feito isto ela irá “aloca_plotter();” porém o sistema só conseguirá se 
 a thread_A já estiver finalizado o'que não aconteceu deixando o sistema confuso, e 
 tentará enfileirar causando um impasse fazendo com que os processos fiquem 
 bloqueados. 
 E a thread_C assim que tentar alocar recursos de um periférico ocorre um impasse 
 impedindo os processos de continuar suas execuções porque o outro periférico está 
 sendo utilizado, e o semáforo ainda não registrou a liberação dos recursos.