Sistemas Operacionais Programação concorrente

Apresentação em tema: "Sistemas Operacionais Programação concorrente"— Transcrição da apresentação:

1 Sistemas Operacionais Programação concorrente

2 Conceitos apenas um usuário vários usuários podem utilizar
Monoprogramação apenas um programa executando Multiprogramação vários programas podem executar Monousuário apenas um usuário Multiusuário vários usuários podem utilizar

3  Núcleo (kernel) X Micronúcleo (microkernel)
Conceitos Multitarefa » programa pode ser implementado por várias tarefas » processo · uma tarefa · multitarefa  Multiprocessado » vários processadores  Núcleo (kernel) X Micronúcleo (microkernel)

4 Sistemas Multiprogramados
concorrência princípio do intercalamento maior utilização da CPU E/S CPU tempo mono livre 1 E/S CPU tempo multi livre 1 2

5 Programação Concorrente
primeiros conceitos explorar o paralelismo várias aplicações executadas compartilhando a mesma CPU aplicações estruturadas de forma que seus módulos podem ser executados concorrentemente sem interação com interação (compartilhando recursos) o SO pode (e precisa) utilizar esta técnica internamente “o SO pode ser visto como um grande monitor...”

6 Programação Concorrente Hipóteses
teórica programas distribuídos funcionam em qualquer plataforma independe da velocidade de execução intercalamento no tempo vários cenários de execução possíveis velocidade do PC de cada processo é independente não determinística execução e uma instrução PC e dados indefinidos a:= PC2 a:= ( o )o[ ]o( )o[ ]o( )o PC1 o( )o[ ]o( )o[ ]o a PC e dados definidos estáveis

7 Especificação de Concorrência em Programas
Linguagens: Pascal Concorrente: cobegin - coend OOCAM ADA Unix: fork wait Mecanismos para compartilhamento de Recursos memória compartilhada troca de mensagens

8 Interação entre Processos
Processos (que compõem um mesmo programa ou não) podem precisar cooperar entre si Mecanismos para compartilhamento de Recursos variável_comum Memória compartilhada troca de mensagens pedido resposta

9 Problemas de Comunicação e Exclusão Mútua
comunicação entre processos IPC - Inter Process Communication implementação do compartilhamento de recursos problema: inconsistência nos dados compartilhados solução: exclusão mútua e sincronização garantia de que algumas condições serão respeitadas na comunicação entre processos outros problemas deadlock livelock starvation injustiça

10 Exclusão Mútua Requisitos
apenas um processo pode acessar a região crítica no acesso a recursos compartilhados a entrada ou saída de processos competindo pelo mesmo recursos não deve influenciar outros processos ausência de deadlock ou starvation nada é assumido em relação à velocidade de execução dos processos nem ao número dos processos um processo não conhece implicitamente o estado de outro processo daí a necessidade de se garantir o sincronismo e a exclusão mútua

11 Região Crítica uma abstração
program exclusão_mutua; const n = ...; { número de processos } Begin cobegin P (1); P (2); ... P (n); coend End. procedure P (i : integer); repeat <código restante> entra_reg_crítica (R); <código para a região crítica R> sai_reg_critica (R); forever End; uma abstração “área de segurança” para acesso à recursos compartilhados um processo desejando entrar na RC deve ser garantido ao processo a entrada na RC se a RC estiver livre, deve poder fazê-lo sem atrasos um processo só pode ficar na RC durante um período finito de tempo

12 Sincronização Velocidade de execução dos processos é diferente
uso de buffers lê o que ainda não foi escrito inconsistência em banco de dados processos tem “visão” diferente de variáveis problemas semelhantes ao de cache

13 Exclusão Mútua - Soluções por Software
algoritmo de Dekker Djikstra propôs série de soluções evolutivas cada uma evidencia bugs comuns em programas concorrentes 1 - uma variável, buzy waiting 2 - duas variáveis 3 - 3 variáveis 4 - correta algoritmo de Peterson garante exclusão mútua garante justiça para 2 processos

14 Primeira Tentativa espera ocupada (busy-waiting) => while
alternância explícita dos processos velocidade ditada pelo mais lento falhas na RC ? variável global compartilhada => turn: 0..1; . while turn <> 0 do { nothing }; < região crítica > turn := 1; Processo 0 . while turn <> 1 do { nothing }; < região crítica > turn := 0; Processo 1

