Semáforos

1. Semáforos Eduardo Nicola F. Zagari Principles of Concurrent and Distributed Programming - Ben-Ari

2. Tópicos • Introdução • Invariâncias • Exclusão Mútua • Definições de Semáforos • O Problema do Produtor Consumidor • Buffers Infinitos • Buffers Limitados • Produtor Consumidor com Semáforos Binários

3. Introdução • Soluções anteriores usam apenas diretivas providas pela máquinas. • Muito baixo nível para ser eficiente e confiável • Semáforo é uma solução em nível mais alto • Implementados no sistema operacional

4. Introdução • Semáforo é uma variável inteira não negativa. São definidas apenas 2 operações num semáforo S: • P(S) ou Down(S): Se S > 0 então S := S – 1, senão suspende a execução deste processo. • V(S) ou Up(S): Se existem processos suspensos neste semáforo, acorda um deles, senão S := S + 1.

5. Introdução • O semáforo tem as seguintes propriedades: • P(S) e V(S) são atômicas • A todo semáforo deve ser atribuído um valor inicial não negativo (semáforos gerais versus semáforos binários) • A operação V(S) deve acordar um dos processos suspensos (a definição não especifica qual!)

6. Invariâncias • Um semáforo satisfaz as seguintes invariâncias: S >= 0 S = S0 + #V(S) - #P(S)

7. Exclusão Mútua S: Semaforo := 1; task body P1 is begin loop Regiao_Nao_Critica_1; P(S); Regiao_Critica_1; V(S); end loop; end P1; task body P2 is begin loop Regiao_Nao_Critica_2; P(S); Regiao_Critica_2; V(S); end loop; end P2;

8. Exclusão Mútua • Note que: • A propriedade de exclusão mútua é satisfeita; • O programa não sofre deadlock; • Não há starvation. • Similar à segunda tentativa do capítulo anterior, exceto pela atomicidade do pré e pós-protocolos. • Difere da instrução Test-and-Set pelo fato de que um processo suspenso num semáforo não executa instruções checando valor de variáveis provocando espera ocupada (busy-waiting).

9. Definições de Semáforos • Semáforo Blocked-set: Um processo que faz a operação “V” ( ou Up) acorda um dos processos suspensos. • P(S): Se S > 0, então S := S - 1, senão suspende a execução deste processo. • V(S): Se há processos que estão suspensos neste semáforo, acorde um deles, senão S := S + 1. • Semáforo Blocked-queue: Os processos suspensos são mantidos em uma fila FIFO e acordados na mesma ordem em que foram suspensos. • P(S): Se S > 0, então S := S - 1, senão suspende a execução deste processo. Ele é adicionado no fim da fila FIFO. • V(S): Se há processos que estão suspensos neste semáforo, acorde o processo do início da fila, senão S := S + 1.

10. Definições de Semáforos • Semáforo Busy-wait: o valor de S é testado em um laço de espera ocupada. O comando if inteiro é executado como uma operação atômica, mas pode haver intercalamento entre ciclos do laço. • P(S): loop if S > 0 then S := S - 1; exit; end if; end loop; • V(S): S := S + 1;

11. Teoremas • Teo 1: Para um semáforo busy-wait, é possível starvation. • Considere a seguinte seqüência de execução: • P1 executa P(S) e entra em sua seção crítica • P2 encontra S = 0 e entra no laço • P1 completa um ciclo inteiro consistindo do pós-protocolo, seção não crítica, pré-protocolo e entra novamente em sua seção crítica

12. Teoremas • Teo 2: Para um semáforo blocked-queue não é possível a ocorrência de starvation. • Teo 3: Para um semáforo blocked-set, é possível a ocorrência de starvation para N >= 3.

13. O Problema do Produtor-Consumidor • Produtores: estes processos criam um elemento de dados que deve ser enviado para os consumidores. • Consumidores: Ao receber um elemento de dados, estes processos realizam algum processamento • Solução elementar: comunicação síncrona • Solução mais flexível: introdução de buffer

