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

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

Álgebras de Processo (FSP e CSP)

Apresentações semelhantes


Apresentação em tema: "Álgebras de Processo (FSP e CSP)"— Transcrição da apresentação:

1 Álgebras de Processo (FSP e CSP)
Joabe Jesus

2 Conceitos Fundamentais
Programa concorrente 2 ou mais fluxos (processos) executam simultaneamente para realizar uma tarefa Processo É um programa seqüencial (lista de comandos executados em sequencia)

3 Programas Concorrentes
Processos comunicam-se através de Variáveis compartilhadas Passagem de mensagens E sincronizam por Exclusão mútua Seções críticas não devem executar ao mesmo tempo Sincronização condicional Retarda um processo até uma dada condição ser satisfeita

4 concurrent processes We structure complex systems as sets of simpler activities, each represented as a sequential process. Processes can overlap or be concurrent, so as to reflect the concurrency inherent in the physical world, or to offload time-consuming tasks, or to manage communications or other devices. Designing concurrent software can be complex and error prone. A rigorous engineering approach is essential. Concept of a process as a sequence of actions. Model processes as finite state machines. Program processes as threads in Java.

5 processes and threads Concepts: processes - units of sequential execution. Models: finite state processes (FSP) to model processes as sequences of actions. labelled transition systems (LTS) to analyse, display and animate behavior. Practice: Java threads

6 Modeling Processes Models are described using state machines, known as Labelled Transition Systems LTS. These are described textually as finite state processes (FSP) and displayed and analysed by the LTSA analysis tool LTS - graphical form FSP - algebraic form CSP - algebraic form

7 Álgebra de Processos FSP

8 modeling processes A process is the execution of a sequential program. It is modeled as a finite state machine which transits from state to state by executing a sequence of atomic actions. a light switch LTS a sequence of actions or trace onoffonoffonoff ………. Can finite state models produce infinite traces?

9 FSP - action prefix If x is an action and P a process then (x-> P) describes a process that initially engages in the action x and then behaves exactly as described by P. ONESHOT = (once -> STOP). ONESHOT state machine (terminating process) Convention: actions begin with lowercase letters PROCESSES begin with uppercase letters

10 FSP - action prefix & recursion
Repetitive behaviour uses recursion: SWITCH = OFF, OFF = (on -> ON), ON = (off-> OFF). Substituting to get a more succinct definition: SWITCH = OFF, OFF = (on ->(off->OFF)). And again: SWITCH = (on->off->SWITCH).

11 animation using LTSA The LTSA animator can be used to produce a trace.
Ticked actions are eligible for selection. In the LTS, the last action is highlighted in red.

12 redorangegreenorangeredorangegreen …
FSP - action prefix FSP model of a traffic light : TRAFFICLIGHT = (red->orange->green->orange -> TRAFFICLIGHT). LTS generated using LTSA: Trace: redorangegreenorangeredorangegreen …

13 Referências FSP LTSA - http://www.doc.ic.ac.uk/ltsa/
LTSA - Applet Eclipse Plugin - Instalação - SceneBeans

14 Álgebra de Processos CSP

15 CSP Notação para modelar sistemas concorrentes Alto nível de abstração
Comunicação via passagem de mensagens Vários operadores para compor processos Ferramentas para analisar propriedades automaticamente Ex: FDR, PAT Possui bibliotecas para Java Ex: JCSP

16 CSP A simple programming language designed for multiprocessor machines
Its key feature is its reliance on non-buffered message passing with explicit naming of source and destination processes CSP uses guarded commands to let processes wait for messages coming from different sources

17 The Model Each process runs on its own processor
All communications between concurrent processes are made through message passing. CSP relies on the most primitive message passing mechanism: Non-buffered sends and receives Explicit naming of source and destination processes

18 ProBE (Animador de CSP)

19 FDR (Analisador de CSP)

20 JCSP Biblioteca para Java que suporta (subconjunto) de CSP
Programação concorrente com passagem de mensagens Possível usar memória compartilhada (mas desaconselhável)

21 Notação CSP

22 Escolhas Em CSP temos vários tipos de operadores de escolha
P [] Q (Escolha determinística) P |~| Q (Escolha não-determinística) if b then P else Q (Escolha condicional) b & P (guarda)

