A maior rede de estudos do Brasil

SISTEMAS OPERACIONAIS

Foi desenvolvido um sistema que possui três procedimentos que são executados 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 desses 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, esse 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 será 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.

O procedimento “processa_algo()” simplesmente representa alguma tarefa que o realiza em determinados momentos.

Linhas de comando:

pthread_create(thread_A, Proc_A);

pthread_create(thread_B, Proc_B);

pthread_create(thread_C, Proc_C);

As linhas de comando acima 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 de 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.

---------

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();

         libera_plotter();

  Fim Enquanto;

Fim;

 

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;

 

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;

 

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.

Faça a verificação do algoritmo apresentado apontando, em um documento no formato PDF, os erros que podem levar ao funcionamento incorreto do sistema. No documento, deverão 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.

13 resposta(s)

User badge image

Pietro Lima

Há mais de um mês

Acredito que essa é a 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.

 

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); // 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.

 

 

Resumindo, 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.

Acredito que essa é a 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.

 

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); // 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.

 

 

Resumindo, 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.

User badge image

Di Snows

Há mais de um mês

galera da uva top kk

 

User badge image

Jose Alyson

Há mais de um mês

"Cada um desses 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, esse segundo procedimento ficará bloqueado até que o procedimento que detém o recurso o libere."

Ou seja...se vc alocar (1) e quiser alocar alguma outra coisa vc precisa liberar esse (1) para alocar essa outra coisa

Essa pergunta já foi respondida por um dos nossos estudantes