Programação concorrente: Problemas, comunicação e sincronização de processo Referências: - Capítulo 2, Modern Operating Systems, A. Tanenbaum - Capítulo 5, Operating Systems: Internals and Design Principles, Willian Stallings - Capítulo 6, Operating System Concepts, Silberschatz & Galvin - http://www.cne.gmu.edu/modules/ipc/ - Apostila *baseado no material do Prof. Orlando Loques - IC/UFF

Conceito de processo Um sistema operacional executa uma variedade de programas de forma “simultânea” Livros usam os termos job e processo quase que indeterminadamente. Processo – um programa em execução; execução do processo deve progredir de maneira seqüencial. Tecnicamente um processo é criado quando um outro processo faz uma chamada ao sistema de criação de processos - Fork  clone identico ao processo que o chamou Inicialização de processos em segundo plano pelo - Daemons

Estados do processo Durante a execução de um processo, ele altera seu estado Novo (new): O processo está sendo criado. Executando (running): instruções estão sendo executadas. Esperando (waiting): O processo está esperando algum evento acontecer. Pronto (ready): O processo está esperando ser associado a um procesador. Terminado (terminated): O processo terminou sua execução.

Diagrama de estados do processo

Tipos de Processamento Concorrente Multiprogramação: vários processos em um sistema monoprocessador Multiprocessamento: vários processos em um sistema multiprocessador (memória comum - acesso compartilhado) Processamento Distribuído: vários processos executando em vários (multi) processadores distribuídos (memória privada - acesso exclusivo)

Programação Concorrente Conceitos e mecanismos para expressar paralelismo potencial Facilita a solução de problemas inerentes associados ao compartilhamento de recursos, à sincronização e à comunicação de processos Provê as abstrações de programação para o tratamento de situações comuns, existentes no mundo real sistemas operacionais sistemas de comunicação sistemas de controle de processos (embutidos) Pode ser suportada através do compartilhamento de um único processador ou por vários processadores operando em paralelo Leva a sistemas eficientes, modulares e bem estruturados

Concorrência: utilizações Compartilhamento de recursos Sincronização de processos Comunicação entre processos

Exemplo de Compartilhamento Atualização de uma variável compartilhada, exemplo: saldo bancário var V:integer; // valor do saldo ... processo T_1; begin . . | V = V +1; <---------------| end; processo T_2; . | { sequência de instruções } load V add 1 store v

Sequência de Execução tempo Processo 1 2 Ação load V add 1 add1 store V storeV Valor de V 4 - 5

Programa simplesmente lê um valor e o imprime Outro Exemplo procedure echo; var out, in: character; begin input(in, keyboard); out := in; output(out, display) end. Programa simplesmente lê um valor e o imprime

P1, P2 executando em processadores separados Cada processo tem uma linha de código executada por vez de forma alternada... Entrada: “xy” Process P2 --- echo input(in,keyboard) ”y” out := in output(out,display) Process P1 --- echo input(in,keyboard) “x” out := in output(out,display) P1 e P2 concorrentes Saídas: “yy” ou “xx” ?! P1 e P2 exclusivos Saída: “xy” ok!

Condições de corrida (Race Conditions) Processos trocam dados, as vezes, através de memória Principal, arquivo... Região/seção crítica Porção de programa que pode levar a condição de disputa Tipo de memória não altera o problema Alguma forma de garantir que apenas 1 esteja na região crítica

Condições de corrida (Race Conditions) Situações onde dois ou mais processos estão acessando dados compartilhados. O resultado final pode variar de acordo com a ordem de execução. Mecanismo de Sincronização. Garante o compartilhamento de recursos e a comunicação entre os processos. Garante a integridade e a confiabilidade dos dados compartilhados.

Condições de corrida (Race Conditions) Exemplo 1: Resultado Final: Contador = 6 (ERRO!) 1 2 7 7 Processo A 7+1 Processo B 7-1 7 3 4 5 6 8 6

Condições de corrida (Race Conditions) Processo A suspenso 2 Exemplo 2: Valor armazenado pelo processo B é perdido. recebe CPU 8 10 Y 1 9 7 8 5 6 próxima entrada 7 4 3 6 X 4 5 7 8 Processo B recebe CPU 3 suspenso 7

Condições de corrida (Race Conditions) Região Crítica: Parte do código onde é feito acesso a recursos compartilhados, e que podem levar a condições de corrida. Ex: Processo A. Código normal Início da Seção Crítica (Protocolo de Entrada) Seção Crítica Término da Seção Crítica (Protocolo de Saída)

Condições de corrida (Race Conditions) Enquanto um processo estiver usando um recurso, os outros devem aguardar até que o recurso esteja liberado. Exclusão Mútua. Exclusividade no acesso a um determinado recurso. A exclusão mútua deve afetar os processos concorrentes quando um deles estiver em uma região crítica.