23 Estado de um processo Na prática, dificilmente um processo não precisará da noção de estado Por exemplo: controlar a evolução do conteúdo de uma fila, pilha, etc. Em CSP, estado pode ser capturado através de parâmetros em processos P(S) = …

24 Estado de um processo Um processo com parâmetros é semelhante a uma classe Para usar é preciso “criar uma instância” Ou seja, atribuir valores iniciais aos parâmetros P(0) ou Q(true)

25 Tipos usados em estados
CSP dispõe de alguns tipos simples: Básicos: inteiros (Int) e booleanos (Bool) Tuplas: (x, y, z) Conjuntos: { 1, 2, 3 } ou { x | x <- T } Seqüências:  1, 2, 3  ou  x | x <- T  Enumerações: datatype T = A | B Abreviação: nametype Nat = { x | x <- Int, x >= 0}

26 Operações sobre tipos Cada tipo tem operações disponíveis
first(x, y) = x head( 1, 2, 3 ) = 1 tail( 1, 2, 3 ) =  2, 3  union({0, 1}, {3}) = {0, 1, 3} member(0, {0, 1}) = true Etc.

27 Funções As vezes é necessário definir funções para manipular estruturas específicas Por exemplo first3(x, y, z) = x midd3(x, y, z) = y Mas antes de criar uma função é sempre bom ver disponibilidade… Note o uso de casamento De padrões

28 if b then P else Q Escolha condicional
Sejam P e Q dois processos e b uma expressão booleana. Então if b then P else Q

29 LTS de escolha condicional
Seja S = if b then P else Q, então P b S  b Q

30 Escolha condicional: Buffer
channel in, out: {0, 1} Buffer(s) = if s ==   then in?x -> Buffer(s^  x ) else ( in?x -> Buffer(s^  x ) [] out!head(s) -> Buffer(tail(s)) )

31 Casamento de padrões Como CSP é equipada com uma linguagem funcional, também há suporte a casamento de padrões em processos Buffer( ) seria equivalente a Buffer(s) = if s ==   then …

32 Casamento de padrões: Buffer
channel in, out: {0, 1} Buffer( ) = in?x -> Buffer(s^  x ) Buffer( h ^t) = ( in?x -> Buffer(s^  x ) [] out!h -> Buffer(t) )

33 Guarda O processo guardado É equivalente a escolha condicional b & P
if b then P else STOP

34 LTS de guarda Seja S = b & P, então P b S  b

35 Guarda: Buffer channel in, out: {0, 1}
Buffer(s) = (s ==  ) & in?x -> Buffer(s^  x ) [] (s !=  ) & ( in?x -> Buffer(s^  x ) [] out!head(s) -> Buffer(tail(s)) )

36 Exercício Modele o atendimento de uma fila de um caixa de banco
A fila pode aumentar se chegar cliente Pode diminuir se cliente for atendido Cliente pode sacar ou depositar qq valor A fila do caixa deve iniciar sem qq cliente (vazia)

37 Introduzindo concorrência

38 Paralelismo Representam a execução paralela de dois ou mais processos:
fluxos de controles independentes interações eventuais Utilizados para conectar os componentes de um sistema distribuído: sistemas distribuídos a partir de componentes seqüenciais sistemas distribuídos a partir de componentes paralelos

39 Operadores de Paralelismo
Concorrência pode ser expressa em CSP através de: Composição paralela alfabetizada P [ X || Y ] Q Composição paralela generalizada P [| X |] Q Entrelaçamento P ||| Q

40 Entrelaçamento Sejam P e Q processos CSP então P ||| Q
P e Q são executados em paralelo sem sincronização (independentes) Útil para especificar arquiteturas cliente-servidor Vários clientes e/ou servidores

41 Entrelaçamento P ||| Q Oferece os eventos iniciais tanto de P quanto de Q, e espera até que haja uma comunicação Após a comunicação de um evento a de P (Q), comporta-se como P’ ||| Q (P ||| Q’) Na presença de mesmo evento, P ||| Q evolução em P ou Q é não-determinística

