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

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

Módulo 5 - pag. 1 Alexandre 2001 Sistemas Operacionais Programação concorrente.

Apresentações semelhantes


Apresentação em tema: "Módulo 5 - pag. 1 Alexandre 2001 Sistemas Operacionais Programação concorrente."— Transcrição da apresentação:

1 Módulo 5 - pag. 1 Alexandre 2001 Sistemas Operacionais Programação concorrente

2 Módulo 5 - pag. 2 Alexandre 2001 Monoprogramação apenas um programa executando Multiprogramação vários programas podem executar 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 Monousuário apenas um usuário Multiusuário vários usuários podem utilizar Conceitos

3 Módulo 5 - pag. 3 Alexandre 2001 Multitarefa » programa pode ser implementado por várias tarefas » processo · uma tarefa · multitarefa Multitarefa » programa pode ser implementado por várias tarefas » processo · uma tarefa · multitarefa Multiprocessado » vários processadores Multiprocessado » vários processadores Núcleo (kernel) X Micronúcleo (microkernel) Conceitos

4 Módulo 5 - pag. 4 Alexandre 2001 E/S CPU tempo mono livre 11 1 Sistemas Multiprogramados E/S CPU tempo multi livre concorrência –princípio do intercalamento –maior utilização da CPU concorrência –princípio do intercalamento –maior utilização da CPU

5 Módulo 5 - pag. 5 Alexandre 2001 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 Módulo 5 - pag. 6 Alexandre 2001 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 ( o )o[ ]o( )o[ ]o( )o o( )o[ ]o( )o[ ]o execução e uma instrução PC e dados indefinidos PC e dados definidos estáveis a:= a PC1 PC2

7 Módulo 5 - pag. 7 Alexandre 2001 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 Módulo 5 - pag. 8 Alexandre 2001 Interação entre Processos Processos (que compõem um mesmo programa ou não) podem precisar cooperar entre si Mecanismos para compartilhamento de Recursos troca de mensagens pedido resposta variável_comum Memória compartilhada

9 Módulo 5 - pag. 9 Alexandre 2001 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 Módulo 5 - pag. 10 Alexandre 2001 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 Módulo 5 - pag. 11 Alexandre 2001 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 program exclusão_mutua; const n =...; { número de processos } Begin cobegin P (1); P (2);... P (n); coend End. program exclusão_mutua; const n =...; { número de processos } Begin cobegin P (1); P (2);... P (n); coend End. procedure P (i : integer); Begin repeat entra_reg_crítica (R); sai_reg_critica (R); forever End; procedure P (i : integer); Begin repeat entra_reg_crítica (R); sai_reg_critica (R); forever End; Região Crítica

12 Módulo 5 - pag. 12 Alexandre 2001 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 Módulo 5 - pag. 13 Alexandre 2001 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 variáveis 4 - correta algoritmo de Peterson –garante exclusão mútua –garante justiça para 2 processos

14 Módulo 5 - pag. 14 Alexandre 2001 Primeira Tentativa espera ocupada (busy-waiting) => while alternância explícita dos processos velocidade ditada pelo mais lento falhas na RC ?. while turn <> 0 do { nothing }; turn := 1;. while turn <> 0 do { nothing }; turn := 1;. Processo 0. while turn <> 1 do { nothing }; turn := 0;. while turn <> 1 do { nothing }; turn := 0;. Processo 1 variável global compartilhada => turn: 0..1;

15 Módulo 5 - pag. 15 Alexandre 2001 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). while flag[ 1 ] do { nothing }; flag[ 0 ] := true; flag[ 0 ] := false;. while flag[ 1 ] do { nothing }; flag[ 0 ] := true; flag[ 0 ] := false;. Processo 0. while flag[ 0 ] do { nothing }; flag[ 1 ] := true; flag[ 1 ] := false;. while flag[ 0 ] do { nothing }; flag[ 1 ] := true; flag[ 1 ] := false;. Processo 1 variável global compartilhada => var flag: array [0..1] of boolean;

16 Módulo 5 - pag. 16 Alexandre 2001 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 }; flag[ 0 ] := false;. flag[ 0 ] := true; while flag[ 1 ] do { nothing }; flag[ 0 ] := false;. Processo 0. flag[ 1 ] := true; while flag[ 0 ] do { nothing }; flag[ 1 ] := false;. flag[ 1 ] := true; while flag[ 0 ] do { nothing }; flag[ 1 ] := false;. Processo 1

