Fundamentos de Sistemas Operacionais

Transcrição

1 Fundamentos de Sistemas Operacionais Aula 5: Exclusão Mútua Diego Passos

2 Última Aula

3 Programação Concorrente Programas compostos por mais de um processo ou thread. Pode trazer benefícios: Simplificar o projeto de certos programas. Aumentar o desempenho. Também pode trazer problemas: Aumento de complexidade no gerenciamento dos processos (threads). Acesso simultâneo a recursos compartilhados. Região crítica.

4 Região Crítica Trecho de código que manipula recursos compartilhados. Ordem de execução dos processos (threads) é imprevisível. Pode causar comportamento errado do programa. Resultados inválidos. Perda de informação. Etc. Soluções: Usar operações atômicas. Impedir acessos simultâneos à região crítica. Exclusão mútua.

5 Operações Atômicas

6 Definição É uma operação indivisível no tempo. Não pode ser interrompida. Ou é totalmente executada, ou nem começa a execução. Exemplos: instruções de máquina. Processador verifica se há interrupções no início do ciclo de execução. Se não há, a instrução é executada completamente. Caso contrário, a execução da instrução sequer começa.

7 Operações Atômicas e Seções Críticas Se todo código da seção crítica pudesse ser executado atomicamente, não haveria condição de corrida. Processos podem executar em qualquer ordem. Jamais dois processos estariam "dentro" da seção crítica ao mesmo tempo. Não há risco de inconsistência nos dados. Problema: A seção crítica pode ser complexa demais para ser executada em uma única instrução de máquina.

8 Operações Atômicas: Possível Implementação É preciso garantir que um processo execute toda uma região crítica sem ser interrompido. Solução: desabilitar interrupções. Instrução CLI. Exemplo: asm ("cli"); /* Aqui começa a Região Crítica. */ x = x + 1; y = x + 15;... /* Fim da Região Crítica. */ asm ("sti");

9 Operações Atômicas: Possível Implementação (mais) Método traz uma série de problemas: Instrução CLI é privilegiada. Processos de aplicação em geral rodam em modo usuário. Sem interrupções, não há chamadas de sistema. Qualquer E/S tem que ser feito pelo processo do usuário. Propenso a falhas e brechas de segurança: E se o programador esquece (ou decide não colocar) a instrução STI no final? Não funciona em máquinas multiprocessadas. Em geral, utilizado apenas em sistemas simples. Sistemas embarcados.

10 Exclusão Mútua

11 Definição Significa que no máximo um processo estará na Seção Crítica por vez. Se um processo A já está na Seção Crítica e B quiser entrar, B precisa esperar que A saia. Um processo na Seção Crítica pode ser interrompido. Processos que não compartilham o recurso podem ser executados. Processos que compartilham, mas não estão na seção crítica podem ser executados. Ao voltar, processo encontrará o recurso compartilhado no mesmo estado.

12 Requisitos Uma solução para exclusão mútua deve prover/permitir: Exclusão mútua. Que, caso não haja outro processo na seção crítica, um processo não seja impedido de entrar. Que um processo não seja indefinidamente impedido de entrar na sua seção crítica (starvation). A solução não deve depender de: Ordens específicas de execução de processos. Velocidades específicas de execução dos processos.

13 Protocolos de Acesso Primeiro tipo de solução para prover exclusão mútua. Totalmente baseados em software. Nenhum suporte do hardware é necessário. Exemplos: Alternância. Algoritmo de Peterson. Algoritmo de Dekker. Algoritmo de Eisenberg. Algoritmo de Lamport (Bakery).

14 Alternância Inicialização: turn = 0; // Pode ser 1. Processo 0: while(turn == 1) { // Espera ocupada. } // Início da região crítica.... // Fim da região crítica. turn = 1; Processo 1: while(turn == 0) { // Espera ocupada. } // Início da região crítica.... // Fim da região crítica. turn = 0;

15 Alternância: Problemas Força uma sequência de execução entre os processos. P0, P1, P0, P1,... Um processo mais rápido pode ter que esperar um longo tempo até que outro chegue a seção crítica para passar a vez. Muito ineficiente. A vez de um processo pode nunca chegar, se o outro não executar sua seção crítica.

16 Algoritmo de Peterson (1981) Inicialização: flag[0] = 0; flag[1] = 1; turn = 0; // Pode ser 1. Processo 0: flag[0] = 1; turn = 1; while(flag[1] == 1 && turn == 1) { // Espera ocupada. } // Início da região crítica.... // Fim da região crítica. flag[0] = 0; Processo 1: flag[1] = 1; turn = 0; while(flag[0] == 1 && turn == 0) { // Espera ocupada. } // Início da região crítica.... // Fim da região crítica. flag[1] = 0;

17 Desvantagens dos Protocolos de Acesso Soluções complexas. Principalmente quando há mais de dois processos envolvidos. Fazem espera ocupada (busy-waiting). Pouco eficiente. Processador fica ocupado inutilmente.

18 Soluções com Suporte do Hardware

19 Spin-Lock: Intuição Podemos controlar a entrada na seção crítica com uma variável lock. A Seção está trancada quando há um processo nela. A Seção está destrancada, caso contrário. Exemplo: // Tentar entrar na seção crítica. while (lock == 1) {}; lock = 1; // Início da Seção Crítica... // Fim da Seção Crítica. lock = 0;

