Implementação de Sincronização n Protocolos que usam busy waiting:  Difíceis de projetar, compreender e provar corretos  Complexos  Variáveis usadas.

Apresentação em tema: "Implementação de Sincronização n Protocolos que usam busy waiting:  Difíceis de projetar, compreender e provar corretos  Complexos  Variáveis usadas."— Transcrição da apresentação:

1 Implementação de Sincronização n Protocolos que usam busy waiting:  Difíceis de projetar, compreender e provar corretos  Complexos  Variáveis usadas para sincronizar são idênticas às outras variáveis do programa  ineficientes

2 Solução n usar ferramentas especiais para ajudar a projetar protocolos de sincronização corretos, e bloqueiam processos em espera.

3 Semáforos n Foi uma das primeiras “ferramentas” n Uma das mais importantes n Torna fácil proteger regiões críticas n Pode ser usado de forma disciplinada para implementar sincronização de condição n Podem ser implementados com busy-waiting ou interagir com o escalonador de processos para obter sincronização sem busy-waiting

4 Semáforo n Tipo abstrato de dados, com duas operações:  P(S)  Também chamada de wait  Atrasa um processo até que um evento ocorra.  V(S)  Também chamado de signal  Sinaliza a ocorrencia de um evento

5 Invariante do Semáforo n Para um semáforo s, seja nP o número de operações P completadas e nV o número de operações V completadas. Se init é o valor inicial de s, então, em todos os estados visíveis, nP  nV + init n Execução de operações P esperam até que um número adequado de operações V tenha ocorrido

6 Representação de um Semáforo n Número não negativo n s = init + nV – nP n Invariante: s  0

7 Representação de um Semáforo  P (s)  0) -> s := s – 1>  V (s) 

8 Tipos de Semáforos n Semáforo genérico  assume valores não negativos n Semáforo binário  assume apenas valores 0 ou 1

9 Região Crítica n sem_t S = 1; void Pi { while (TRUE) { Non_Cr_S_i; P(S); Critical_S_i; V(S); } }

10 A propriedade de exclusão mútua é satisfeita n #CS é o número de processos em sua região crítica n provar que #CS + S = 1  #CS = nP(S) - nV(S)  S = 1 + nV(S) - nP(S)  S = 1 - #CS  #CS + S = 1 n como S >= 0, então #CS <= 1

11 O programa não entra em deadlock n os processos teriam que estar suspensos em P(S) n teríamos S = 0 e #CS = 0 n mas já mostramos que #CS + S = 1  contradição

12 não há starvation n Se P1 está suspenso, o semáforo deve ter 0 n Pelo invariante do semáforo, P2 está na região crítica n Quando P2 sai da região crítica, executa V(S), que acorda um processo (P1)

13 Definições de semáforos n Blocked-set semaphore  um sinal acorda um dos processos suspensos n Blocked-queue semaphore  os processos suspensos são mantidos em uma fila FIFO e são acordados na mesma ordem em que foram suspensos

14 Definições de semáforos n Busy-wait semaphore  processos ficam testando o valor de S em um loop de busy-wait. O teste é atômico.

15 Definições de semáforos n Strongly-fair semaphore  se o semáforo é sinalizado infinatamente frequente, em algum momento todos os processos esperando serão acordados. n Weakly-fair semaphore  se o semáforo é mantido com um valor maior que zero, em algum momento todos os processos esperando serão atendidos.

16 Provas n em um semáforo de busy-wait, pode ocorrer starvation  P1 executa P(S) e entra na região crítica  P2 encontra S = 0 e fica no loop  P1 executa todo um ciclo, e reentra na região crítica  P2 encontra S = 0 e fica no loop

17 Provas n em um semáforo blocked-queue, é impossível ocorrer starvation  suponha P1 bloqueado em S  então existem no máximo N - 1 processos na frente de P1 na fila para S

18 Provas n em um semáforo blocked-set, é possível ocorrer starvation para N >= 3  como não há garantia de qual processo será acordado, se houverem pelo menos 2 processos bloqueados, um deles pode ser sempre o escolhido.

19 Barreiras n sem_t barrier1 = 0; sem_t barrier2 = 0; void P1 { while (TRUE) {...; V(barrier1); P(barrier2); } } void P2 { while (TRUE) {...; V(barrier2); P(barrier1); } }

20 Problema do Produtor- Consumidor n Problema de comunicação n Produtores  geram dados com o procedimento Produce, que devem ser enviados aos consumidores n Consumidores  ao receberem um dado fazem alguma computação, com o procedimento Consume

21 Buffer de tamanho 1 n int B; sem_t empty = 1; sem_t full = 0; void Producer { int m; while (TRUE) { Produce(m); P(empty); B = m; V(full); } } void Consumer { int m; while (TRUE) { P(full); m = B; V(empty); Consume(m); } }

22 Buffer limitado (circular) n int B[n]; int front = 0; int rear = 0; sem_t empty = n; sem_t full = 0; void Producer { int m; while (TRUE) { Produce(m); P(empty); B[rear] = m; rear = (rear + 1) % n V(full); } } void Consumer { int m; while (TRUE) { P(full); m = B[front]; front = (front + 1) % n V(empty); Consume(m); } }

