Sistemas Operacionais. Técnicas de Implementação de Exclusão Mútua. Aula VI Prof. Rosemary Silveira

Transcrição

1 Sistemas Operacionais Técnicas de Implementação de Exclusão Mútua Aula VI Prof. Rosemary Silveira

2 Tópicos de Apresentação Condições de Corrida Técnicas de Implementação de Exclusão Mútua

3 Condições de Corrida Como o sistema operacional determina, através da política de escalonamento, o processo que vai executar e por quanto tempo, não se sabe a priori em que ordem dois processos ativos irão executar. Situações nas quais dois ou mais processos acessam concorrentemente as mesmas posições de memória ou arquivo compartilhado e o valor final contido nestas posições depende da ordem na qual os processos foram executados são chamadas de condições de corrida (race conditions). A existência de condições de corrida em um sistema pode levar a resultados inesperados, devido ao não-determinísmo inerente a estas condições.

4 Condições de Corrida As condições de corrida levam geralmente a resultados inesperados, por isto, devem ser evitados. É necessário assegurar que outros processos sejam impedidos de usar uma variável compartilhada ou arquivo compartilhado que já estiver em uso por outro processo. A serialização da execução garante que uma porção de código seja executada somente por um processo de cada vez. A exclusividade na execução de partes de código é garantida por mecanismos que implementam a exclusão. A parte do código protegida pelos mecanismos de exclusão é denominada região crítica.

5 Exclusão Mútua Os mecanismos de exclusão devem garantir que jamais dois ou mais processos estejam dentro da mesma região crítica simultaneamente. A implementação da exclusão pode ser feita de duas maneiras: Espera ocupada (busy waiting) O processo espera a permissão de entrada na seção crítica em um loop de teste de permissão: while (vez!= minha) A espera ocupada desperdiça CPU, só é interessante utilizá-la quando se sabe que a espera é pequena. Bloqueio de processos O processo que espera a permissão de entrada na seção crítica executa uma primitiva que causa o seu bloqueio até que a seção crítica seja liberada. if (vez!= minha) sleep(); O bloqueio ocasiona troca de contexto entre processos -> esperas longas.

6 Exclusão Mútua Uma boa solução para o problema de exclusão deve garantir os seguintes requerimentos: 1) exclusão se o processo P1 está executando na seção crítica, nenhum outro processo pode estar executando nesta seção crítica simultaneamente. 2) progresso Se não há processo executando na seção crítica e existem processos querendo entrar nela, somente os processos que desejam executar a seção crítica devem participar na decisão de que processo pode acessála. Caso contrário, pode-se retardar a execução de processos indefinidamente. 3) Espera limitada (bounded waiting) Deve existir um limite no número de vezes que outros processos acessam a região crítica quando um processo está esperando entrar nela.

7 1) Inibição de interrupções O processo que deseja acessar a região crítica desabilita as interrupções logo depois de entrar na sua região crítica e reabilita imediatamente antes de sair dela. Desabilitando as interrupções, não pode ocorrer qualquer interrupção do relógio e assim o processo não pode ser interrompido pelo escalonador. A CPU é alternada de processo em processo somente como um resultado de interrupção do relógio ou de outra interrupção. Uma vez que tenha desabilitado as interrupções, um processo pode verificar e atualizar a memória compartilhada sem temer a intervenção de um outro processo.

8 1) Inibição de interrupções Características do algorítmo: exclusão, progresso e espera limitada. Problemas: Não é prudente dar aos processos dos usuários o poder de desligar as interrupções. Por ser uma função crítica, a inibição de interrupções geralmente só pode ser executada em modo kernel. Esta técnica é inadequada para mecanismo geral de exclusão para processos de usuário. Desabilita_interrupções(); /* executa a região crítica */ x = x + 1; Habilita_interrupções();

