A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

IC - UFF Sistemas Operacionais 3. Concorrência Texto base: capítulo 2 Modern Operating Systems A.S. Tanenbaum.

Apresentações semelhantes


Apresentação em tema: "IC - UFF Sistemas Operacionais 3. Concorrência Texto base: capítulo 2 Modern Operating Systems A.S. Tanenbaum."— Transcrição da apresentação:

1 IC - UFF Sistemas Operacionais 3. Concorrência Texto base: capítulo 2 Modern Operating Systems A.S. Tanenbaum

2 IC - UFF O que envolve? l O conceito de concorrência envolve n compartilhamento de recursos: problema fundamental da exclusão mútua n sincronização entre processos n comunicação entre processos

3 IC - UFF Algumas dificuldades l Compartilhamento de recursos globais n e.g., variáveis globais: leituras e escritas l Gerenciamento da alocação de recursos n e.g., uma unidade de E/S deve ficar alocada a um processo suspenso? l Localização de erros em programas n e.g., como reproduzir situações?

4 IC - UFF Corrida abc prog.c prog.n lista do spooler out = 4 in = 7 daemon de impressão processo A processo B impressora

5 IC - UFF Compartilhando código echo () char in, out; { in = getch(); out = in; putchar(out); }

6 IC - UFF Logo... l Resultado da execução de um processo deve ser independente da velocidade de execução deste processo relativamente a outros processos concorrentes l Atenção: o problema também ocorre em multiprocessadores

7 IC - UFF Concorrência: problemas l Exclusão mútua n seções críticas l Bloqueio n P 1 com R 1 e precisa de R 2 n P 2 com R 2 e precisa de R 1 l Esfomeação n P 1, P 2 e P 3 querem R; suponha P 1 e P 2 passando o controle um para o outro

8 IC - UFF Requisitos: exclusão mútua Ê Dois processos não podem estar simultâneamente em suas seções críticas Ë Nenhuma hipótese deve ser feita sobre a velocidade ou número de processadores Ì Nenhum processo fora de sua crítica pode bloquear outro processo Í Nenhum processo deve esperar indefinidamente para entrar em sua seção crítica

9 IC - UFF Espera ocupada (1) l Desabilitando interrupções n solução mais simples: desabilita antes de entrar na seção crítica; habilita antes de sair n dá muito poder a processos do usuário n não funciona quando existe mais de um processador n útil no núcleo do SO

10 IC - UFF Espera ocupada (2) l Alternância estrita l Não é boa idéia quando um processo é muito mais lento que o outro (cond. 3) while (TRUE) { while (vez != 1);/*espera*/ seção_crítica(); vez = 0; seção_não_crítica(); } while (TRUE) { while (vez != 0);/*espera*/ seção_crítica(); vez = 1; seção_não_crítica(); }

11 IC - UFF Solução de Peterson #define FALSE0 #define TRUE1 #define N2/* número de processos */ int turn;/* de quem é a vez? */ int interested[N];/* inicialmente 0 (FALSE) */ void enter_region (int process) { int other;/* número do outro processo */ other = 1 - process; interested[process] = TRUE;/* indique seu interesse */ turn = process;/* set flag */ while (turn == process && interested[other] == TRUE); } void leave_region int process) { interested[process] = FALSE;/* indica saída da região crítica */ }

12 IC - UFF Ainda a espera ocupada l A instrução TSL (test and set lock) n lê o conteúdo de uma palavra de memória e armazena um valor: operação indivisível n a UCP que executa TSL bloqueia o barramento de memória: nenhuma outra UCP acessa memória durante ciclo da TSL n uso de uma variável compartilhada para coordenar o acesso à memória (flag, no exemplo)

13 IC - UFF Uso da TSL enter_region: tsl register, flag| register flag e flag 1 cmp register, #0| flag era zero? jnz enter_region| se não era zero, continue testando ret| retorna; entrou na região crítica leave_region: mov flag, #0| flag 0 ret| retorna

14 IC - UFF Inversão de prioridades? l Exemplo: n dois processos, A (alta) e B (baixa) n B na região crítica; A torna-se pronto n A inicia espera ocupada; B nunca sairá da seção crítica n A fica em espera eterna

15 IC - UFF Bloqueio espera ocupada l A espera ocupada implica em desperdício de tempo de UCP l Vejamos primitivas que bloqueiam em vez de desperdiçar tempo de UCP quando acesso à seção crítica é negado: sleep() e wakeup(p)

16 IC - UFF l Dois processos compartilham um buffer de tamanho fixo: um coloca informação e o outro retira Produtor-consumidor (P-C) buffer [N] produtor consumidor assincronismo