23 Buffer limitado – com vários produtores e consumidores n int B[n]; int front = 0; int rear = 0; sem_t empty = n; sem_t full = 0; sem_t mutexD = 0; sem_t mutexF = 0; void Producer { int m; while (TRUE) { Produce(m); P(empty); P(mutexD); B[rear] = m; rear = (rear + 1) % n V(mutexD); V(full); } } void Consumer { int m; while (TRUE) { P(full); P(mutexF); m = B[front]; front = (front + 1) % n V(mutexF); V(empty); Consume(m); } }

24 Exclusão mútua seletiva n Jantar dos filósofos  Processos competem por acesso a conjuntos sobrepostos de variáveis compartilhadas n Leitores e Escritores  Combinação de acesso concorrente e exclusivo a variáveis compartilhadas

25 Jantar dos filósofos n Cinco filósofos ao redor de uma mesa redonda n Cada filósofo alterna entre comer e pensar n O spaghetti está no centro da mesa n Filósofos precisam de dois garfos para se alimentar n Existem 5 garfos, um entre cada par de filósofos n Evitar deadlock, e outras propriedades.

26 Jantar dos Filósofos Fil. 2 Fil. 3 Fil. 4 Fil. 0 Fil. 1

27 Solução n sem_t fork[4] = 1; n void Philosopher[i] { /* filósofo 1 a 4 */ while (TRUE) { Think; P(fork[i]); P(fork[(i+1) % 5]); Eat; V (fork[i]); V (fork[(i+1) % 5]); } }

28 Solução 2 n sem_t fork[4] = 1; n void Philosopher[i] { /* filósofo 0 a 3 */ while (TRUE) { Think; P(fork[i]); P(fork[(i+1) % 5]); Eat; V (fork[i]); V (fork[(i+1) % 5]); } }

29 Solução 2 (cont.) n sem_t fork[4] = 1; n void Philosopher[4] { /* filósofo 4 */ while (TRUE) { Think; P(fork[0]); P(fork[4]); Eat; V (fork[4]); V (fork[0]); } }

30 Leitores e Escritores n Dois tipos de processos: leitores e escritores, compartilham o acesso a uma base de dados. n Leitores lêem valores da base de dados. n Escritores escrevem na base de dados. n A Base de dados está inicialmente em um estado consistente. n Cada transação transforma a base de dados de um estado consistente em outro.

31 Leitores e Escritores n Para evitar interferência o escritor deve ter acesso exclusivo à base de dados n Se nenhum escritor estiver acessando a base de dados, vários leitores podem ler concorrentemente a base de dados n Exclusão mútua seletiva

32 Solução n Variáveis para controlar leitores e escritores reading, writing[n]

33 Esboço da Solução n int reading = 0; int nr = 0; int writing[n] = 0; void Reader[i] { while (TRUE) { read the database } } void Writer[i] { while (TRUE) { write the database } }

34 Solução de grossa granularidade n int reading = 0; int nr = 0; int writing[n] = 0; void Reader[i] { while (TRUE) { reading++};> read the database } } void Writer[i] { while (TRUE) { writing[i]++;> write the database } }

35 Solução de grossa granularidade n int reading = 0; int nr = 0; int writing[n] = 0; sem_t mutexR = 1; void Reader[i] { while (TRUE) { P(mutexR); nr++; if (nr == 1) { reading++>}; V(mutexR); read the database P(mutexR); nr--; if (nr == 0) { }; V(mutexR); } }

36 Solução n int nr = 0; sem_t mutexR = 1; sem_t rw = 1; void Reader[i] { while (TRUE) { P(mutexR); nr++; if (nr == 1) {P(rw)}; V(mutexR); read the database P(mutexR); nr--; if (nr == 0) {V(rw)}; V(mutexR); } }

37 Solução n void Writer[i] { while (TRUE) { P(rw); write the database V(rw); } }

38 Solução n Prioridade para os escritores n Outra solução: controlar quais processos estão em espera, e escolher outro tipo de prioridade  contar número de leitores e escritores na região crítica (nr, nw), número de leitores e escritores esperando (dr, dw).

39 Solução 2 n int nr = 0; nw = 0; sem_t e = 1; sem_t r = 0; sem_t w = 0; int dr = 0; int dw = 0;

40 Solução 2 n void Reader[i] { while (TRUE) { P(e); if (nw > 0) {dr++; V(e); P(r)}; nr++; if (dr > 0) {dr--; V(r)} else {V(e)}; read the database P(e); nr--; if (nr == 0 && dw > 0) {dw--;V(w)} else {V(e)}; } }

41 Solução 2 n void Writer[i] { while (TRUE) { P(e); if (nr > 0 || nw > 0) {dw++; V(e); P(w)}; nw++; V(e); read the database P(e); nw--; if (dr > 0) {dr--;V(r)} else {if (dw > 0) {dw--;V(w)} else {V(e)}}; } }