9 Implementação de exclusão com Espera Ociosa 2) Alternância obrigatória Neste caso, cada processo tem a sua vez de entrar na região crítica. A vez de entrar na região crítica é controlada pela variável turn (vez). Características do algoritmo: Exclusão. Problemas: O algoritmo só permite entrada alternada de dois processos na região crítica. Se os dois processos possuem velocidades diferentes de execução do loop, pode ocorrer que um dos processos seja bloqueado por um processo que não está em sua região crítica. while (TRUE) {Processo P1 { while (turn!= 0) /* laço */ ; regiao_critica(); turn = 1; regiao_nao_critica(); while (TRUE) {Processo P2 { while (turn!= 1) /* laço */ regiao_critica(); turn = 0; regiao_nao_critica();

10 Implementação de exclusão com Espera Ociosa 3) Solução de Peterson Todo processo p que deseja executar uma região crítica deve fazer: entra_regiao(p); /* região_crítica */ sai_regiao(p) Características do algoritmo: exclusão, progresso e espera limitada. Problemas: Este algoritmo resolve o problema da região crítica somente para dois processos. Apresenta o defeito de precisar de espera ociosa. Pode ocasionar problema da inversão de prioridade. #define N 2 /*número processos */ int turn; int interested[n]; /* valores iniciais iguais a zero */ void enter_region(int process); { int other; other = 1 process; interested[process] = TRUE; turn = process; while (turn== process && interested[other]== TRUE) ; void leave_region(int process) { interested[process] = FALSE;

11 Implementação de exclusão com Espera Ociosa 4) Solução que utiliza hardware adicional Na maioria das máquinas comerciais existem algumas instruções de hardware que auxiliam a implementação da exclusão. Estas instruções testam e setam um valor de maneira indivisível. Características do algoritmo: exclusão, progresso e espera limitada. enter_region TSL REGISTER, LOCK /* copia lock para o registrador e põe lock em 1 */ CMP REGISTER, #0 JNE enter_region RET leave_region MOVE LOCK, #0 RET Problemas: Este algoritmo resolve o problema da região crítica somente para dois processos. Apresenta o defeito de precisar de espera ociosa. Pode ocasionar problema da inversão de prioridade.

12 Implementação de Exclusão Mútua com Bloqueio de Processos Vantagens quanto a implementação de exclusão por espera ociosa: Evitar o desperdício de CPU. Evitar o problema de prioridade invertida Considere um computador com dois processos: H, com alta prioridade L, com baixa prioridade As regras de escalonamento em que H é executado sempre que tiver pronto. Em certo momento, com L em sua região crítica, H torna-se pronto para executar. Agora H inicia uma espera ociosa, mas como L nunca é escalonado enquanto H está executando, L nunca tem oportunidade de deixar sua região crítica, e assim, H fica em um laço infinito.

13 1) Uso de Primitivas (usado para implementar o bloqueio de processos à espera da região crítica): Exemplos: Sleep e Wakeup sleep: bloqueia o processo que a chamou Wakeup: desbloqueia os processos que estão esperando pela região crítica 2) Uso de Semáforo Variável inteira que só admite valores positivos. Duas operações indivisíveis podem ser executadas sobre um semáforo: down - decrementa o valor do semáforo se este for maior que zero. - se o valor do semáforo for zero, o processo que executou a operação é bloqueado. up - incrementa o valor do semáforo e acorda os processos que estiverem bloqueados no semáforo.

14 3) Uso de Monitores Mecanismo de alto nível para a sincronização de processos. Conjunto de procedures e dados agrupados por módulos. Os processos só podem chamar os procedimentos, nunca acessando diretamente os dados. Características importantes: Não pode haver dois processos ativos dentro do monitor simultaneamente. Quem se preocupa em garantir a exclusão é o compilador e não o programador. Problema: o conceito de monitor deve estar contido na linguagem de programação e a maioria das linguagens atuais não suporta este conceito. 3) Uso de Variáveis de Condição Variáveis utilizadas para ordenar a execução de diferentes processos. Permite que um processo se bloqueie esperando uma ação de outro processo. Existem duas operações sobre as variáveis de condição: - wait: bloqueia processo - Signal: acorda processos bloqueados

15 Exemplo de utilização de mecanismos de exclusão Problema: Produtor-Consumidor Neste problema, dois processos compartilham um buffer de tamanho fixo. Um processo escreve dados no buffer e o outro retira dados do buffer. Como o buffer tem tamanho fixo, deve-se ter uma variável que controle o número de mensagens no buffer. Para que o processo produtor não escreva no buffer cheio e o processo consumidor não retire dados do buffer vazio, o número de mensagens no buffer é uma variável compartilhada e o acesso a ela pode levar a condições de corrida.

16 Problema do Produtor-Consumidor 1) Solução utilizando as primitivas Sleep e Wakeup Características do algoritmo: Não garante exclusão, nem progresso e nem espera limitada. Problemas: Acarreta condição disputa, pelo fato de a variável count ter acesso irrestrito. Situação: Escalonador executa inicialmente consumidor com count igual a zero. Em seguida executa produtor com buffer vazio. Quando for executado novamente o consumidor, com count ainda igual a zero, ele irá dormir para sempre. Mais tarde o produtor poderá preencher o buffer inteiro e também dormirá para sempre. #define N 100 int count = 0 void procedurer(void) { int item; while (TRUE) { item = procedure_item(); if (count == N) sleep(); insert_item(item); count = count + 1; if (count == 1) wakeup(consumer); void consumer(void) { int item; while (TRUE) { if (count == 0) sleep(); item = remove_item(); count = count 1 if (count == N-1) wakeup(producer) consume_item(item);

