O Problema da Exclusão Mútua

1. O Problema da Exclusão Mútua Eduardo Nicola F. Zagari Principles of Concurrent and Distributed Programming - Ben-Ari

2. 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

3. Introdução • O problema da Exclusão Mútua para N processos: • 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) • 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

4. Introdução Loop Região Não Crítica; Pré-Protocolo; Região Crítica; Pós-Protocolo; End loop; Forma da Solução de Exclusão Mútua

5. Introdução • 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 • Os processos não devem provocar bloqueio (deadlock) na tentativa de acessar suas RCs • Não deve haver inanição (starvation) de nenhum dos processos • No caso de não haver disputa pelo acesso à RC, o processo deve ser bem sucedido e com overhead mínimo

6. Primeira Tentativa Turn: Integer range 1..2 := 1; task body P1 is begin loop Regiao_Nao_Critica_1; loop exit when Turn = 1; end loop; Regiao_Critica_1; Turn := 2; end loop; end P1; task body P2 is begin loop Regiao_Nao_Critica_2; loop exit when Turn = 2; end loop; Regiao_Critica_2; Turn := 1; end loop; end P2;

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

8. Segunda Tentativa C1, C2: Integer range 0..1 := 1; task body P1 is begin 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 is begin loop Regiao_Nao_Critica_2; loop exit when C1 = 1; end loop; C2 := 0; Regiao_Critica_2; C2 := 1; end loop; end P2;

9. 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...

10. Terceira Tentativa C1, C2: Integer range 0..1 := 1; task body P1 is begin 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 is begin loop Regiao_Nao_Critica_2; C2 := 0; loop exit when C1 = 1; end loop; Regiao_Critica_2; C2 := 1; end loop; end P2;

11. 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...

12. Quarta Tentativa C1, C2: Integer range 0..1 := 1; task body P1 is begin 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 is begin 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;

13. 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.

14. 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...

15. Algoritmo de Dekker C1, C2: Integer range 0..1 := 1; Turn: Integer range 1..2 := 1; task body P2 is begin 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; task body P1 is begin 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;

16. 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

17. Exclusão Mútua para N processosO Algoritmo da Padaria N1, N2: Integer range 0..1 := 0; task body P1 is begin 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; Para 2 processos task body P2 is begin 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;

18. Exclusão Mútua para N processosO Algoritmo da Padaria Escolhendo: array(1..N) of Integer := (others => 0); Number: array(1..N) of Integer := (others => 0); 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; Para N processos

19. 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

20. Exclusão Mútua Assistida por Hardware C: Integer range 0..1 := 0; Para N processos Instrução Test_and_Set(Li) : 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;

21. Exclusão Mútua Assistida por Hardware C: Integer range 0..1 := 1; Para N processos Instrução Exchange(A,B) : 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;