Concorrência Aula X. Prof. José Gonçalves - DI/UFES Sist. Operacionais - 2003/2 Concorrência Um...

Concorrência

Aula X

Prof. José Gonçalves - DI/UFESSist. Operacionais - 2003/2

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.


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.

p2

p1

p3

p q

P(p,q)S(p,q)

p

q

p3

p1

p5p4

p2

S(p1, P(p2,p3)) ???


Grafo Propriamente Aninhado

Grafo que pode ser expresso através da composição das funções S e P.

p1

p4

p3

p6p2

p5

p7 p8

p1

p5

p7p3

p8

p6

p2

p4

Fig.1: Sim Fig.2: Não

S(S(p1,P(P(p2,S(p3(P(p4,p5))),p6)),P(p7,p8))


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.

p1 pnp2 . . .

cobegin

coend



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

p1 pnp2 . . .

cobegin

coend



p1;

cobegin

p2

|

p3;

cobegin

p4 | p5

coend

|

p6

coend

cobegin

p7 | p8

coend

p1

p4

p3

p6p2

p5

p7 p8


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.



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.



quit

p

p

fork x

x:

q

join t,w; quit

w:

(t=3)

Cria um processo e inicia a sua execução no rótulo x.

Termina o processo p.

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.



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;





a8: p8; quit;

p1

p5

p7p3

p8

p6

p2

p4


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.


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.


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.


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.


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.


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.


Especificação IndividualV4program

process P1;

k: integer init 0;

while k < 10 do

{ write(1); k:= k+1};

process P2;

k: integer init 0;

while k < 10 do

{ write(2); k:= k+1}

endprogram


Array de Processos

V4program

process p(i:= 1 to 2);

k: integer init 0;

while k < 10 do

{ write(i);

k:= k+1

}

endprogram


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.


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

Concorrência Aula X. Prof. José Gonçalves - DI/UFES Sist. Operacionais - 2003/2 Concorrência Um...

Documents

Transcript of Concorrência Aula X. Prof. José Gonçalves - DI/UFES Sist. Operacionais - 2003/2 Concorrência Um...