Programação Concorrente

Apresentação em tema: "Programação Concorrente"— Transcrição da apresentação:

1 Programação Concorrente
Ambientes Operacionais Prof. Simão Sirineo Toscani

2 Programa Seqüencial x Programa Concorrente
Um programa seqüencial possui um único fluxo de controle (fluxo de execução, linha de execução, thread). Isso permite que o programador realize uma "execução imaginária" de seu programa apontando com o dedo, a cada instante, o comando que está sendo executado. Um programa concorrente possui vários fluxos de execução. Para o programador realizar agora uma "execução imaginária", ele vai necessitar de vários dedos, um para cada fluxo de controle. Execução lógicamente paralela e execução fisicamente paralela.

3 Programa Seqüencial x Programa Concorrente
A programação concorrente é mais complexa. Um programa concorrente pode apresentar todos os tipos de erros que aparecem nos programas seqüenciais e, adicionalmente, os erros associados com as interações entre os processos. Muitos erros dependem do exato instante de tempo em que o escalonador do sistema operacional realiza um chaveamento de contexto. Isso torna muitos erros difíceis de reproduzir e de identificar.

4 Aplicações da programação concorrente
A programação concorrente é natural para vários tipos de aplicações, principalmente para aquelas que apresentam paralelismo implícito Aplicações com paralelismo implícito: aquelas para as quais pode-se distinguir facilmente funções para serem realizadas em paralelo

5 Uma aplicação: Spooling de impressão

6 Organização do servidor de impressão

7 Especificação do paralelismo
Primitivas fork join e quit Primitiva fork no sistema Unix: id = fork() if id = 0 then { processamento do filho } else { processamento do pai }

8 Especificação do paralelismo
Primitiva fork no sistema Vale4: (no sistema Vale4, o fork cria uma thread) id = fork() if id = myNumber then { processamento da filha } else { processamento da mãe }

9 Especificação do paralelismo
Primitivas join(id) e quit Diferença entre thread e processo: Basicamente, está no espaço de endereçamento

10 Especificação do paralelismo Um exemplo
V4program process p1; f1: integer; /* identifica filha 1*/ f2: integer; /* identifica filha 2*/ { write('Alo da mae'); nl; f1:= fork(); /* Cria filha 1 */ if f1 = myNumber then { write('Alo da filha 1'); nl; quit}; f2:= fork(); /* Cria filha 2 */ if f2 = myNumber then { write('Alo da filha 2'); nl; quit}; join(f1); write('Filha 1 morreu'); nl; join(f2); write('Filha 2 morreu'); nl } end program

11 Especificação do paralelismo Criação estática de processos (possibilidade 1)
V4program process P1; k: integer init 0; while k < 10 do { write(1); k:=k+1 }; process P2; { write(2); } end program

12 process P (i := 1 to 2); % array de processos k: integer init 0;
Especificação do paralelismo Criação estática de processos (possibilidade 2) V4program process P (i := 1 to 2); % array de processos k: integer init 0; while k < 10 do { write(i); k:=k+1 } endprogram

13 Especificação do paralelismo Criação dinâmica de processos
V4program process type P (i: integer); k: integer init 0; while k < 10 do { write(i); k:=k+1 }; process Q; { new P(1); new P(2) } endprogram

14 Especificação do paralelismo Torre de Hanoi
V4program process type Hanoi(n, a, b, c: integer); id, m: integer; if n = 1 then { nl; write(a); write(' --> '); write(b) } else { m:= n-1; id:= new Hanoi(m, a, c, b); join(id); nl; write(a); write(' --> '); write(b); id:= new Hanoi(m, c, b, a); join(id) }; process P; new Hanoi(3, 1, 2, 3) endprogram

15 Especificação do paralelismo Compartilhamento de um procedimento
V4program procedure imprime(i: integer); k: integer init 0; while k < 10 do { write(i); k:=k+1 }; process P1; imprime(1); process P2; imprime(2) endprogram

16 Especificação do paralelismo Compartilhamento de uma variável
V4program S : integer init 0; process p1; k: integer init 0; { loop S:= S+1; k:= k+1; exit when k = 100 endloop; nl; write('p1'); tab(2); write(S) }; process p2; nl; write('p2'); tab(2); write(S) } endprogram

17 O problema da exclusão mútua
Comando em linguagem de alto nível: S:= S+1; Código gerado pelo compilador: push S % coloca o valor de S na pilha push $1 % coloca a constante 1 na pilha add % soma os dois últimos valores colocados na pilha pop S % guarda o resultado em S

18 Mecanismos de sincronização
Operações lock e unlock Operações block e wakeup(P) Semáforos Monitores Tasks Operações send e receive

19 Mecanismos de sincronização Semáforos
Semáforos são variáveis especiais que admitem apenas duas operações, denominadas P e V. Sendo S é uma variável semáfora, as operações P e V têm a seguinte semântica: • P(S) : espera até S ser maior que 0 e então subtrai 1 de S; • V(S) : incrementa S de 1.

20 Problemas clássicos Produtor - consumidor Jantar dos filósofos
Barbeiro dorminhoco Leitores e escritores Fumantes Etc.

21 Problemas clássicos Jantar dos filósofos

22 Problemas clássicos Jantar dos filósofos
V4program garfo: array[5] of semaphore init 1; % array global procedure getForks(i: integer); j: integer; { j := i-1 ; % j é o garfo da esquerda if j = 0 then { P(garfo[1]); P(garfo[5]) } else { P(garfo[j]); P(garfo[i]) } }; procedure putForks(i: integer); if j = 0 then { V(garfo[1]); V(garfo[5]) } else { V(garfo[j]); V(garfo[i]) } process filosofo (i:= 1 to 5); k: integer init 10; while k > 0 do { getForks(i); nl; write(‘filosofo ’); write(i); write(‘ comecou a comer’); putForks(i); nl; write(‘filosofo ’); write(i); write(‘ parou de comer’); k:=k-1 } endprogram

23 Problemas clássicos Leitores e escritores
Variáveis globais: mutex, w : semaphore initial 1; nr : integer initial 0; Processo leitor: . . . P(mutex); Processo escritor: nr:=nr+1; if nr=1 then P(w); V(mutex); P(w); READ WRITE P(mutex); V(w); nr:=nr-1; if nr=0 then V(w); V(mutex);

24 FIM