42 Processos Paralelos e Seqüenciais
Sejam P = c?x:A -> P’ e Q = c?x:B -> Q’. Então: P ||| Q = c?x: A  B -> if (x A  B) then (P’ ||| Q) |~| (P ||| Q’) else if (x  A) then (P’ ||| Q) else (P ||| Q’)

43 Lei Interessante Seja P um processo CSP. Então P ||| STOP = P
Esta lei decorre imediatamente do slide anterior (step-law) if (x  A) then (P’ ||| Q) Onde Q é o processo STOP Este fato nos permite modelar tolerância a falhas

44 Cuidado Sejam P e Q processos CSP recursivos. O processo P = P ||| Q
O mesmo ocorre também com escolha externa Sejam P e Q processos CSP recursivos. O processo P = P ||| Q É infinito estruturalmente e FDR não consegue lidar com o mesmo Já P = P’ ||| Q pode ser trabalhado sem problemas

45 Exercício Adapte o modelo de caixas anterior para considerar 2 caixas

46 Composição Paralela Generalizada
Sejam P e Q processos CSP então P [| X |] Q P e Q são executados em paralelo mas sincronizando nos eventos em X: Nos outros eventos semelhante ao operador de entrelaçamento (independente)

47 Composição Paralela Generalizada
Generaliza outros operadores: P ||| Q = P [| {} |] Q P [ X || Y ] Q = (P [| Events \ X |] STOP) [| X  Y |] (Q [| Events \ Y |] STOP) Não pode ser expresso através dos outros operadores

48 Composição Paralela Generalizada
P [| X |] Q Com A e B sendo respectivamente os eventos iniciais de P e Q, tem-se o seguinte conjunto de eventos: C =(A \ X) U (B \ X) U (A  B  X)

49 Processos Paralelos e Sequenciais
Sejam P = c?x:A -> P’ e Q = c?x:B -> Q’. Então P [| X |] Q = c?x:C -> if (xX) then P’ [|X|] Q’ else if (xAB) then (P’ [|X|] Q) |~| (P [|X|] Q’) else if (xA) then (P’ [|X|] Q) else (P [|X|] Q’)

50 Deadlock P = (a -> b -> P) [] (b -> a -> P) Q = (a -> c -> Q) [] (c -> a -> Q) P [|Events|] Q = a -> STOP

51 Exercício Adapte o exercício de caixas anterior para que um cliente possa trocar de fila

52 Restringindo Concorrência
Os operadores de composição paralela podem ser usados para restringir o comportamento dos processos: P [|X|] STOP comporta-se como P exceto pela proibição da realização dos eventos em X P [|X|] Q, onde Q só realiza os eventos em X, restringe o comportamento de P

53 Associatividade Sejam P, Q e R processos CSP, X e Y conjuntos de sincronização. Então (P [|X|] Q) [|Y|] R  P [|X|] (Q [|Y|] R) Só quando X = Y esta associatividade é válida (P [|X|] Q) [|X|] R = P [|X|] (Q [|X|] R)

54 Multiway rendezvous Ocorre quando mais de dois processos participam de interação em comum Do ponto de vista de análise pode ser usado sem problemas No nível de projeto deve ser evitado ou reescrito O modelo CSP que será usado para mapear em JCSP não deve usar JCSP não suporta

55 Operadores Indexados Para P [ X || Y ] Q temos Para P ||| Q temos
|| [A(i)] P(i) Para P ||| Q temos ||| P(i) Para P [|X|] Q temos [|X|] P(i)

56 Cliente-Servidor Indexados
Sejam Ci e Sj processos CSP e X um conjunto de sincronização entre Ci e Sj. Então uma arquitetura cliente-servidor pode ser vista genericamente como (|||i=1..N Ci) [|X|] (|||j=1..K Sj)

57 Referências Roscoe, A.W. The Theory and Practice of Concurrency. Prentice-Hall, 1998. Hoare, C.A.R. Communicating Sequential Processes. Prentice-Hall, 1985.

58 Referências CSP FDR – Failures Divergences Refinement
Courses FDR – Failures Divergences Refinement


Carregar ppt "Álgebras de Processo (FSP e CSP)"

Apresentações semelhantes


Anúncios Google