20 Spin-Lock: Intuição (mais) Para funcionar, a variável lock precisa ser compartilhada entre os vários processos. Problema: Se lock é um recurso compartilhado, a manipulação desta variável está susceptível a condições de corrida. O algoritmo não resolve o problema, apenas cria outro. Solução: Suporte do hardware. Processador permite que a manipulação da variável lock seja atômica.

21 Spin-Lock: Implementação Utiliza uma instrução específica. Varia de processador para processador: Test-and-set-lock (TSL), Swap (SWP), Compare-on- Store (COS),... Exemplo: instrução Swap(reg, mem). Recebe dois argumentos: um registrador e um endereço de memória. Troca o valor do registrador com o valor armazenado no endereço de memória. [mem] -> aux; reg -> [mem]; aux -> reg;

22 Spin-Lock: Implementação (mais) Utilizando a instrução Swap, o código fica: // Tentar entrar na seção crítica. do { reg = 1; swap(reg, lock); } while(reg == 1); // Início da Seção Crítica... // Fim da Seção Crítica. lock = 0;

23 Spin-Lock: Análise O código sempre escreve 1 na variável lock. Se o valor de lock já era 1 (há um processo na região crítica): lock continua 1. reg passa a ser 1. Repetição continua. Se o valor de lock era 0 (não há processo na região crítica): lock continua 1. reg passa a ser 0. Repetição para. Quando um processo fica na repetição aguardando, ele faz uma espera ocupada (consome inutilmente recursos do processador). Quando há vários processos disputando a entrada na região crítica, não há garantias de que um dado processo conseguirá entrar.

24 Semáforos É um tipo de dado especial: Composto por um valor inteiro e por uma fila de processos. Aceita dois tipos de operação: P(S): decrementa e testa. Também chamada de down. Decrementa o valor do semáforo e testa se é menor que zero. Se for, processo é bloqueado e colocado na fila do semáforo. V(S): incrementa, desbloqueia. Também chamada de up. Incrementa o valor do semáforo. Se há um processo na fila, desbloqueia.

25 Semáforos: Exemplos de Uso Proteção de acesso à região crítica. Antes de entrar na região crítica, processo realiza a operação P no semáforo correspondente. Ao sair, ele realiza a operação V no semáforo correspondente. Processo 0: P(S); x = x + 1; V(S); Processo 1: P(S); x = x + 1; V(S);

26 Semáforos: Exemplos de Uso (mais) Sincronização entre processos. Suponha que o processo 0 só possa executar determinada ação, após o processo 1 chegar a um determinado ponto da sua execução. Utiliza-se um semáforo S de controle, inicializado com 0. Processo 0: Processo 1: /* Aguarda liberação de P1. */ P(S); /* Prossegue com a sua execução. */ /* Chega ao ponto em que P0 pode ser liberado. */ V(S); /* Prossegue com a sua execução. */

27 Semáforos: Mutex vs. Contador. Um mutex (ou semáforo binário) tem funcionamento ligeiramente diferente. Ele só pode assumir os valores 0 e 1. Suficiente para garantir exclusão mútua. Operações também são chamadas de lock() e unlock(). Semáforos comuns são chamados semáforos contadores. Úteis quando o acesso a um dado recurso pode ser dado a um conjunto de processos simultaneamente.

28 Semáforo Contador: Exemplo Problema do Produtor-Consumidor Inicialização: s_mutex m = 1; s_contador vagas = N; s_contador dados = 0; Produtor: while (1) { P(vagas); P(m); insere_dado(); V(m); V(dados); } Consumidor: while (1) { P(dados); P(m); remove_dado(); V(m); V(vagas); }

29 Semáforos: Implementação Um semáforo também é um recurso compartilhado. Suas operações, portanto, podem sofrer condições de corrida. É preciso proteger o acesso. Várias opções. Desabilitar interrupções. Pode não funcionar com vários processadores. Spin-locks. Protocolos de acesso. Como P e V são operações curtas e executadas pelo SO, problemas das soluções anteriores são mitigados.

30 Semáforos: Implementação (mais) Quando um processo executa uma operação P() em um semáforo com valor 0 (ou negativo), o SO: Remove o processo da fila de aptos. Insere o processo na lista de bloqueados. Insere uma referência a ele na fila de processos do semáforo. Quando um processo executa uma operação V() em um semáforo, o SO: Verifica se há processos na fila do semáforo. Remove o primeiro da fila (ou mais prioritário). Remove o processo da lista de bloqueados. Insere o processo na fila de aptos.

31 Semáforos: Análise Garante exclusão mútua. Não provoca starvation. Fila de processos esperando garante que todos os processos eventualmente serão atendidos. Provê a funcionalidade de contador. Útil em certos problemas. Processo da aplicação não precisa realizar espera ocupada. Processo fica no estado bloqueado.

32 Revisão

33 Para Lembrar Requisitos da exclusão mútua. O que é starvation? Utilização de operações atômicas. Por que não é usado em geral (por aplicações)? Desvantagens de desabilitar interrupções. Protocolos de acesso. Alternância. Spin-locks. Como são implementados. Desvantagens. Semáforos. Mutex vs. Contador. Operações. Exemplos de uso. Por que sua implementação pode utilizar os outros métodos?