17 IC - UFF O produtor #define N 100 int count = 0; void producer (void) { int item; while (TRUE) { produce_item (&item); if (count == N) sleep();/* espere, se buffer cheio*/ enter_item (item); count = count + 1; if (count == 1) wakeup (consumer); /* buffer vazio? */ }

18 IC - UFF O consumidor void consumer (void) { int item; while (TRUE) { if (count == 0) sleep();/* espere, se buffer vazio*/ remove_item (&item); count = count - 1; if (count == N-1) wakeup(producer); /* buffer cheio? */ consume_item(item); }

19 IC - UFF Acesso irrestrito a variável l Variável count: n buffer vazio, consumidor lê count=0, escalonador pára de executar consumidor e dispara produtor n produtor produz um item, incrementa count, chama wakeup(consumidor) n consumidor não estava dormindo: sinal de wakeup é perdido n consumidor é escalonado e vai dormir; produtor enche o buffer e vai dormir

20 IC - UFF Semáforo l Variável especial, chamada semáforo, é usada para sinalização l Se um processo está esperando por um sinal, ele será suspenso até receber o sinal l Operações de sinal e espera: atômicas l Uso de fila para manter processos que esperam no semáforo

21 IC - UFF P-C com semáforos #define N 100 typedef int semaphore; semaphore mutex = 1; /* controla acesso à região crítica */ semaphore empty = N; /* conta lugares vazios */ semaphore full = 0; /* conta lugares cheios */ void producer (void) { int item; while (TRUE) { produce_item (&item); down (&empty); down (&mutex); /* entra região crítica */ enter_item (item); up (&mutex); /* sai da região crítica */ up (&full); } void consumer (void) { int item; while (TRUE) { down (&full); down (&mutex); /* entra região crítica */ remove_item (&item); up (&mutex); /* sai da região crítica */ up (&empty); consume_item (item); } para sincronização para exclusão mútua

22 IC - UFF O problema dos filósofos

23 IC - UFF Uma primeira solução... #define N 5/* número de filósofos */ void philosopher (int i) { while (TRUE) { think(); take_fork (i);/* pega garfo à esquerda */ take_fork ((i+1)%N);/* pega garfo à direita */ eat (); put_fork (i);/* devolve garfo da esquerda */ put_fork ((i+1)%N);/* devolve garfo da direita */ }

24 IC - UFF Problemas! l Se todos pegarem o garfo da esquerda (direita) simultâneamente teremos bloqueio (deadlock) l Variação: pega o da esquerda, testa o da direita. Contudo se todos fizerem isso simultâneamente teremos esfomeação l Solução: proteger região crítica com semáforo: possível perda de paralelismo

25 IC - UFF... uma solução #define N5 #define LEFT(i-1)%N #define RIGHT(i+1)%N #define THINKING0 #define HUNGRY1 #define EATING2 typedef int semaphore; int state[N];/* array para guardar estado de cada filósofo */ semaphore mutex = 1;/* exclusão mútua para a região crítica */ semaphore s[N];/* um semáforo por filósofo */

26 IC - UFF... uma solução (cont.) void philosopher (int i) { while (TRUE) { think(); take_forks(i); eat(); put_forks(i); }

27 IC - UFF... uma solução (cont.) void take_forks (int i) { down (&mutex);/* entra região crítica */ state[i] = HUNGRY; test(i);/* tenta pegar dois garfos */ up (&mutex);/* sai da região crítica */ down (&s[i]);/* bloqueia se não pegou ambos os garfos */ } test()

28 IC - UFF... uma solução (cont.) void put_forks (int i) { down (&mutex);/* entra região crítica */ state[i] = THINKING; test (LEFT);/* vizinho da esquerda pode comer? */ test (RIGHT);/* vizinho da direita pode comer? */ up (&mutex);/* sai da região crítica */ } test()

29 IC - UFF... uma solução (cont.) void test (int i) { if (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) { state[i] = EATING; up (&s[i]); } para i corrente! sinaliza que pegou ambos os garfos! take_forks() put_forks()

30 IC - UFF Outras formas l Embora semáforos pareçam simples (baixo nível), problemas podem surgir se a ordem das operações down forem impróprias: uso de monitores (linguagem) l E se é necessário a troca de informações entre máquinas processos? troca de mensagens

31 IC - UFF Leitura suplementar l Operating Systems Concepts, A. Silberschatz e P.B. Galvin, Addison- Wesley l Operating Systems: Internals and Design Principles, W. Stallings, Prentice Hall


Carregar ppt "IC - UFF Sistemas Operacionais 3. Concorrência Texto base: capítulo 2 Modern Operating Systems A.S. Tanenbaum."

Apresentações semelhantes


Anúncios Google