Alocação de recursos

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