15 Segunda Tentativa cada processo tem sua própria chave para a RC
cada processo vê o quadro de avisos do outro mas não pode alterá-lo não existe bloqueio se outro processo falha fora da RC (o mesmo não é garantido se este falha dentro da RC) existe falha grave no algoritmo (não garante exclusão mútua) variável global compartilhada => var flag: array [0..1] of boolean; . while flag[ 1 ] do { nothing }; flag[ 0 ] := true; < região crítica > flag[ 0 ] := false; Processo 0 . while flag[ 0 ] do { nothing }; flag[ 1 ] := true; < região crítica > flag[ 1 ] := false; Processo 1

16 Terceira Tentativa em relação à segunda tentativa, apenas uma mudança no código garante exclusão mútua problemas de deadlock (os dois setam o respectivos flags para 1) cada processo pode setar o valor de seu flag sem saber da condição do outro . flag[ 0 ] := true; while flag[ 1 ] do { nothing }; < região crítica > flag[ 0 ] := false; Processo 0 . flag[ 1 ] := true; while flag[ 0 ] do { nothing }; < região crítica > flag[ 1 ] := false; Processo 1

17 Quarta Tentativa processos agora setam seu flag para indicar a intenção pode haver livelock (tracing abaixo) “mutual courtesy” flag[0] = flag[1] = FALSE . flag[1] := true; while flag[0] do begin flag[1] := false; <delay for a short time>; end; < critical section >; Process 1 flag[0] := true; while flag[1] do flag[0] := false; Process 0 flag[1] := true; while flag[1] do flag[0] := true; flag[1] := true; flag[0] := true; while flag[1] do while flag[0] do while flag[0] do flag[0] := false; flag[1] := false; flag[0] := true; flag[0] := false; flag[1] := false; flag[0] := true; flag[1] := true; PO sets flag [0] to true TRUE P1 sets flag [1] to true TRUE P0 checks flag [1] P1 checks flag [0] P0 sets flag [0] to false FALSE P0 sets flag [0] to true TRUE P1 sets flag [1] to false FALSE P1 sets flag [1] to true TRUE

18 Solução Correta uso da variável turn
as variáveis flag ainda são usadas algoritmo original de Dekker algoritmo complexo e de prova difícil

19 Algoritmo de Dekker var flag: array [0 .. 1] of boolean; turn: 0 .. l;
procedure Pl; begin repeat flag [1] := true; while flag [0] do if turn = 0 then flag [1] := false; while turn = 0 do {nothing}; flag [1] := true end; < região crítica >; turn := 0; < restante > forever procedure P0; begin repeat flag [0] := true; while flag [1] do if turn = 1 then flag [O] := false; while turn = 1 do {nothing}; flag [0] := true end; < região crítica >; turn := 1; flag [0] := false; < restante > forever Begin flag [0] := false; flag [1] := false; turn := 1; parbegin P0; P1 parend end.

20 Algoritmo de Petterson
garante exclusão mútua e justiça (para 2 processos ?) também usa flags (mutex) e turn (conflitos) var flag array [0 ..1] of boolean; turn:0..1; procedure P0; begin repeat flag [0] := true; turn := 1; while flag [1] and turn = 1 do {nothing}; < região crítica >; flag [0] := false; < restante > forever end; procedure Pl; begin repeat flag [1] := true; turn := 0; while flag [0] and turn = 0 do {nothing}; < região crítica >; flag [1] := false; < restante > forever end; begin flag [0] := false; flag [1] := false; turn := 1; parbegin P0; P1 parend end.

21 Sincronização - Soluções por Hardware
desabilitar interrupções instruções implementadas por hardware test-and-set (atômicas) exchange protocolo de exclusão mútua ex.: repeat { nothing } until testeset (variável); repeat exchange (key_i, bolt) until key_i = 0; simples, vários processos, várias RCs espera ocupada, starvation, deadlock

22 Sincronização - Soluções por Software
Semáforos mecanismo proposto em 1967 por Dijkstra recurso acessado somente por funções específicas: wait e signal wait e signal são atômicos o semáforo deve ser compartilhados por todos os processos que vão utilizá-lo como mecanismo para exclusão mútua ou sincronização

23 Sincronização - Soluções por Software
init ( sem) Contador S wait (sem ) signal ( sem) Fila K wait (sem) : s:= s - 1 se sem >= 0 então processo prossegue se sem < 0 então processo é bloqueado na fila de espera K signal (sem) : s:= s + 1 se houver processo bloqueado na fila de espera, um deles é escolhido para se desbloquear e prosseguir operações também chamadas de P e V por motivos históricos