17 Módulo 5 - pag. 17 Alexandre 2001 flag[0] = flag[1] = flag[0] = flag[1] = FALSE. flag[1] := true; while flag[0] do begin flag[1] := false; ; flag[1] := true; end; ; flag[1] := false;.. flag[1] := true; while flag[0] do begin flag[1] := false; ; flag[1] := true; end; ; flag[1] := false;. Process 1. flag[0] := true; while flag[1] do begin flag[0] := false; ; flag[0] := true; end; ; flag[0] := false;.. flag[0] := true; while flag[1] do begin flag[0] := false; ; flag[0] := true; end; ; flag[0] := false;. Process 0 P1 sets flag [1] to true TRUE P1 sets flag [1] to false FALSE PO sets flag [0] to true TRUE P0 sets flag [0] to false FALSE P0 sets flag [0] to true TRUE flag[0] := true; flag[1] := true; flag[1] := false; flag[0] := true; flag[0] := false; flag[1] := false; flag[1] := true; while flag[1] do flag[0] := true; flag[1] := true; flag[0] := true; Quarta Tentativa processos agora setam seu flag para indicar a intenção pode haver livelock (tracing abaixo) mutual courtesy P0 checks flag [1] P1 checks flag [0] P1 sets flag [1] to true TRUE while flag[0] do flag[0] := false; while flag[1] dowhile flag[0] do

18 Módulo 5 - pag. 18 Alexandre 2001 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 Módulo 5 - pag. 19 Alexandre 2001 Algoritmo de Dekker var flag: array [0.. 1] of boolean; turn: 0.. l; var flag: array [0.. 1] of boolean; turn: 0.. l; procedure P0; begin repeat flag [0] := true; while flag [1] do if turn = 1 then begin flag [O] := false; while turn = 1 do {nothing}; flag [0] := true end; ; turn := 1; flag [0] := false; forever end; procedure Pl; begin repeat flag [1] := true; while flag [0] do if turn = 0 then begin flag [1] := false; while turn = 0 do {nothing}; flag [1] := true end; ; turn := 0; flag [1] := false; forever end; Begin flag [0] := false; flag [1] := false; turn := 1; parbegin P0; P1 parend end. Begin flag [0] := false; flag [1] := false; turn := 1; parbegin P0; P1 parend end.

20 Módulo 5 - pag. 20 Alexandre 2001 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; 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}; ; flag [0] := false; forever end; procedure Pl; begin repeat flag [1] := true; turn := 0; while flag [0] and turn = 0 do {nothing}; ; flag [1] := false; forever end; begin flag [0] := false; flag [1] := false; turn := 1; parbegin P0; P1 parend end. begin flag [0] := false; flag [1] := false; turn := 1; parbegin P0; P1 parend end.

21 Módulo 5 - pag. 21 Alexandre 2001 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); »ex.: repeat exchange (key_i, bolt) until key_i = 0; –simples, vários processos, várias RCs –espera ocupada, starvation, deadlock

22 Módulo 5 - pag. 22 Alexandre 2001 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 Módulo 5 - pag. 23 Alexandre 2001 Sincronização - Soluções por Software 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 0..N wait (sem ) signal ( sem) init ( sem) Contador S Fila K

24 Módulo 5 - pag. 24 Alexandre 2001 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. Implementação de semáforos: type semaphore = record value: integer; L: list of process; end;

25 Módulo 5 - pag. 25 Alexandre 2001 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 then begin remove o processo P de S.L; wakeup(P); end;

26 Módulo 5 - pag. 26 Alexandre 2001 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 Módulo 5 - pag. 27 Alexandre 2001 Exemplos exclusão mútua sincronização –tarefa A espera em L1: até que tarefa B atinja ponto L2: situação de deadlock sem := 1;... wait (sem);. seção crítica. signal (sem);... sem := 1;... wait (sem);. seção crítica. signal (sem);... Tarefa_A prossiga := 0;... L1: wait (prossiga);... Tarefa_A prossiga := 0;... L1: wait (prossiga);... Tarefa_B... L2: signal (prossiga);... Tarefa_B... L2: signal (prossiga);... Tarefa_A... wait (x);... wait (y);... Tarefa_A... wait (x);... wait (y);... Tarefa_B... wait (y);... wait (x);... Tarefa_B... wait (y);... wait (x);...

28 Módulo 5 - pag. 28 Alexandre 2001 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 Módulo 5 - pag. 29 Alexandre 2001 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 Módulo 5 - pag. 30 Alexandre Exemplos Bounded Buffer Solução Ad Hoc inout 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; 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; task consumer: loop... while in = out do nothing; nextc := buffer [out]; out := (out + 1) mod 3;... consome o item em netxp... endloop; 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; Begin in := 0; out := 0; endModule; Module Example ( ); type item :...; var buffer: array [ 0..3 ] of item; in, out : 0..3; nextp, nextc: item; Module Example ( ); type item :...; var buffer: array [ 0..3 ] of item; in, out : 0..3; nextp, nextc: item; in out inout

