ava 2 sistemas operacionais

Prévia do material em texto

UVA- Universidade Veiga De Almeida
Sistemas de Informação
Aluno: Pedro Henrique Veloso De Araújo
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;
7/ Semaforos de controle
sema_impressora, sema_plotter, sema_scanner: semaforo:
Procedimento Proc A()
Inicio
Enquanto (verdadeiro) Faca // Procedimento nunca termina
processa_algo0
aloca_plotter0:
processa_algo();
libera_plotter0):
Fim Enquanto;
Fim:
//Proc_A() aloca o potter, processa e depois libera
Procedimento Proc_B(
Início
Enquanto (verdadeiro) Faça // Procedimento nunca termina Procedimento Proc_B0
Inicio
Enquanto (verdadeiro) Faça // Procedimento nunca termina processa_algo();
aloca_scanner0);
processa_algo();
aloca_impressora();
processa_algo():
aloca_plotter0:
processa_algo();
libera_plotter0):
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_algol();
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 conseguira 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): //Inicia
Proc_A como uma thread
pthread_create(thread_C,Proc_C);//IniciaProc_Acomoumathread
// 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, feitoisto 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 causara 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.