Especificao de Sistemas Distribudos

DEFINIO DE UM CANAL channel ch: T DEFINIO DE UM EVENTO channel eve CANAIS E EVENTOS channel ch: Int eventos = {ch.0, ch.1, ..., ch.N} {|x|} = {ch.0, ..., ch.N} ENTRADA DE DADOS in?var ch?x:A, onde A um subconjunto de inteiro ch?x:{0,1,2} ch?x:{x<=10} ch?x?y:{(x-1)..(x+1)} SADA DE DADOS out!exp SINCRONIZAO/SADA DE DADOS ch.expS OBS.: Evitar usar ch?(1+x) e ch.(1+x2) ALFABETO DE UM PROCESSO : unio dos alfabetos de todos os processos P: alfabeto de um processo PROCESSOS BSICOS STOP: estado terminal de onde no se pode mais sair, representa deadlock ou falha ?x:{ } -> P(x) SKIP: trmino com sucesso, evento P |~| Q, escolha interna pelo processo, pode rejeitar eventos de P ou Q ESCOLHA EXTERNA P [ ] Q, escolha pelo ambiente If eventos iniciais comuns, no-determinismo Sempre oferece os eventos de P e Q ESCOLHA INTERNA ESCOLHA CONDICIONAL if cond the P else Q (cond & P) = if cond then P else STOP PREFIXO evento -> processo DEFINIO DE UM PROCESSO channel up, down P0 = up -> down -> STOP P1 = up -> down -> P2 (recursiva) P2 = up -> down -> up -> down -> P1 P3 = up -> down -> P3 (guarda) PARAMETRIZAO DE PROCESSOS COUNT(n)= if n==0 then (up -> COUNT(1)) else (up -> COUNT(n+1) [ ] down -> COUNT(n-1)) ENTRADA E ESCOLHA c?x -> P = c.e0 -> P[e0 / x] [] [] c.eN -> P[eN / x] ESCOLHA PREFIXADA ?x:A -> P(x) = [ ] x:A @ x -> P(x)

Especificao de Sistemas Distribudos

EVENTOS COMPOSTOS channel c: A.B c.a.b -> c?x!b -> x ,|x|- = ,c.a.b, c.a1.b, PROCESSOS ESPECIAIS RUN(X) = [ ] x:X @ x -> RUN(X) Processo que aceita sincronizar com qualquer evento em qualquer instncia de tempo Chaos(X) = STOP |~| ([ ] x:X @ x -> Chaos(x)) LEIS ALGBRICAS P[]P=P P[]Q=Q[]P P [ ] (Q [ ] R) = (P [ ] Q) [ ] R STOP [ ] P = P P |~| P = P P |~| Q = Q |~| P P |~| (Q |~| R) = (P |~| Q) |~| R P.((a -> P) |~| (b -> P)) != (P.a -> P) |~| (P.b -> P) COMPOSIO PARALELA ALFABETIZADA P [X||Y] Q Executa P e Q em paralelo, mas s sincronizando os eventos comuns a X e Y Se X==Y=Events, ento P||Q = P [X||Y] Q Conjunto de eventos iniciais: C = (A(X\Y)) (B(Y\X)) (ABXY) Step Law P = c?x:A -> P Q = c?x:B -> Q P [X||Y] Q = c?x: C -> if (xX) then P else P [X||Y] if (xY) then Q else Q ENTRELAAMENTO P ||| Q P e Q so executados em paralelo, de forma independente, sem sincronizar eventos. A escolha da execuo do mesmo evento de P e Q no-determinstica. Step Law P = c?x:A -> P Q = c?x:B -> Q P ||| Q = c?x:AB -> if (xAB) then (P ||| Q) |~| (P ||| Q) else if (xA) then (P ||| Q) else (P ||| Q) LEIS ALGBRICAS 1. P ||| Q = Q ||| P 2. P ||| (Q ||| R) = (P ||| Q) ||| R 3. P ||| (Q |~| R) = (P ||| Q) |~| (P ||| R) 4. P ||| SKIP = P 5. STOP ||| SKIP = STOP

CONCORRNCIA/PARALELISMO COMPOSIO PARALELA SNCRONA (P||Q) P e Q so processos que andam somente quando aparecer algum evento comum ao alfabeto dos dois, caso contrrio, refuta. P||Q = P [|Events|] Q TRANFORMAR PARALELO EM SEQUENCIAL c?x:A -> P || c?y:B -> Q = c?z:(A B) -> (P || Q)

Especificao de Sistemas Distribudos