24 Implementação de semáforos:
Definir um semáforo como um “record”: Oferecer duas operações simples: “block” suspende o processo que a invocou. “wakeup(P)” reinicia a execução de um processo “P” bloqueado. type semaphore = record value: integer; L: list of process; end;

25 Implementação (Cont.) As operações dos semáforos agora serão definidas como: wait(S): S.value := S.value – 1; if S.value < 0 then begin adiciona esse processo à S.L; block; end; signal(S): S.value := S.value + 1; if S.value  0 remove o processo P de S.L; wakeup(P);

26 Dois tipos de semáforos
Counting semaphore (semáforo contador) – valor inteiro que pode variar por uma faixa de valores sem restrição. Binary semaphore (semáforo binário) – valor inteiro que varia somente entre 0 e 1; pode ser simples de se implementar. Podemos implementar um semáforo contador como um semáforo binário.

27 Exemplos exclusão mútua sincronização situação de deadlock
sem := 1; ... wait (sem); . seção crítica signal (sem); exclusão mútua sincronização tarefa A espera em L1: até que tarefa B atinja ponto L2: situação de deadlock Tarefa_A prossiga := 0; ... L1: wait (prossiga); Tarefa_B ... L2: signal (prossiga); Tarefa_A ... wait (x); wait (y); Tarefa_B ... wait (y); wait (x);

