Download - Semáforos Eduardo Nicola F. Zagari Principles of Concurrent and Distributed Programming - Ben-Ari
Semáforos
Eduardo Nicola F. Zagari
Principles of Concurrent and Distributed Programming - Ben-Ari
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
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
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.
Introdução
• O semáforo tem as seguintes propriedades:
1. P(S) e V(S) são atômicas
2. A todo semáforo deve ser atribuído um valor inicial não negativo (semáforos gerais versus semáforos binários)
3. A operação V(S) deve acordar um dos processos suspensos (a definição não especifica qual!)
Invariâncias
• Um semáforo satisfaz as seguintes invariâncias:
S >= 0
S = S0 + #V(S) - #P(S)
Exclusão Mútua
task body P1 isbegin loop Regiao_Nao_Critica_1; P(S); Regiao_Critica_1; V(S); end loop;end P1;
task body P2 isbegin loop Regiao_Nao_Critica_2; P(S); Regiao_Critica_2; V(S); end loop;end P2;
S: Semaforo := 1;
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).
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.
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;
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
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.
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
Buffer Infinito
task body Producer isI: Integer;begin loop Produce(I); B(In_Ptr) := I; In_Ptr := In_Ptr + 1; end loop;end Producer;
B: array(0..infinity) of Integer;In_Ptr, Out_Ptr: Integer := 0;
task body Consumer isI: 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
Buffer Infinito
task body Producer isI: Integer;begin loop Produce(I); B(In_Ptr) := I; In_Ptr := In_Ptr + 1; Up(Elements); end loop;end Producer;
B: array(0..infinity) of Integer;In_Ptr, Out_Ptr: Integer := 0;Elements: Semaphore := 0;
task body Consumer isI: Integer;begin loop Down(Elements); I := B(Out_Ptr); Out_Ptr := Out_Ptr + 1; Consume(I); end loop;end Consumer;
Buffer Finito• Buffer circular:
• Pool de buffers:
...
Out_Ptr In_Ptr...
Out_Ptr In_Ptr
Consumer
In_Ptr
Producer
PoolOut_Ptr
Buffer Circular Finito
task body Producer isI: Integer;begin loop Produce(I); Down(Spaces); B(In_Ptr) := I; In_Ptr := (In_Ptr+1) mod N; Up(Elements); end loop;end Producer;
B: array(0..N-1) of Integer;In_Ptr, Out_Ptr: Integer := 0;Elements: Semaphore := 0;Spaces: Semaphore := N;
task body Consumer isI: Integer;begin loop Down(Elements); I := B(Out_Ptr); Out_Ptr := (Out_Ptr+1) mod N; Up(Spaces); Consume(I); end loop;end Consumer;
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
Produtor Consumidor com Semáforos Binários
task body Producer isI: 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;
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 isI: 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;
Apêndice
• Tópico “avançado” em definição de semáforo...
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.
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