AVA2 SISTEMAS OPERACIONAIS

Prévia do material em texto

UNIVERSIDADE VEIGA DE ALMEIDA 
SISTEMAS OPERACIONAIS 
PROFESSOR: FABIO CONTARINI CARNEIRO 
NOME: ALEX FERREIRA CANEL 
MATRICLA: 20202300499 
 
 
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 
 
1. Algoritmo "concorrentes" 
2. 
3. Var 
4. // Variaveis de controle das threads 
5. thread thread_A, thread_B, thread_C: thread; 
6. // Semaforos de controle 
7. sema_impressora, sema_plotter, sema_scanner: semaforo; 
8. 
9. Procedimento Proc_A() 
10. Início 
11. Enquanto (verdadeiro) Faça // Procedimento nunca termina 
12. processa_algo(); 
13. aloca_plotter(); 
14. processa_algo_utilizando_plotter(); 
15. libera_plotter(); 
16. Fim Enquanto; 
17. Fim; 
18. 
19. Procedimento Proc_B() 
20. Início 
21. Enquanto (verdadeiro) Faça // Procedimento nunca termina 
22. processa_algo(); 
23. aloca_scanner(); 
24. processa_algo_utilizando_scanner(); 
25. aloca_impressora(); 
26. processa_algo_utilizando_scanner_impressora(); 
27. aloca_plotter(); 
28. processa_algo_utilizando_scanner_impressora_plotter(); 
29. libera_plotter(); 
30. libera_impressora(); 
31. libera_scanner(); 
32. Fim Enquanto; 
33. Fim; 
34. 
35. Procedimento Proc_C() 
36. Início 
37. Enquanto (verdadeiro) Faça // Procedimento nunca termina 
38. processa_algo(); 
39. aloca_impressora(); 
40. processa_algo_utilizando_impressora(); 
41. aloca_scanner(); 
42. processa_algo_utilizando_scanner_impressora(); 
43. libera_impressora(); 
44. libera_scanner(); 
45. Fim Enquanto; 
46. Fim; 
47. Início 
48. sema_impressora = 1; // Inicia semaforo de controle da impressora 
49. sema_plotter = 1; // Inicia semaforo de controle do plotter 
50. sema_scanner = 1; // Inicia semaforo de controle do scanner 
51. // Inicia as threads colocando-as em execução paralelamente 
52. pthread_create(thread_A, Proc_A); // Inicia Proc_A como uma thread 
53. pthread_create(thread_B, Proc_B); // Inicia Proc_A como uma thread 
54. pthread_create(thread_C, Proc_C); // Inicia Proc_A como uma thread 
55. // faz com que a thread principal espere as demais acabarem 
56. pthread_join(thread_A); 
57. pthread_join(thread_B); 
58. pthread_join(thread_C); 
59. Fim. 
60. 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 
 
 
 
 
RESPOSTAS 
1 -Analisando a linha a linha do código pude perceber que está entre as linhas 23 a 31 
e 38 a 44. 
2 - Devido os recursos serem compartilhados e terem um acesso exclusivo temporário 
a eles (um processo por vez), está ocorrendo um Deadlock (Impasse) pois um processo quer o 
recurso que está alocado com outro processo e como resultado os dois ficam parados sem 
poder continuar. 
3 - Uma correção seria desalocar temporariamente (preempção) os recursos quando 
eles já foram utilizados pelo processo, ao invés do ficar retendo liberar o recurso para o outro 
processo usar. 
20 Início 
21 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
22 processa_algo(); 
23 aloca_scanner(); 
24 processa_algo_utilizando_scanner(); 
25 libera_scanner(); 
26 aloca_impressora(); 
27 aloca_scanner(); 
28 processa_algo_utilizando_scanner_impressora(); 
29 aloca_plotter(); 
30 processa_algo_utilizando_scanner_impressora_plotter(); 
31 libera_plotter(); 
32 libera_impressora(); 
33 libera_scanner(); 
34 Fim Enquanto; 
35 Fim; 
36 
37 Procedimento Proc_C() 
38 Início 
39 Enquanto (verdadeiro) Faça // Procedimento nunca termina 
40 processa_algo(); 
41 aloca_impressora(); 
42 processa_algo_utilizando_impressora(); 
43 aloca_scanner(); 
44 processa_algo_utilizando_scanner_impressora(); 
45 libera_impressora(); 
46 libera_scanner(); 
47 Fim Enquanto; 
48 Fim;