28 Problema I: Produtores/Consumidores
vários processos: produtores consumidores cada processo tem seu ritmo (nada é assumido sobre o tempo de execução produtor produz item e coloca em um buffer consumidor pega item no buffer e consome buffer infinitos finitos (circular)

29 Produtor/Consumidor Buffer Ilimitado
proposta da turma dica consumidor só é liberado para pegar item depois que o produtor colocar o item no buffer um semáforo um ponteiro para a posição do produtor na fila um ponteiro para a posição do consumidor na fila

30 Exemplos Bounded Buffer Solução “Ad Hoc”
Module Example ( ); type item : ...; var buffer: array [ 0..3 ] of item; in, out : 0..3; nextp, nextc: item; 1 2 3 task producer: loop ... produz um item em netxp while (in + 1) mod 3 = out do nothing; buffer [in] := nextp; in := (in + 1) mod 3; endloop; in in out out in out in out in out task consumer: loop ... while in = out do nothing; nextc := buffer [out]; out := (out + 1) mod 3; consome o item em netxp endloop; Begin in := 0; out := 0; endModule;

31 Solução com semáforo de contagem
program BufferLimitado; const TamFila = ...; var Fila : array [1..TamFila] of TipDado; Item : semaphore; Vaga: semaphore; procedure Consumidor; var IniFila : (1..TamFila); W : tipDado; begin IniFila := 1; repeat wait (Item); W := Fila [ IniFila ] ; IniFila := (IniFila mod TamFila) + 1; signal (Vaga); Consumir (W); until Fim; end; procedure Produtor; var FimFila : (1..TamFila); V : tipDado; begin FimFila := 1; repeat Produzir (V); wait (Vaga); Fila [ FimFila ] := V; FimFila := (FimFila mod TamFila) + 1; signal (Item); until Fim; end; Begin InitSem (Item, 0); InitSem (Vaga, TamFila); cobegin Produtor; Consumidor; coend; End.

32 Exemplos Bounded Buffer Solução com Semáforos
Module Example; type item : ...; var buffer: array [0.. n-1] of item; full, empty, mutex: semaphore; nextp, nextc: item; pontP, pontC: ponteiros; Exemplos Bounded Buffer Solução com Semáforos task producer: loop produz um item em netxp ... wait (empty); wait (mutex); adiciona nextp ao buffer; ajusta PontP; signal (mutex); signal (full); endloop; task consumer: loop ... wait (full); wait (mutex); remove um item do buffer ajusta pontC signal (mutex); signal (empty); consome o item em netxp endloop; funciona para qualquer estrutura de dados para o buffer mutex: exclusão mútua full > 0 existe algum item produzido empty > 0 existe espaço vazio no buffer Begin full := 0; pontC = 0; empty := n; pontP = 0; mutex := 1; endModule;

33 Sincronização - Soluções por Software
Brich Hansen e Hoare Monitores solução estruturada concentra partes críticas de sincronização funções e procedimentos declarados pelo programador estão protegidas e encapsuladas dentro do monitor além das funções o monitor encapsula dados procedimentos dentro do monitor são executados em exclusão mútua o monitor possui uma fila (FIFO) de entrada onde, processos desejando executar um procedimento do monitor, aguardam sua vez

34 Monitores: programação
Variável de Condição (um tipo primitivo dos monitores, na verdade são os nomes de uma fila FIFO) dois procedimentos e uma função atuam sobre a variável de condição wait (condição) processo é suspenso e vai para o fim da fila “condição” signal (condição) primeiro processo suspenso na fila “condição” retorna a sua execução NonEmpty (condição) TRUE se a fila “condição” não estiver vazia semântica das funções wait e signal dos monitores é diferente do semáforo (não tem memória)

35 fila de entrada no monitor
processos na pilha têm prioridade sobre os novos processos só tem acesso aos procedimentos do monitor saída do monitor fila de entrada no monitor Quintal da Pilha topo ... Procedimentos do Monitor P1 Pn P2 P3 Quintal das filas de condições C1 C2 C3 Monitor signal (C2) wait (C1)

36 Monitores: Interface de Programação
monitor exemplo; < declara variáveis locais ao monitor>; procedure entry proc_name_1; Begin <corpo do procedimento 1> End; procedure entry proc_name_2; <corpo do procedimento 2>; ... < inicialização das variáveis do monitor >; End exemplo;

37 Produtores/Consumidores com Monitor
encapsulamento exclusão mútua var buf: array [1..n] of item; in, out, count: integer; a_buf_is_full, a_buf_is_empty: condition; monitor bounded_buffer (n: integer); begin if count = n then a_buf_is_empty.wait; buf [in] := it; in := (in mod n) + 1; count := count + 1; a_buf_is_full.signal; end; proc entry insert (it: item); begin if count = 0 then a_buf_is_full.wait; it := buf [out]; out := (out mod n) + 1; count := count -1; a_buf_is_empty.signal; end; proc entry remove (it: item); begin in := 0; out := 0; a_buf_is_empty := true; a_buf_is_full := false; count := 0; end; Inicialização Tarefa produtor: bounded_buffer.insert (p); Tarefa consumidor: bounded_buffer.remove (p);

38 Monitores e Semáforos podemos simular semáforos do tipo FIFO com monitores exercício para turma podemos construir um monitor com semáforos

39 Barbeiro Dorminhoco

40 Leitores e Escritores vários processos escritores e leitores competindo por um recurso comum O acesso ao recurso comum por um escritor deve ser feito em exclusão mútua entre leitores, exclusão mútua não é exigida se há um escritor escrevendo, escritores esperando para escrever e leitores esperando para ler o primeiro escritor na fila não começará a a escrever até que todos os leitores que estiverem esperando o escritor escrever tenham acabado de ler se há leitores lendo chega primeiro um escritor para esperar para escrever novos leitores que chegarem ficarão suspensos se há leitores lendo, escritores esperando e leitores esperando todos os leitores esperando para ler não vão começar a ler até que o primeiro escritor que está esperando para escrever acabe de escrever

41 Escr/Leit: monitor program LeitoresEscritores; procedure Leitor; begin
monitor MonitorLeitoresEscritores; var Leitores : integer; Escrevendo : boolean; PodeLer, PodeEscrever : condition; procedure ComecarALer; begin if (Escrevendo or NonEmpty(PodeEscrever)) then wait(PodeLer); Leitores:=Leitores+l; signal (PodeLer); end; procedure AcabarDeLer; Leitores:=Leitores-1; if Leitores=0 then signal(PodeEscrever); procedure Leitor; begin repeat ComecarALer; LerDado; AcabarDeLer; ConsumirDado; until false; end; procedure Escritor; ProduzirDado; ComecarAEscrever; EscreverDado; AcabarDeEscrever; Begin cobegin Leitorl ; Escritorl; ...; coend; end. procedure ComecarAEscrever; begin if ((Leitores<>0) or Escrevendo) then wait(PodeEscrever); Escrevendo:=true; end; procedure AcabarDeEscrever; escrevendo := false; if NonEmpty(PodeLer) then signal(PodeLer) else signal (PodeEscrever); begin Leitores:=0; Escrevendo:=false; end;

42 Sincronização Troca de Mensagens send / receive endereçamento API
direto caixa postal API System V IPC Messages sockets RPC CORBA

43 Verificação de Programas Concorrentes
Provas formais de corretude lógica temporal linguagens que permitem verificações formais de propriedades ADA (Rendevouz) CCS CSP Estelle Lotus Redes de Petri Pi Calculus

44 Problema dos Filósofos
problema clássico de exclusão mútua filósofos pensam e comem em um tempo arbitrário para comer: 2 pauzinhos evitar starvation (esfomeação) deadlock soluções semáforo monitor