17 Problema do Produtor-Consumidor 2) Solução utilizando semáforo Garante que uma vez iniciada uma operação de semáforo, nenhum outro processo pode ter acesso a este até que a operação tenha terminado ou sido bloqueada. O semáforo mutex é usado para garantir exclusão. Os outros semáforos são voltados para sincronização, ou seja, asseguram que o produtor pare de executar quando o buffer estiver cheio ou quando o buffer estiver vazio. Características do algoritmo: exclusão, progresso e espera limitada. #define N 100 semphore mutex=1; semaphore empty=n; semaphore full=0; void procedurer(void) { int item; while (TRUE) { item = procedure_item(); down(&empty); down(&mutex); insert_item(item); up(&mutex); up(&full); void consumer(void) { int item; while (TRUE) { down(&full); down(&mutex); item = remove_item() up(&mutex); up(&empty); consume_item(item);

18 Problema do Produtor-Consumidor 3) Solução utilizando semáforo Problemas: Deve-se ter cuidado na ordem do uso dos semáforos, pois pode levar a condições de erros como deadlock e condições de disputa. Situação: Suponha que os dois downs no código do produtor sejam invertidos, de modo que o mutex seja decrescido antes do empty. Se o buffer estivesse completamente cheio, o produtor seria bloqueado como mutex em zero. Quando o consumidor tentasse ter acesso ao buffer, faria down em mutex e seria bloqueado também. #define N 100 semphore mutex=1; semaphore empty=n; semaphore full=0; void procedurer(void) { int item; while (TRUE) { item = procedure_item(); down(&empty); down(&mutex); insert_item(item); up(&mutex); up(&full); void consumer(void) { int item; while (TRUE) { down(&full); down(&mutex); item = remove_item() up(&mutex); up(&empty); consume_item(item);

19 Problema do Produtor-Consumidor 4) Solução utilizando Monitores Coleção de procedimentos, variáveis e estruturas de dados, tudo isso agrupado em um tipo especial de módulo (pacote). Processos podem chamar os procedimentos quando quiserem, mas não podem ter acesso direto a parte interna deste. Permite que apenas um processo fique ativo em um monitor em dado momento. É o compilador que providencia a exclusão. Uso de variáveis condicionais, com duas operações sobre ela: wait e signal. Características do algoritmo: exclusão, progresso e espera limitada. Problemas: Em sistemas distribuídos, formado por múltiplas CPUs, cada qual com sua própria memória privada e conectada por uma rede local, essas primitivas tornam-se inaplicáveis. Monitor ProducerConsumer condition full, empty; integer count; procedure insert(item: integer); begin if conunt = N then wait(full); insert_item(item); count := count + 1; if count=1 then signal(empty); end; function remove: integer; begin if (count = 0) then wait(empty); remove = remove_item; count := count 1; if (count = N -1) then signal(full) end monitor;

20 Monitor ProducerConsumer condition full, empty; integer count; procedure insert(item: integer); begin if conunt = N then wait(full); insert_item(item); count := count + 1; if count=1 then signal(empty); end; function remove: integer; begin if (count = 0) then wait(empty); remove = remove_item; count := count 1; if (count = N -1) then signal(full) end monitor; procedure producer; begin while true do begin item = produce_item; ProducerConsumer.insert(item); end; end; produce consumer; begin while true do begin item = ProducerConsumer.remove; consume_item(item); end; end;

21 Problema do Produtor-Consumidor 5) Solução utilizando Troca de Mensagens Usa duas primitivas de comunicação, send e receive (chamadas de sistema) Resolve este problema apenas com troca de mensagem, sem uso de memória compartilhada. Características do algoritmo: Problemas: exclusão, progresso e espera limitada. Apresentam problemas complexos relativos a comunicação. #define N 100 void producer(void); { int item; message m; while (TRUE) { item = produce_item(); void consumer(void) { int item, i; message m; receive(consumer, &m); build_message(&m, item); send(consumer, &m); for (i=0; i<n;i++) send(producer, &m); while (TRUE) { receive(producer, &m); item = extract_item(&m); send(producer, &m); consumer_item(item);

22 Métodos de Sincronização envolvendo vários processos 1) Problema do Jantar dos Filósofos Solução dirigida a grupos de processos, em vez de situações que envolve dois processos. Útil para modelar processos que competem pelo acesso exclusivo a um número limitado de recursos. Descrição : A vida do filósofo consiste em alternar períodos de comer e pensar. Quando um filósofo fica com fome, ele tenta pegar os garfos à sua direita e a sua esquerda. Se o filósofo conseguir pegar, ele comerá e em seguida devolverá. Solução 1: #define N 5 void philodopher(int i) { while(true) { think(); take_fork(i); take_fork((i+1)%n); eat(); put_fork(i); put_fork((i+1)%n); Problemas: Pode ocorrer deadlock, se todos os filósofos tentarem pegar seus garfos simultaneamente. Neste caso, nenhum será capaz de pegar o garfo a sua direita.

