Concorrência Aula X

Prof. José Gonçalves - DI/UFES Concorrência Um programa executado por apenas um processo é dito “programa seqüencial”. Existe um único fluxo (thread) de execução. Um programa concorrente é executado por vários processos, que cooperam entre si para a realização de uma tarefa (aplicação). Existem vários fluxos (threads) de execução. Necessidade de interação para troca de informações (comunicação e sincronização entre processos). Ex: estrutura do próprio S.O. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Prof. José Gonçalves - DI/UFES Grafo de Precedência Os mecanismos para especificar concorrência (isto é, para criar e terminar processos) devem permitir expressar relações de precedência arbitrárias entre processos. p p1 p1 p q q p2 p2 p3 S(p,q) P(p,q) p3 p4 p5 S(p1, P(p2,p3)) ??? Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Grafo Propriamente Aninhado Grafo que pode ser expresso através da composição das funções S e P. Fig.2: Não Fig.1: Sim p1 p1 p2 p3 p5 p4 p2 p6 p3 p7 p4 p5 p6 S(S(p1,P(P(p2,S(p3(P(p4,p5))),p6)),P(p7,p8)) p8 p7 p8 Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Primitivas cobegin/coend (1) Denominadas originalmente por Dijkstra (1965) como parbegin e parend, explicitam um conjunto de trechos de código para serem executados concorrentemente. Sintaxe: cobegin C1|C2|...|Cn coend Cada Ci é um segmento de código autônomo. Quando a execução chega ao cobegin, são criados n processos independentes para executar os segmentos de código especificados. cobegin p1 p2 . . . pn coend Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Primitivas cobegin/coend (2) Observações: A execução do comando só termina quando todos os n processos terminam as suas execuções. A construção cobegin/coend permite representar apenas grafos propriamente aninhados. O operador seqüencial (“;”) tem precedência sobre o operador paralelo (“|”). Ex: cobegin p1 | p2; p3 coend p1; cobegin p2 | p3; coend cobegin p1 p2 . . . pn coend Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Primitivas cobegin/coend (3) | p3; p4 | p5 coend p6 p7 | p8 p1 p3 p2 p6 p4 p5 p7 p8 Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

As Primitivas fork, join e quit (1) Definidas por Conway (1963), são mais gerais que as primitivas cobegin/coend pois permitem descrever qualquer grafo de fluxo de processos. A execução de fork x por um processo p faz com que um novo processo q seja criado e inicie a sua execução na instrução com rótulo x. A partir daí, os processos p e q são executados simultaneamente. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

As Primitivas fork, join e quit (2) Se um processo executa a primitiva quit ele termina. A instrução join t,w tem a seguinte semântica: -------------------------------- t := t – 1; if t=0 then goto w else nothing; --------------------------------------- É uma operação atômica ou indivisível. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

As Primitivas fork, join e quit (3) fork x join t,w; quit quit Termina o processo p. x: w: q Três processos executam a seqüência join t,w; quit com t=3. Quando chega o terceiro processo, sua execução é desviada para o rótulo w. Cria um processo e inicia a sua execução no rótulo x. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

As Primitivas fork, join e quit (4) t1:=2; t2:=3; p1; fork a2; fork a5; fork a7; quit; a2: p2; fork a3; fork a4; quit; a3: p3; join t2,a8; quit; a4: p4; join t1,a6; quit; a5: p5; join t1,a6; quit; a6: p6; join t2,a8; quit; a7: p7; join t2,a8; quit; a8: p8; quit; p1 p2 p4 p5 p3 p7 p6 p8 Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

cobegin/coend x fork/join/quit A opção por mecanismos do tipo cobegin/coend ao invés de mecanismos mais gerais do tipo fork/join/quit é justificada pela importância de se ter uma maior estruturação para os programas concorrentes já que esses últimos podem tornar os programas confusos,principalmente quando usadas dentro de loops ou outras estruturas de controle. Assim, perde-se no poder de representação dos mecanismos, mas ganha-se na clareza da semântica dos programas. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Prof. José Gonçalves - DI/UFES Fork no Sistema Unix (1) O Unix usa uma simplificação do fork, a qual cria uma cópia idêntica do processo que executa esta operação. O comando id = fork() cria um filho idêntico ao processo que executou a operação.O filho recebe cópia das variáveis do processo pai (cópias privativas),bem como dos descritores de arquivos. Os valores iniciais das variáveis do filho são iguais às do pai no momento da execução do fork. A única diferença é o valor da variável id, que é 0 para o filho e é o valor de retorno da função fork para o pai. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Prof. José Gonçalves - DI/UFES Fork no Sistema Unix (2) O valor de retorno é o número de identificação do processo criado, referido por pid (process identification). Isto permite que os processos prossigam de acordo com suas identidades. Normalmente o comando seguinte ao fork tem a seguinte forma: if id = 0 then {processamento do filho} else {processamento do pai} Um dos processos pode sobrepor um novo código sobre si,através da operação exec, a qual especifica um novo segmento de código e de dados para o processo. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Prof. José Gonçalves - DI/UFES O Conceito de Thread (1) Igual ao fork, com a diferença que o pai e o filho compartilham o mesmo espaço de endereçamento (as mesmas variáveis, os mesmos descritores de arquivos,etc.). Simplificação: Pai e filho passam a ser descritos por um mesmo (único) registro descritor e cada um passa a utilizar um ”mini-descritor” próprio, para conter os atributos em que diferem. Diminui o overhead já que não é mais necessário tantas trocas de contexto entre processos. Pode-se dizer que nos processos ficam mais “leves” (“threads = ligthweight process”) já que todas as threads de um processo são descritas por um mesmo (único) descritor. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Prof. José Gonçalves - DI/UFES O Conceito de Thread (2) Simplificação (cont.): Cada thread possui um mini-descritor e uma pilha. O mini-descritor é usado para salvar os valores dos registradores da CPU (PC,PSW, etc.) e a pilha é usada para as chamadas e retornos de procedimentos. A função fork() do Unix cria um novo processo (não uma thread), pois pai e filho possuem espaços de endereçamento distintos. Não há compartilhamento de variáveis, embora sejam usados os mesmos nomes para as mesmas. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Criação Estática de Processos Processos são declarados explicitamente (dados + código) no programa fonte e vão existir desde o início da execução do programa concorrente. Duas maneiras: Especificação de processos individuais; Especificação de array de processos. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Especificação Individual V4program process P1; k: integer init 0; while k < 10 do { write(1); k:= k+1}; process P2; { write(2); k:= k+1} endprogram Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Prof. José Gonçalves - DI/UFES Array de Processos V4program process p(i:= 1 to 2); k: integer init 0; while k < 10 do { write(i); k:= k+1 } endprogram Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

Criação Dinâmica de Processos Os processos são criados dinamicamente, durante a execução, através de instruções específicas para esse fim. Cobegin/coend, fork/join/quit realizam a criação e término dinâmico de processos (ou threads). Também é possível criar dinamicamente processos que são declarados explicitamente. Para isso, o usuário explicita um modelo (template), que é usado para criar cópias (clones) do processo durante a execução. Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES

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 qqnome; { new p(1); new p(2)} endprogram Sist. Operacionais - 2003/2 Prof. José Gonçalves - DI/UFES