3.1 CAPTURANDO A SEMÂNTICA DE CIRCUS EM K
3.1.2 Canais
3.1.4.4 Escolha Externa
Assim como especificado na Subseção2.4.5.6, dividimos as regras que determinam o comportamento do operador de escolha externa em três grupos. O progresso deste operador é iniciado quando a primeira regra é disparada modificando o operador r s para r`s e fazendo uma cópia do estados S para as ações envolvidas na escolha além de gerar uma transição por meio de um evento invisível.
rule [ extenal ´choice ´begin ] :
<k>
evaluate (A1 : Action [ ] A2 : Action , S) =>
t r a n s i t i o n ( (A1 [ ] A2 , S) , Tau , ( (A1 , S1 ) [+] (A2 , S2 ) , S) ) . . . </k>
No decorre do progresso, ambas os lados (A1 e A2) podem evoluir para um novo estado gerando arcos rotulados com (τ ) sem que a escolha seja resolvida. A definição deste comportamento pode ser visualizado no par de regras abaixo. Nota-se que ambas consultam o conjunto de transições ( célula <transitions>) para resgatar a evolução de A1 ou A2 para A3.
rule [ extenal ´choice ´s i l e n t ´l e f t ] :
<k> evaluate ( (A1 : Action , S1 ) [+] (A2 : Action , S2 ) , S)
=> t r a n s i t i o n ( (A1 , S1 ) [+] (A2 , S2 ) , S) , Tau , ( (A3 , S3 ) [+] (A2 , S2 ) , S) ) . . .
</k> <process >
. . .
<t r a n s i t i o n s >
T:Set SetItem ( (A1 , S1 ) , Tau , (A3 : Action , S3 ) )
</ t r a n s i t i o n s > . . .
</process >
rule [ extenal ´choice ´s i l e n t ´r i g h t ] :
<k> evaluate ( (A1 : Action , S1 ) [+] (A2 : Action , S2 ) , S)
=> t r a n s i t i o n ( (A1 , S1 ) [+] (A2 , S2 ) , S) , Tau , ( (A1 , S1 ) [+] (A3 , S3 ) , S) ) . . .
</k> <process >
. . .
<t r a n s i t i o n s >
T:Set SetItem ( (A2 , S2 ) , Tau , (A3 : Action , S3 ) )
</ t r a n s i t i o n s > . . .
</process >
Este operador tem sua escolha resolvida quando um dos lados evoluiu para Skip via uma transição τ ou quando acontece uma comunicação visível, que neste caso, leva a mudança de estado. Um ponto a ser mencionado nas regras abaixo é o atributo when, pois ele garante que estas regras só serão disparadas se um dos lados evoluiu por um evento visível, ou seja, Event ‰ τ .
rule [ e x t e n a l c h o i c e ´skip´l e f t ] :
<k>
evaluate ( ( Skip , S1 ) [+] (A: Action , S2 ) , S) =>
t r a n s i t i o n ( ( ( Skip , S1 ) [+] (A, S2 ) , S) , Tau , ( Skip , S1 ) ) . . . </k>
rule [ e x t e n a l c h o i c e ´skip´r i g h t ] :
<k>
evaluate ( (A: Action , S1 ) [+] ( Skip , S2 ) , S) =>
t r a n s i t i o n ( ( (A, S1 ) [+] ( Skip , S2 ) , S) , Tau , ( Skip , S2 ) ) . . . </k>
rule [ extenal ´choice ´end´l e f t ] :
<k> evaluate ( (A1 : Action , S1 :Int) [+] (A2 : Action , S2 :Int) , S) =>
t r a n s i t i o n ( ( ( A1 , L1 ) [+] (A2 , L2 ) , S) , Event , (A3 , S3 ) ) . . . </k>
<process > . . .
<t r a n s i t i o n s >
T:Set SetItem ( (A1 , S1 ) , Event :K, (A3 : Action , S3 :Map) )
</ t r a n s i t i o n s > . . .
</process > when Event =/=K Tau
rule [ extenal ´choice ´end´r i g h t ] :
<k> evaluate ( (A1 : Action , S1 :Int) [+] (A2 : Action , S2 :Int) )
=> t r a n s i t i o n ( ( ( A1 , S1 ) [+] (A2 , S2 ) , S) , Event , (A3 , S3 ) ) . . . </k>
<process > . . .
<t r a n s i t i o n s >
T:Set SetItem ( (A2 , S2 ) , Event :K, (A3 : Action , S2 ) )
</ t r a n s i t i o n s > . . .
</process > when ( Event =/=K Tau)
3.1.4.5 Composição Sequencial
Corroborando com o conteúdo discutido na Subseção 2.4.5.3, o comportamento da composição sequencial foi capturado em duas situações específicas do operador. A primeira tem relação com o progresso pA1; BqÝÑ pAl 2; Bq, onde a condição para tal evolução é a existência de uma transição A1
l Ý
Ñ A2. Este requisito é verificado na célula <transitions> que buscará um item no conjunto de transições que contemple a tupla ppA1, S1q, l, pA2, S2qq.
rule [ sequence´p r o g r e s s ] :
<k>
evaluate ( (A1 : Action ; B: Action ) , S1 ) =>
t r a n s i t i o n ( (A1 ; B, S1 ) , Event , (A2 ; B, S2 ) ) . . . </k>
<process > . . .
<t r a n s i t i o n s >
T:Set SetItem ( (A1 , S1 ) , Event :K, (A2 : Action , S2 ) ) => T
</ t r a n s i t i o n s > . . .
</process >
A segunda situação, determina o término da sequencia através de uma transição silenciosa pÝÑq. A regra para esta transição indica que o lado esquerdo da sequencia foiτ
finalizada e é aplicada sempre que a ação Skip é encontrada. Isto permite que a composição evolua para a próxima ação em sequencia.
rule [ sequence´end ] :
evaluate ( ( Skip ; A: Action ) , S) =>
t r a n s i t i o n ( ( Skip ; A, S) , Tau , (A, S) ) 3.1.4.6 Paralelismo
A representação do comportamento paralelo na ferramenta objeto de estudo deste trabalho, foi capturado com a especificação de cinco regra de disparo. A primeira regra (Parallel Begin) evolui através de um evento invisível criando uma cópia local do estado
atual para ambos os lados paralelos. rule [ p a r a l l e l ´begin ] :
evaluate (A1 : Action [ | { Sync : IDs } | ] A2 : Action , S)
=> t r a n s i t i o n ( (A1 [ | { Sync } | ] A2 , S) , Tau , (A1 , S) [ | { Sync } | ] (A2 , S) ) As regras Parallel Independent Left e Parallel Independent Right são aplicadas sempre que pelo menos um dos lados do paralelismo tenha evoluído através de um evento τ ou por um evento visível que não pertença ao conjunto de sincronização (Sync). Esta restrição é estabelecida em K pela expressão: pnotBool E belongsTo Syncq orBool pE ==K
T auq.
rule [ p a r a l l e l ´independent´l e f t ] :
<k> evaluate ( (A1 : Action , S1 ) [ | { Sync : IDs } | ] (A2 : Action , S2 ) )
=> t r a n s i t i o n ( (A1 , S1 ) [ | { Sync } | ] (A2 , S2 ) ,E, (A3 , S3 ) [ | { Sync } | ] (A2 , S2 ) ) </k>
<process > . . .
<t r a n s i t i o n s > . . .
SetItem ( (A1 , S1 ) , E:K, (A3 : Action , S3 ) )
. . .
</ t r a n s i t i o n s > . . .
</process >
when (notBool E belongsTo Sync ) orBool (E ==K Tau)
rule [ p a r a l l e l ´independent´r i g h t ] :
<k> evaluate ( (A1 : Action , S1 ) [ | { Sync : IDs } | ] (A2 : Action , S2 ) )
=> t r a n s i t i o n ( (A1 , S1 ) [ | { Sync } | ] (A2 , S2 ) ,E, (A1 , S1 ) [ | { Sync } | ] (A2 , S3 ) ) </k>
<process > . . .
<t r a n s i t i o n s > . . .
. . .
</ t r a n s i t i o n s > . . .
</process >
when (notBool E belongsTo Sync ) orBool (E ==K Tau)
A sincronização acontece sempre por prefixação e tem como restrição que ambos os lados tenha evoluído por um mesmo evento e este evento esteja incluído no conjunto de sincronização (Sync). Caso esta regra seja disparada, acontecerá uma transição através de um evento visível (E) e ambos os lados avançarão.
rule [ p a r a l l e l ´synchronised ] :
<k> evaluate ( (A1 : Action , S1 ) [ | { Sync : IDs } | ] (A2 : Action , S2 ) )
=> t r a n s i t i o n ( (A1 , S1 ) [ | { Sync } | ] (A2 , S2 ) , E, (A3 , S3 ) [ | { Sync } | ] (A4 , S4 ) ) </k> <process > . . . <t r a n s i t i o n s > . . .
SetItem ( (A1 , S1 ) , E:K, (A3 : Action , S3 ) )
SetItem ( (A2 , S2 ) , E:K, (A4 : Action , S4 ) )
. . .
</ t r a n s i t i o n s > . . .
</process >
when (E belongsTo Sync ) andBool (E =/=K Tau)
A última regra ocorre sempre que ambos os lados tenham terminado. O disparo desta regra gera uma transição silenciosa para o estado Skip e a fusão dos estados.
rule [ p a r a l l e l ´end ] :
evaluate ( ( Skip , S1 ) [ | { Sync : IDs } | ] ( Skip , S2 ) )
=> t r a n s i t i o n ( ( Skip , S1 ) [ | { Sync } | ] ( Skip , S2 ) , Tau , ( Skip , ( S1 , S2 ) ) ) 3.1.4.7 Recursão
Em termos de semântica operacional, uma chamada de ação é representada por uma transição que inicial por um identificador de uma ação que tem como alvo o seu próprio corpo. Em K, isto foi expresso da seguinte forma.
rule [ action ´c a l l ] :
<k>
evaluate ( I :Id, S) => t r a n s i t i o n ( ( I , S) , Tau , (A, S) ) . . .
</k> <process >
. . .
. . .
</process >
Uma vez que o identificador I é encontrado no conjunto de ações, o corpo pAq deste é recuperado e então o sistema cria uma nova transição ppI, Sq, τ, pA, Sqq através do evento invisível τ .
3.1.5
Transições
O construtor transition tem sempre como parâmetro uma tripla ppA, Sq, l, pA1, S1 qq, onde o par pA, Sq é composto de uma ação e o estado atual, l o rótulo da transição e por fim pA1, S1q com evolução da ação e do estado inicial. De forma prática esta função armazena esta tripla em um conjunto de transições para ser consultado por regras de disparo que necessitam destas informações. Além disto, a regra definida para esta função tem como saída uma nova computação que é adicionada topo da pilha de computações para ser avaliada.
rule [ t r a n s i t i o n s ] :
<k>
t r a n s i t i o n ( (A: Action , S1 ) , Event , (B: Action , S2 ) ) => evaluate (B, S2 ) . . .
</k> <process >
. . .
<t r a n s i t i o n s >
T:Set => T SetItem ( (A, S1 ) , Event :K, (B, S2 ) )
</ t r a n s i t i o n s > . . .
4 EXPERIMENTOS E RESULTADOS
Neste capítulo serão apresentados alguns exemplares clássicos, analisados por outras ferramentas e que serviram para experimentar o verificador de modelos fruto deste trabalho de dissertação bem como avaliá-lo em relação aos outros verificadores relacionados à CSP.