23 Métodos de Sincronização envolvendo vários processos 1) Problema do Jantar dos Filósofos Solução para Primeiro Problema: Depois de pegar o garfo esquerdo, verificar se o garfo direito está disponível. Se não tiver, o filósofo devolverá o garfo esquerdo. Problemas: Pode ocorrer que todos os processos continuem executando indefinidamente, mas falhem ao tentar progredir (inanição starvation) Solução 1: #define N 5 void philodopher(int i) { while(true) { think(); take_fork(i); take_fork((i+1)%n); eat(); put_fork(i); put_fork((i+1)%n); Situação: Todos os filósofos podem começar simultaneamente executando, pegando seus garfos esquerdo e vendo que seus direitos não estão disponíveis, neste caso todos devolveriam os garfos e permaneceriam para sempre.

24 Métodos de Sincronização envolvendo vários processos 1) Problema do Jantar dos Filósofos Solução para Segundo Problema: Protege os cinco comandos que seguem a chamada think com um semáforo binário. Não apresenta inanição (starvation) e nem deadlock. Problemas: Apresenta problema de desempenho, pois apenas um filósofo poderá estar comendo a qualquer instante. Solução 2: #define N 5 #define LEFT (I+N-1)%N #define RIGHT (i + 1)%N #define THINKING 0 #define HUNGRY 1 #define EATING 2 int state[n]; semaphore mutex=1; semaphore s[n]; void philosopher(int i) { while (TRUE) { think(); take_forks(i); /* pega dois garfos*/ eat(); put_forks(i);

25 Problemas Clássicos void take_forks(int i) { down(&mutex); state[i] = HUNGRY; test(i); up(&mutex); down(&s[i]); void test(i) { if (state[i]==hungry && state[left]!= EATING && state[right]!= EATING) { state[i] = EATING; up(&s[i]); void put_forks(i) { down(&mutex); state[i] = THINKING; test(left); test(right); up(&mutex);

26 Métodos de Sincronização envolvendo vários processos 2) Problema dos Leitores e Escritores Solução dirigida a grupos de processos, em vez de situações que envolve dois processos. Útil para modelar processos que competem pelo acesso a uma base de dados. Descrição : É aceitável que múltiplos processo leia a base de dados ao mesmo tempo, mas se um processo estiver atualizando na base, nenhum outro processo pode ter acesso a esta, nem mesmo os leitores. O leitor para obter acesso à base de dados, primeiro leitor faz o down no semáforo db. Os leitores subsequentes incrementaram o contador rc, ou decrementaram, caso saiam. O escritor permanecerá suspenso até que nenhum leitor esteja presente. O último a sair permite que um eventual escritor entre. typedef int semaphore; semaphore mutex = 1; semaphore db = 1; int rc=0; void reader(void) { while (TRUE) { down(&mutex); rc = rc +1; if (rc==1) down(&db); up(&mutex); read_data_base(); down(&mutex); rc = rc - 1; if (rc == 0) up(&db); up(&mutex); use_data_read();

27 Métodos de Sincronização envolvendo vários processos 2) Problema dos Leitores e Escritores Problemas : O escritor poderá permanecer suspenso até que nenhum leitor esteja presente. Neste caso, pode ocorrer do escritor nunca conseguir entrar na região crítica. void writer(void) { while (TRUE) { think_up_date(); down(&db); write_data_base(); up(&db); Solução: Se um leitor chegar quando um escritor estiver esperando, o leitor será suspenso logo depois do escritor, em vez de ser admitido de imediato.

28 Métodos de Sincronização envolvendo vários processos 3) Problema do Barbeiro Sonolento Descrição : Na barbearia há um barbeiro, uma cadeira de barbeiro e n cadeiras para clientes esperarem. Quando chega um cliente, ele precisa acordar o barbeiro. Se outros clientes chegarem enquanto o barbeiro estiver cortando o cabelo de um cliente, eles se sentarão ou sairão da barbearia. A razão de se ter a variável waiting é que não há uma maneira de ler o valor atual do semáforo customer.

29 Métodos de Sincronização envolvendo vários processos #define CHAIRS 5 semaphore customers = 0; semaphore barbers = 0; semaphore mutex = 1; int waiting = 0; void barber(void) { while (TRUE) { down(&customers); down(mutex); waiting = waiting 1; up(&barbers); up(&mutex); cut_hair(); void customer(void) { down(&mutex); if (waiting < CHAIRS) { else { waiting = waiting + 1; up(&customers); up(&mutex); down(&barbers); get_haircut(); up(&mutex);