Regiões críticas Como evitar condições de disputa? Implementar exclusão mútua Um por vez junto à região Garantir que dois ou mais processos estarão sincronizados, e só um dentro da região crítica Operando sobre dados compartilhados

Regiões críticas Quatro requisitos básicos para os algoritmos solucionarem o problema de região crítica Dois ou mais processos NUNCA podem estar simultaneamente na região crítica Não considerar velocidade relativas dos processos Quem estiver fora da região não pode bloquear quem quer entrar Tem que entrar em algum momento!

Regiões críticas

Dois tipos de bloqueios Dois tipos de bloqueio são considerados básicos: bloquear até que um recurso se torne disponível; bloquear até que chegue um sinal de outro processo.

Locks Conceito e Implementações

Locks - Funcionamento Um processo só entra num trecho delimitado pelo par lock/unlock se nenhum outro processo está executando em um outro trecho delimitado dessa maneira. Isto é, o primeiro processo que executa o comando lock passa e tranca a passagem (chaveia a fechadura) para os demais. O comando unlock deixa passar (desbloqueia) o primeiro processo da fila de processos que estão bloqueados por terem executado um lock (enquanto a fechadura estava trancada). Se a fila está vazia, a fechadura é destrancada (isto é, é deixada aberta).

Solução: Locks (i) Definição: Lock L = valor binário L = 0  lock aberto; o processo prossegue L = 1  lock fechado; o processo espera Tentativa de Implementação Lock (L) ::= while L=1 do nothing; L:= 1; UnLock (L) ::= L := 0;

Solução: Locks Encapsulamento Lock/Unlock garante a Exclusão Mútua Permite acesso seguro a variáveis compartilhadas Thread_T; begin . . . Lock (L); - - seção crítica UnLock (L); end;

Implementação de Locks Hardware: Inibição de Interrupção Lock ::= < desabilita interrupção > Unlock ::= < habilita interrupção > A perda da capacidade de entremear a execução de programas pode afetar o desempenho A capacidade de resposta rápida a eventos (associados a interrupções) é também afetada Em multiprocessadores, mais que um processo pode estar executando ao mesmo tempo: bloquear interrupções não garante a exclusão mútua

Implementação de Locks Hardware: Instruções especiais, não interruptíveis Questões: Espera-ocupada (busy waiting): o processo esperando em um lock fica em loop, usando inutilmente o processador. Isso pode degradar o desempenho do sistema Deadlock: situção onde dois ou mais processos ficam impedidos de continuar a execução, ficam bloqueados Starvation: se um processo de baixa prioridade está na seção crítica e um processo de alta prioridade quer entrar nela, o processo de alta prioridade pode ganhar o processador para esperar a sua vez (acontece o problema de inversão de prioridade – SO pode aumentar a prio de processo) Locks em hardware podem ser uma boa solução em certas aplicações, e.g., multiprocessadores

Locks: Falha de TSL TSL = Test and Set Lock Mecanismo implementado a nível de hardware É atômico A instrução TSL pode falhar se o acesso ao barramento não for bloqueado

Sleep / Wakeup

Funcionamento Quando um processo P executa o comando sleep, ele se bloqueia até que um outro processo execute o comando wakeup(P). Este último comando acorda (desbloqueia) o processo especificado por P. Se wakeup(P) é executado antes, o processo P não se bloqueia ao executar o sleep. Não formam uma estrutura sintática (isto é, não precisam estar casados, como se fossem um abre e fecha parênteses), eles são comandos independentes

Semáforo Dijkstra 1965

Semáforos Em 1965 Dijkstra propôs usar uma variável inteira para contar o número de sinais de acordar e salvá-los para uso futuro. Esta variável recebeu o nome de semáforo e é usada para sincronizar processos. Seu objetivo é coordenar o acesso a uma região crítica e evitar os problemas que levam a condições de corrida. Esta variável pode armazenar o valor 0 (indicando que nenhum sinal de acordar foi salvo) ou outro valor positivo caso 1 ou mais sinais de acordar estejam pendentes.

Semáforos Possui as seguintes características: Um semáforo s é uma estrutura de dados, formada por um contador e um apontador para uma fila de processos bloqueados naquele semáforo Somente pode ser acessado por duas operações (P e V) A operação P bloqueia o processo que a executa se o valor do semáforo é 0 A operação V incrementa o valor do semáforo. Existindo processos bloqueados, o primeiro da fila é acordado As modificações são executadas atomicamente Se dois processos tentam, simultaneamente, executar P(s) ou V(s), essas operações irão ser executadas sequencialmente, em uma ordem arbitraria Semaforos podem ser usados para exclusão mutua com n processos, quando inicializados com o valor 1

