Soluções por software para problemas de exclusão mútua., Trabalhos de Informática

Baixe Soluções por software para problemas de exclusão mútua. e outras Trabalhos em PDF para Informática, somente na Docsity!

FGP – Pederneiras

Soluções por software para problemas de

exclusão mútua.

Aluno: José Ivan Marciano Junior Turma: 2º ano SIS RA: 100102211

Condições de corrida Condições de corrida são situações onde dois ou mais processos acessam dados compartilhados e o resultado final depende da ordem em que os processos são executados. A ordem de execução é ditada pelo mecanismo de escalonamento do S.O.

Condições de corrida são evitadas através da introdução de mecanismos de exclusão mútua, esta garante que somente um processo estará usando os dados compartilhados num dado momento.

Região crítica é uma parte do programa, entenda-se por trecho do código, onde os dados compartilhados são acessados.

Portanto, o objetivo da exclusão mútua é proibir que mais de um processo entre em sua Região Crítica.

Exemplo:

 P1 invoca echo() e é interrompido imediatamente após a conclusão da função input(). Suponha que x tenha sido o caractere digitado, que agora está armazenado na variável in.  P2 é despachado e também invoca echo(). Suponha que y seja digitado ( in recebe y ), sendo então exibido no dispositivo de saída.  P1 retoma a posso do processador. O caractere exibido não é o que foi digitado ( x ), pois ele foi sobreposto por y na execução do processo P2. Conclusão: o caractere y é exibido duas vezes.  Essência do problema: o compartilhamento da variável global in.

Procedure echo(); var out, in: character; begin input (in, keyboard); out := in; output (out, display) end.

Solução de Decker Trata-se da primeira solução correta para o problema da exclusão mútua de dois processos (proposta na década de 60).

O algoritmo combina as idéias da variável de bloqueio e o array de intenção.

Algoritmo de Decker

 Quando P0 quer entrar na sua R.C. ele coloca seu flag em true. Ele então vai checar o flag de P1 ;  Se o flag de P1 for false , então P0 pode entrar imediatamente na sua R.C.; do contrário, ele consulta a variável turn ;

Var flag: array[0..1] of boolean; Turn: 0..1 //quem terá a prioridade flag[0]:= false flag[1]:= false turn :=

Processo p0: flag[0] := true while flag[1] { if turn != 0 { flag[0] := false while turn != 0 { } // busy wait flag[0] := true } } // seção crítica …… // fim da seção crítica turn := 1 flag[0] := false

Processo p1: flag[1] := true while flag[0] { if turn != 1 { flag[1] := false while turn != 1 { } // busy wait flag[1] := true } } // seção crítica …… // fim da seção crítica turn := 0 flag[1] := false

 Se turn = 0 então P0 sabe que é a sua vez de insistir e, deste modo, fica em busy wait testando o estado de P1 ;  Em certo ponto, P1 notará que é a sua vez de declinar. Isso permite ao processo P0 prosseguir;  Após P0 usar a sua R.C. ele coloca o seu flag em false para liberá-la, e faz turn = 1 para transferir o direito para P. O algoritmo de Decker resolve o problema da exclusão mútua, demostrando que é possível resolver o problema inteiramente por software, sem exigir instruções de máquina especiais. Porém o algoritmo não trata a solução para mais de dois processos.

Solução de Peterson Proposto em 1981, é uma solução simples e elegante para o problema da exclusão mútua, sendo facilmente generalizado para o caso de n processos. O truque do algoritmo consiste em ao marcar a sua intenção de entrar, o processo já indica (para o caso de empate) que a vez é do outro.

Algoritmo de Peterson

flag[0] := false; flag[1] := false; turn := 0;

Processo p0: flag[0] := true turn := 1 while ( flag[1] && turn == 1) { // busy wait } // região crítica … // fim da região crítica flag[0] := false

Processo p1: flag[1] := true turn := 0 while ( flag[0] && turn == 0) { // busy wait } // região crítica … // fim da região crítica flag[1] := false