1 / 21

O Problema da Exclusão Mútua

O Problema da Exclusão Mútua. Eduardo Nicola F. Zagari Principles of Concurrent and Distributed Programming - Ben-Ari. Tópicos. Introdução Primeira Tentativa Segunda Tentativa Terceira Tentativa Quarta Tentativa Algoritmo de Dekker Exclusão Mútua para N Processos

hume
Télécharger la présentation

O Problema da Exclusão Mútua

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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;

More Related