O Problema da Exclusão Mútua
description
Transcript of O Problema da Exclusão Mútua
![Page 1: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/1.jpg)
O Problema da Exclusão Mútua
Eduardo Nicola F. Zagari
Principles of Concurrent and Distributed Programming - Ben-Ari
![Page 2: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/2.jpg)
Tópicos
• Introdução• Primeira Tentativa• Segunda Tentativa• Terceira Tentativa• Quarta Tentativa• Algoritmo de Dekker• Exclusão Mútua para N Processos• Exclusão Mútua Assistida por Hardware
![Page 3: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/3.jpg)
Introdução
• O problema da Exclusão Mútua para N processos:
1. N processos executando laços infinitos de instruções: regiões críticas (RC) e regiões não críticas (RNC). O programa deve satisfazer a propriedade de exclusão mútua (não intercalamento das regiões críticas)
2. A solução será descrita pela adição de um pré e um pós-protocolo executado pelo processo que deseja entrar/sair da RC
![Page 4: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/4.jpg)
Introdução
Forma da Solução de Exclusão Mútua
LoopRegião Não Crítica;Pré-Protocolo;Região Crítica;Pós-Protocolo;
End loop;
![Page 5: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/5.jpg)
Introdução
3. Um processo pode parar em sua RNC (neste caso, ele não deve interferir nos outros), mas não pode parar durante a execução dos protocolos nem da RC
4. Os processos não devem provocar bloqueio (deadlock) na tentativa de acessar suas RCs
5. Não deve haver inanição (starvation) de nenhum dos processos
6. No caso de não haver disputa pelo acesso à RC, o processo deve ser bem sucedido e com overhead mínimo
![Page 6: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/6.jpg)
Primeira Tentativa
task body P1 isbegin loop Regiao_Nao_Critica_1; loop exit when Turn = 1; end loop; Regiao_Critica_1; Turn := 2; end loop;end P1;
task body P2 isbegin loop Regiao_Nao_Critica_2; loop exit when Turn = 2; end loop; Regiao_Critica_2; Turn := 1; end loop;end P2;
Turn: Integer range 1..2 := 1;
![Page 7: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/7.jpg)
Primeira Tentativa
• Esta solução satisfaz os requisito de exclusão mútua
• A solução não causa deadlock
• Não há starvation
• Mas... A solução pode falhar no caso de ausência de disputa...
![Page 8: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/8.jpg)
Segunda Tentativa
task body P1 isbegin loop Regiao_Nao_Critica_1; loop exit when C2 = 1; end loop; C1 := 0; Regiao_Critica_1; C1 := 1; end loop;end P1;
task body P2 isbegin loop Regiao_Nao_Critica_2; loop exit when C1 = 1; end loop; C2 := 0; Regiao_Critica_2; C2 := 1; end loop;end P2;
C1, C2: Integer range 0..1 := 1;
![Page 9: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/9.jpg)
Segunda Tentativa
• Considere:– P1 verifica C2 e encontra C2 = 1– P2 verifica C1 e encontra C1 = 1– P1 ajusta C1 para 0– P2 ajusta C2 para 0– P1 entra na sua região crítica– P2 entra na sua região crítica
• Ou seja, nem mesmo o requisito básico de exclusão mútua é satisfeito...
![Page 10: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/10.jpg)
Terceira Tentativa
task body P1 isbegin loop Regiao_Nao_Critica_1; C1 := 0; loop exit when C2 = 1; end loop; Regiao_Critica_1; C1 := 1; end loop;end P1;
task body P2 isbegin loop Regiao_Nao_Critica_2; C2 := 0; loop exit when C1 = 1; end loop; Regiao_Critica_2; C2 := 1; end loop;end P2;
C1, C2: Integer range 0..1 := 1;
![Page 11: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/11.jpg)
Terceira Tentativa
• A solução satisfaz a propriedade de exclusão mútua
• Mas... Considere:– P1 atribui 0 para C1– P2 atribui 0 para C2– P1 testa C2 e permanece no loop– P2 testa C1 e permanece no loop...– Ou seja, deadlock...
![Page 12: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/12.jpg)
Quarta Tentativa
task body P1 isbegin loop Regiao_Nao_Critica_1; C1 := 0; loop exit when C2 = 1; C1 := 1; C1 := 0; end loop; Regiao_Critica_1; C1 := 1; end loop;end P1;
task body P2 isbegin loop Regiao_Nao_Critica_2; C2 := 0; loop exit when C1 = 1; C2 := 1; C2 := 0; end loop; Regiao_Critica_2; C2 := 1; end loop;end P2;
C1, C2: Integer range 0..1 := 1;
![Page 13: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/13.jpg)
Quarta Tentativa
• A solução satisfaz a propriedade de exclusão mútua• Mas...Um processo pode sofrer starvation! Considere:
– P1 atribui 0 para C1– P2 atribui 0 para C2– P2 testa C1 e então reseta C2 para 1– P1 executa o ciclo completo:
• Verifica C2• Entra na RC• Reseta C1• Executa sua RNC• Ajusta C1 para 0
– P2 atribui 0 para C2... Ou seja, voltamos ao início... Starvation de P2.
![Page 14: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/14.jpg)
Quarta Tentativa
• A solução pode ainda provocar uma “forma” de deadlock: o livelock (situação em que até que existe possibilidade de sucesso, mas pode acontecer dos 2 nunca conseguirem entrar na RC!). Exemplo:– P1 ajusta C1 para 0– P2 ajusta C2 para 0– P1 verifica C2 e permanece em loop– P2 verifica C1 e permanece em loop– P1 reseta C1 para 1– P2 reseta C2 para 1– P1 ajusta C1 para 0– P2 ajusta C2 para 0– P1 verifica C2 e permanece em loop– P2 verifica C1 e permanece em loop...
![Page 15: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/15.jpg)
Algoritmo de Dekker
task body P1 isbegin loop Regiao_Nao_Critica_1; C1 := 0; loop exit when C2 = 1; if Turn = 2 then C1 := 1; loop exit when Turn = 1; end loop; C1 := 0; end if; end loop; Regiao_Critica_1; C1 := 1; Turn := 2; end loop;end P1;
C1, C2: Integer range 0..1 := 1;Turn: Integer range 1..2 := 1;
task body P2 isbegin loop Regiao_Nao_Critica_2; C2 := 0; loop exit when C1 = 1; if Turn = 1 then C2 := 1; loop exit when Turn = 2; end loop; C2 := 0; end if; end loop; Regiao_Critica_2; C2 := 1; Turn := 1; end loop;end P2;
![Page 16: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/16.jpg)
Algoritmo de Dekker
• Satisfaz a propriedade de exclusão mútua
• Não provoca deadlock
• Nenhum processo pode sofrer starvation
• Na falta de disputa pela RC, um processo pode entrar em sua região crítica imediatamente
![Page 17: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/17.jpg)
Exclusão Mútua para N processosO Algoritmo da Padaria
task body P1 isbegin loop Regiao_Nao_Critica_1; N1 := 1; N1 := N2 + 1; loop exit when
N2 = 0 or N1 <= N2; end loop; Regiao_Critica_1; N1 := 0; end loop;end P1;
task body P2 isbegin loop Regiao_Nao_Critica_2; N2 := 1; N2 := N1 + 1; loop exit when
N1 = 0 or N2 < N1; end loop; Regiao_Critica_2; N2 := 0; end loop;end P2;
N1, N2: Integer range 0..1 := 0;
Para 2 processosPara 2 processos
![Page 18: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/18.jpg)
Exclusão Mútua para N processosO Algoritmo da Padaria
task body Pi is I: constant Integer := ...; /* Task id */begin loop Regiao_Nao_Critica_I; Escolhendo(I) := 1; Number(I) := 1 + max(Number); Escolhendo(I) := 0; for J in 1..N loop if J != I then loop exit when Escolhendo(J) = 0; end loop; loop exit when Number(J) = 0 or Number(I) < Number(J) or (Number(I) = Number(J) and I < J); end loop; end if; end loop; Regiao_Critica_I; Number(I) := 0; end loop;end Pi;
Escolhendo: array(1..N) of Integer := (others => 0);Number: array(1..N) of Integer := (others => 0);
Para N processosPara N processos
![Page 19: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/19.jpg)
Exclusão Mútua Assistida por Hardware
• Dificuldade em se obter exclusão mútua através de instruções que podem ser intercaladas
• Instruções Atômicas– Test and Set– Exchange
![Page 20: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/20.jpg)
Exclusão Mútua Assistida por Hardware
Li := C;C := 1;
task body Pi is Li: Integer range 0..1;begin loop Regiao_Nao_Critica_i; loop Test_and_Set(Li); exit when Li = 0; end loop; Regiao_Critica_i; C := 0; end loop;end Pi;
Para N processosPara N processosInstrução Test_and_Set(Li) :Instrução Test_and_Set(Li) :
C: Integer range 0..1 := 0;
![Page 21: O Problema da Exclusão Mútua](https://reader036.fdocuments.us/reader036/viewer/2022070404/56813af1550346895da36986/html5/thumbnails/21.jpg)
Exclusão Mútua Assistida por Hardware
Temp := A;A := B;B := Temp;
task body Pi is Li: Integer range 0..1 := 0;begin loop Regiao_Nao_Critica_i; loop Exchange(C,Li); exit when Li = 1; end loop; Regiao_Critica_i; Exchange(C,Li); end loop;end Pi;
Para N processosPara N processosInstrução Exchange(A,B) :Instrução Exchange(A,B) :
C: Integer range 0..1 := 1;