14. Buffer Infinito B: array(0..infinity) of Integer; In_Ptr, Out_Ptr: Integer := 0; task body Producer is I: Integer; begin loop Produce(I); B(In_Ptr) := I; In_Ptr := In_Ptr + 1; end loop; end Producer; task body Consumer is I: Integer; begin loop Wait until In_Ptr > Out_Ptr; I := B(Out_Ptr); Out_Ptr := Out_Ptr + 1; Consume(I); end loop; end Consumer; ... Out_Ptr In_Ptr

15. Buffer Infinito B: array(0..infinity) of Integer; In_Ptr, Out_Ptr: Integer := 0; Elements: Semaphore := 0; task body Producer is I: Integer; begin loop Produce(I); B(In_Ptr) := I; In_Ptr := In_Ptr + 1; Up(Elements); end loop; end Producer; task body Consumer is I: Integer; begin loop Down(Elements); I := B(Out_Ptr); Out_Ptr := Out_Ptr + 1; Consume(I); end loop; end Consumer;

16. Buffer Finito • Buffer circular: • Pool de buffers: ... Out_Ptr In_Ptr ... In_Ptr Out_Ptr In_Ptr Pool Out_Ptr Producer Consumer

17. Buffer Circular Finito B: array(0..N-1) of Integer; In_Ptr, Out_Ptr: Integer := 0; Elements: Semaphore := 0; Spaces: Semaphore := N; task body Producer is I: Integer; begin loop Produce(I); Down(Spaces); B(In_Ptr) := I; In_Ptr := (In_Ptr+1) mod N; Up(Elements); end loop; end Producer; task body Consumer is I: Integer; begin loop Down(Elements); I := B(Out_Ptr); Out_Ptr := (Out_Ptr+1) mod N; Up(Spaces); Consume(I); end loop; end Consumer;

18. Considerações • O programa nunca remove um elemento de um buffer vazio nem insere elementos em um buffer cheio • O programa nunca provoca deadlock • Nunca há starvation em nenhum dos processos

19. Produtor Consumidor com Semáforos Binários B: array(0..N-1) of Integer; In_Ptr, Out_Ptr, Count: Integer := 0; S: Binary_Semaphore := 1; Not_Empty, Not_Full: Binary_Semaphore := 0; task body Consumer is I: Integer; Local_Count: Integer := 0; begin loop if Local_Count = 0 then Down(Not_Empty); end if; I := B(Out_Ptr); Down(S); Count := Count - 1; Local_Count := Count; Up(S); if Local_Count = N-1 then Up(Not_Full); end if; Out_Ptr := (Out_Ptr+1) mod N; Consume(I); end loop; end Consumer; task body Producer is I: Integer; Local_Count: Integer := 0; begin loop Produce(I); if Local_Count = N then Down(Not_Full); end if; B(In_Ptr) := I; Down(S); Count := Count + 1; Local_Count := Count; Up(S); if Local_Count = 1 then Up(Not_Empty); end if; In_Ptr := (In_Ptr+1) mod N; end loop; end Producer;

20. Apêndice • Tópico “avançado” em definição de semáforo...

21. Definições de Semáforos • Semáforo Strongly-fair: Se o semáforo faz a operação “V” (ou Up) com freqüência infinita, todo processo suspenso completará a instrução do semáforo. • Semáforo Weakly-fair: Se o semáforo é mantido em um valor maior que zero, todo processo suspenso completará a instrução do semáforo.

22. Definições de Semáforos • As definições dos tipos blocked-set, blocked-queue e busy-wait dizem respeito à forma como os semáforos são implementados. Já os strong e weak são definidos em termos de seu comportamento abstrato. • Um semáforo busy-wait é uma implementação de um semáforo fraco • Já o semáforo blocked-queue é um semáforo forte