Semáforos A implementação é feita com o uso de uma estrutura de dados que contém o identificador do semáforo, o valor do semáforo, um apontador para o primeiro e o ultimo processos bloqueados Para ser indivisível as operações P e V são implementadas como chamadas de sistema. Com isso, por um pequeno instante as interrupções são desabilitadas, mas não geram nenhum problema. Os semáforos podem ser binários e não binários Binários  0 e 1 Não binários  valores diferentes de 0 e 1

Semáforos Semáforo binário Se o valor = 0 então o processo que executa P fica bloqueado. A operação V verifica a fila do semáforo. Se existe algum processo bloqueado, o primeiro é acordado, caso contrário é atribuído 1 ao valor do semáforo

Iniciar semáforo com valor 1 Semáforos Semáforo não binário A operação P verifica o valor do semáforo. Se o valor é 0, permanece com 0 e o processo fica bloqueado. Se for maior que 0 é decrementado e o processo não fica bloqueado (continua a execução) A operação V verifica a fila do semáforo. Se existe um processo bloqueado, o mesmo é acordado. Caso contrário o valor do semáforo é incrementado Iniciar semáforo com valor 1

Semáforos Exemplo do uso: Semaphore S = 1; P(s); CriticalSection(); V(s);

Birita inicialmente com valor 1 Semáforos e cervejas... Birita inicialmente com valor 1 Hora Você Colega 03:00 Chega em casa 03:04 DOWN(&birita) 03:05 Olha no freezer, sem cerveja 03:10 Sai para o bar 03:15 Chega em casa 03:19 DOWN(&birita) 03:20 Chega no bar 03:25 Compra uma grade e sai 03:30 03:35 Chega em casa 03:36 Guarda as cervejas 03:37 UP(&birita) 03:38 Olha no freezer, COM cerveja

Mutex Mutual Exclusion

Mutex Mutex é uma versão simplificada dos semáforos que serve para controlar o acesso a RC e que pode estar somente em dois estados distintos: impedido ou desempedido. Portanto, apenas um bit é necessário para armazenar esta informação. Existe 2 procedimentos para usar o esquema de mutex: 1. mutex_lock: se o mutex estiver desempedido (RC livre) o processo ganha acesso a RC. Caso o mutex estiver impedido o processo será bloqueado. 2. mutex_unlock: procedimento chamado pelo processo que deixa a RC para liberar o acesso aos demais processos.

Monitor Hoare 74 / Brinch Hansen 73

Monitor: Conceito Mecanismo de sincronização de alto nível proposto por Hoare (1974) e Brinch Hansen (1975); Conjunto de procedimentos e funções de alto nível agrupadas em um módulo Similar a uma classe, na OO Característica mais importante é a implementação automática da exclusão mútua: Somente um processo pode estar ativo dentro um monitor em um determinado instante de tempo. Somente um procedimento sendo executado, até a completude, por vez Programador livre de especificar as restrições

Monitor: Conceito entry: Java variáveis de condição: monitor example; ... declarações locais do monitor … variáveis de condição procedure entry proc_declaration_1; : begin end; procedure entry proc_declaration_2; : // mais procedimentos ... // ... iniciação do monitor end example. entry: assegura exclusão mútua na execução do procedimento Java entry = synchronized variáveis de condição: associadas a filas de espera definidas por expressões lógicas primitivas: wait (condição) signal (condição)

Monitor: Sistema T_1 T_3 M_1 B_Dados M_2 Display T_4 T_2

Estrutura do monitor

Mensagens

Troca de mensagens Primitivas de SEND/RECEIVE Novos problemas Enviar para e receber de Recepção bloqueante Novos problemas Perda de mensagens ACK, NACK Recebimento duplicado Controle de seqüência Segurança...

Troca de mensagens Produtor/consumidor Consumidor Produtor enviar N msg vazias while (TRUE) { receive (produtor, &m); extrai_item(); send (produtor, &m); consome_item(); } Produtor while (TRUE) { produz_item(); receive (consumidor, &m); constroi_msg(); send (consumidor, &m); }

Endereçamento indireto: caixa postal Pn Q1 Qn mailbox send ( mailbox , msg ) receive ( mailbox , msg ) dilema em sistemas distribuídos: onde fica a caixa postal ?

Outras Técnicas

RPC (Remote Procede Call) Distributed Shared Memory (DSM) Rendezvous Uma chamada coloca um processo para dormir até que uma segunda chamada rendezvous ocorra Eventos Processos subscrevem / manifestam interesse por eventos RPC (Remote Procede Call) Distributed Shared Memory (DSM) Sincronização por barreira Processos inteiros esperam até que uma “barreira” seja alcançada