31 Módulo 5 - pag. 31 Alexandre 2001 Solução com semáforo de contagem 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; 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; 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 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; program BufferLimitado; const TamFila =...; var Fila : array [1..TamFila] of TipDado; Item : semaphore; Vaga: semaphore; program BufferLimitado; const TamFila =...; var Fila : array [1..TamFila] of TipDado; Item : semaphore; Vaga: semaphore; Begin InitSem (Item, 0); InitSem (Vaga, TamFila); cobegin Produtor; Consumidor; coend; End. Begin InitSem (Item, 0); InitSem (Vaga, TamFila); cobegin Produtor; Consumidor; coend; End.

32 Módulo 5 - pag. 32 Alexandre 2001 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; Module Example; type item :...; var buffer: array [0.. n-1] of item; full, empty, mutex: semaphore; nextp, nextc: item; pontP, pontC: ponteiros; task consumer: loop... wait (full); wait (mutex);... remove um item do buffer ajusta pontC... signal (mutex); signal (empty);... consome o item em netxp 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 task producer: loop produz um item em netxp... wait (empty); wait (mutex);... adiciona nextp ao buffer; ajusta PontP;... signal (mutex); signal (full); endloop; task producer: loop produz um item em netxp... wait (empty); wait (mutex);... adiciona nextp ao buffer; ajusta PontP;... signal (mutex); signal (full); endloop; Begin full := 0; pontC = 0; empty := n; pontP = 0; mutex := 1; endModule; Begin full := 0; pontC = 0; empty := n; pontP = 0; mutex := 1; endModule;

33 Módulo 5 - pag. 33 Alexandre 2001 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 Módulo 5 - pag. 34 Alexandre 2001 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 Módulo 5 - pag. 35 Alexandre 2001 processos só tem acesso aos procedimentos do monitor processos só tem acesso aos procedimentos do monitor processos na pilha têm prioridade sobre os novos processos na pilha têm prioridade sobre os novos saída do monitor fila de entrada no monitor Quintal da Pilha topo... Procedimentos do Monitor P1PnP2P3... Quintal das filas de condições... C1C2C3 Monitor signal (C2) wait (C1)

36 Módulo 5 - pag. 36 Alexandre 2001 Monitores: Interface de Programação monitor exemplo; ; procedure entry proc_name_1; Begin End; procedure entry proc_name_2; Begin ; End;... Begin ; End exemplo;

37 Módulo 5 - pag. 37 Alexandre 2001 Produtores/Consumidores com Monitor encapsulamento exclusão mútua Tarefa produtor: bounded_buffer.insert (p); Tarefa consumidor: bounded_buffer.remove (p); 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 in := 0; out := 0; a_buf_is_empty := true; a_buf_is_full := false; count := 0; end; begin in := 0; out := 0; a_buf_is_empty := true; a_buf_is_full := false; count := 0; end; Inicialização 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; 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; 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);

38 Módulo 5 - pag. 38 Alexandre 2001 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 Módulo 5 - pag. 39 Alexandre 2001 Barbeiro Dorminhoco

40 Módulo 5 - pag. 40 Alexandre 2001 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 Módulo 5 - pag. 41 Alexandre 2001 Escr/Leit: monitor procedure Leitor; begin repeat ComecarALer; LerDado; AcabarDeLer; ConsumirDado; until false; end; procedure Escritor; begin repeat ProduzirDado; ComecarAEscrever; EscreverDado; AcabarDeEscrever; until false; end; Begin cobegin Leitorl ; Escritorl;...; coend; end. program LeitoresEscritores; 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; begin Leitores:=Leitores-1; if Leitores=0 then signal(PodeEscrever); end; procedure ComecarAEscrever; begin if ((Leitores<>0) or Escrevendo) then wait(PodeEscrever); Escrevendo:=true; end; procedure AcabarDeEscrever; begin escrevendo := false; if NonEmpty(PodeLer) then signal(PodeLer) else signal (PodeEscrever); end; begin Leitores:=0; Escrevendo:=false; end;

42 Módulo 5 - pag. 42 Alexandre 2001 Sincronização Troca de Mensagens send / receive endereçamento –direto –caixa postal API –System V IPC Messages –sockets –RPC –CORBA

43 Módulo 5 - pag. 43 Alexandre 2001 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 Módulo 5 - pag. 44 Alexandre 2001 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 Problema dos Filósofos


Carregar ppt "Módulo 5 - pag. 1 Alexandre 2001 Sistemas Operacionais Programação concorrente."

Apresentações semelhantes


Anúncios Google