COMPOSIO PARALELA GENERALIZADA P [|X|] Q P e Q so executados em paralelo mas s sincronizando os eventos em X. Sendo A e B os eventos iniciais de P e Q, inicialmente oferece o seguinte conjunto: C = {A\X) U (B\X) U (A BX} P = c?x:A -> P Q = c?x:B -> Q P [|X|] Q = c?x:C -> if (xX) then P[|X|] Q else if (xAB) then (P [|X|] Q) |~| (P [|X|] Q) else if (xA) then (P [|X|] Q) else (P [|X|] Q) LEIS ALGBRICAS 1. P [|X|] Q = Q [|X|] P 2. P [|X|] (Q |~| R) = (P [|X|] Q) |~| (P [|X|] R) 3. P [|X|] (Q [|X|] R) = (P [|X|] Q) [|X|] R) DEFININDO COMPOSIO PARALELA GENERALIZADA PARA OUTROS OPERADORES P||Q = P [|Events|] Q P *X||Y+ Q = P*|XY|+ Q P|||Q = P [|{ }|] Q HIDING P\X - COMPORTA-SE COMO P EXCETO QUE OS EVENTOS EM X NO PODEM SER OBSERVADOS, SO EXECUTADOS INTERNAMENTE, DE FORMA AUTOMTICA, SO ESCONDIDOS. - NO INTERESSANTE QUE EVENTOS INTERNOS APAREAM NA INTERFACE DO SISTEMA - ENCAPSULAMENTO DO EVENTO DENTRO DO PROCESSO

- O processo P \ A faz as mesmas transies de P, mas todos os eventos em A so renomeados para - Terminao no pode ser escondida, ento o evento no deve aparecer no conjunto A. - Fonte mais comum de no-determinismo LEIS ALGBRICAS 1. 2. 3. 4. 5. (P |~| Q) \X = (P\X) |~| (Q\X) (P\Y)\X = P\(X U Y) (P\Y)\X = (P\X)\Y P\{} = P (a -> P)\X = P\X (se a X) = a->(P\X) (se a NO X)

PROCESSOS COM E SEM VISIBILIDADE (c?x:A -> P)\X = if XA={} then

RESTRIO DE

c?x:A -> (P\X) else ( (c?x:(A\X) -> (P\X)) [] (|~| {P(a)\X |a XA})) |~| (|~| {P(a)\X |a XA}) DIVERGNCIA - Processo realiza sequncia infinita de eventos - Operador de hiding pode introduzir divergncia ou livelock Nesse caso, ficamos com P =P e Q = Q, o que caracteriza divergncia.

Especificao de Sistemas Distribudos

COMPOSIO SEQUENCIAL P;Q - P executa at todos os seus eventos finalizarem, aps isso, Q executa - Passa-se o controle de um processo para outro - terminao o processo SKIP SKIP = , mas As afirmaes (1), (2) e (3) no fazem sentido, pois PQ s termina quando P e Q terminarem, sincronizando no evento (_tick) LEIS

COMPOSIO SEQUENCIAL E ESTADO Somente vlida se no houver ocorrncias livres de x em: Q (?x:A -> P);Q = ?x:A -> (P;Q) Pois: (1) (?x:A -> SKIP); (x -> Q) x pertence ao escopo do primeiro processo (2) ?x:A -> (SKIP; x -> Q) x pertence ao escopo do segundo processo - Exemplo (contador):

ITERAO (P*) - Repetio infinita de um trecho de cdigo, pois novos traces podem ser gerados - P*=P;P* - Exemplos: (a -> SKIP)* = p.a -> p COPY = (left?x right!x SKIP )* - Representar um for:

P [] SKIP, tal processo pode terminar a qualquer momento, mas tambm pode: P [] SKIP = (P [] SKIP) |~| SKIP MODELO SEMNTICOS

- Problema da continuidade de espao TRACES - Conjunto de sequncia de eventos possveis que uma especificao pode usar - No define o que no pode executar - Verificar at que ponto um padro comportamental atendido. - No verifica determinismo DEFINIO DE TRACES (1) traces(STOP) = { < > }

TERMINAO DISTRIBUDA Relao entre composio paralela de dois processos que podem terminar com sucesso

Especificao de Sistemas Distribudos

(2) traces (c?x:A -> P) = {<>} {<c.a>^s | aA, s traces(P[a/x])} (3) traces(a -> P) = { < > } U { < a > ^ s | s E traces(P) (4) traces( P |~| Q) = traces(P) U traces(Q) (5) traces( P [] Q) = traces(P) U traces(Q)
(6) traces(X.F(X)) = traces(STOP) traces(F(STOP)) ... FALHAS - Indica o que o processo pode fazer e onde falham - determinstico ou no - eventos que ele pode recusar num ponto de execuo

Para qualquer processo P, - div [FD= P

- Normalmente, temos a opo de um conjunto vazio inicialmente na escolha interna:

RENOMEAO

DIVERGNCIAS - Permite identificar as divergncias de um processo - Realizando eventos invisveis ao ambiente, sempre recusa quaisquer eventos - Traces (s) nos quais P pode divergir e as suas extenses (s^t) - div a representao cannica de um processo divergente

- Processo determinstico em termos de falhas e divergncias

Especificao de Sistemas Distribudos