Innate immune response

Em verifica¸c˜ao formal, procura-se garantir que as propriedades s˜ao satisfeitas em todas as situa¸c˜oes poss´ıveis do sistema e, por isso, costuma-se utilizar um modelo de entradas que gere qualquer valor a qualquer momento. Esse tipo de modelo de entradas muitas vezes pode levar a um espa¸co de estados muito grande para o sistema, fazendo com que as ferramentas computacionais n˜ao sejam capazes de processar, levando a situa¸c˜ao conhecida de explos˜ao de estados.

Para evitar a explos˜ao de estados, ´e comum em model checking construir modelos de gera¸c˜ao de est´ımulos de entrada que sejam mais restritos, por´em sem prejudicar a verifica¸c˜ao das propriedades. As res- tri¸c˜oes aplicadas costumam eliminar comportamentos de entrada im- poss´ıveis para o sistema, ou ent˜ao manter apenas os est´ımulos que s˜ao relevantes para a propriedade que est´a sendo verificada.

No Cap´ıtulo 4 foram apresentadas as regras de tradu¸c˜ao VHDL- FIACRE, sendo que o modelo FIACRE gerado ´e formado por dois pro- cessos: um para execu¸c˜ao do c´odigo (delta cycle) e outro para gera¸c˜ao das entradas (input generator). A constru¸c˜ao do input generator para gerar qualquer valor ´e bastante simples e autom´atica conforme descrito no Cap´ıtulo anterior, por´em ´e desej´avel que seja poss´ıvel gerar automaticamente um modelo com restri¸c˜oes para as entradas e evitar a explos˜ao de estados.

O objetivo espec´ıfico da metodologia ´e manter as interfaces com o processo de verifica¸c˜ao em linguagem de usu´ario, logo, exigir que o usu´ario descreva o modelo de entradas em FIACRE est´a descartado. Uma solu¸c˜ao poss´ıvel seria permitir que o usu´ario descreva o comporta- mento desejado por meio de m´aquinas de estado ou at´e mesmo c´odigo VHDL. Por´em, a tradu¸c˜ao seria bastante complicada e a possibilidade de usu´ario cometer erros na defini¸c˜ao das restri¸c˜oes se tornaria muito grande.

A solu¸c˜ao proposta ´e utilizar a mesma ideia da defini¸c˜ao de pro- priedades para verifica¸c˜ao, ao usar padr˜oes de restri¸c˜ao de entradas derivados da biblioteca OVL. A biblioteca OVL j´a prevˆe o uso dos ob- servadores para defini¸c˜ao de est´ımulos v´alidos atrav´es da configura¸c˜ao do parˆametro property type como assume. Na metodologia s˜ao tra- duzidos alguns observadores OVL para serem usados tamb´em como assume, definindo restri¸c˜oes para as entradas que ser˜ao traduzidas au- tomaticamente para um processo input generator adequado.

O uso de observadores OVL leva a algumas limita¸c˜oes no formato do input generator e, por isso, na metodologia s˜ao propostos dois tipos de processo (n˜ao usados em conjunto): um para gerar valores sem OVL (Cap´ıtulo 4) e outro com restri¸c˜oes OVL.

5.4.1 Estrutura do input generator

Quando o desenvolvedor deseja criar um modelo de entradas com restri¸c˜oes geradas por propriedades OVL configuradas como assume, o processo input generator deve ter o formato mostrado no C´odigo 5.2 (considerando que o c´odigo VHDL de origem possui “n” entradas). Os observadores OVL, em sua grande maioria, descrevem propriedades so- bre sinais que evoluem em rela¸c˜ao a um sinal de clock e, por isso, o modelo input generator gerado quando se usa o OVL necessita que seja definido uma das entradas para realizar esse papel. Outra restri¸c˜ao considerada ´e que o circuito ´e s´ıncrono, sendo que as entradas possuem seus valores alterados na borda de subida do clock. No exemplo mos- trado ´e considerado a entrada “input1” como sinal de clock.

1 p r o c e s s i n p u t g e n e r a t o r [ g e n e r a t e d i n p u t s : o u t i n p u t l i s t ] (& o u t p u t l i s t : r e a d o u t p u t l i s t ) i s s t a t e s c l k f a l s e , c l k t r u e v a r i n p u t 1 : b o o l := f a l s e , 5 . . . i n p u t n : f i a c r e t y p e := i n i t v a l u e , // ////// // o v l r e s t r i c t i o n s a u x i l i a r y v a r i a b l e s . . .

10 // ///// i n i t t o c l k f a l s e from c l k f a l s e i n p u t 1 := f a l s e ; g e n e r a t e d i n p u t s ! i n p u t 1 , . . . , i n p u t n ; 15 t o c l k t r u e from c l k t r u e i n p u t 1 := t r u e ; // o v l r e s t r i c t i o n s a u x i l i a r y code . . . 20 // //////////////////////////// i n p u t 2 , . . . , i n p u t n := any where o v l r e s t r i c t i o n 1 and o v l r e s t r i c t i o n 2 . . . 25 and o v l r e s t r i c t i o n n ; g e n e r a t e d i n p u t s ! i n p u t 1 , . . . , i n p u t n ; t o c l k f a l s e

C´odigo 5.2 – Estrutura do input generator com restri¸c˜oes OVL O modelo do input generator ´e um processo com dois estados que ficam se alternando: clk false e clk true. No estado clk false a entrada de clock deve ser falsa, enquanto que no outro estado deve ser verdadeira. O fato do sinal de clock estar sempre alternando seu valor, al´em de reduzir o espa¸co de estados, simplifica a defini¸c˜ao de proprie- dades pois as mesmas n˜ao precisam levar em considera¸c˜ao caminhos de execu¸c˜ao em que o clock n˜ao mude seu valor.

As linhas 4-6 do C´odigo 5.2 contˆem a declara¸c˜ao de n vari´aveis FIACRE, uma para cada entrada declarada no bloco Entity do c´odigo VHDL a ser verificado. As vari´aveis devem ter o tipo FIACRE corres- pondente ao tipo VHDL da entrada que est´a representando, e mesmo nome. As linhas 7-10 representam a declara¸c˜ao de vari´aveis auxiliares usadas para a tradu¸c˜ao das propriedades OVL utilizadas para restringir as entradas. Cada propriedade OVL precisa de um conjunto espec´ıfico de vari´aveis auxiliares que ser˜ao detalhadas nas pr´oximas se¸c˜oes. As li- nhas 12-15 formam o estado clk false, que cont´em apenas a associa¸c˜ao de valor falso para o clock e a sincroniza¸c˜ao para passagem de valores para o processo delta cycle.

O estado clk true (linhas 16-28) ´e onde o valor das entradas que n˜ao s˜ao clock possuem seus valores alterados. Al´em das vari´aveis au- xiliares, algumas propriedades OVL necessitam de um c´odigo adicional que ´e representado nas linhas 18-20 (mais detalhes quando for apresen- tado a tradu¸c˜ao do OVL). Esse c´odigo adicional sempre ´e posicionado antes da express˜ao “any” que atribui qualquer valor para as entradas (linha 21). A diferen¸ca fundamental da express˜ao “any” nesse caso, ´e a presen¸ca da express˜ao “where” que define condi¸c˜oes as quais os

valores gerados devem satisfazer para que sejam considerados v´alidos. Na express˜ao “where” se encontra todas as restri¸c˜oes provenientes das propriedades OVL utilizadas como assume. Ap´os a gera¸c˜ao de valores para as entradas, elas s˜ao repassadas para o delta cycle e o processo retorna ao estado clk true.

As restri¸c˜oes de valores constantes para uma determinada en- trada ou intervalo de valores tamb´em s˜ao poss´ıveis nesse tipo de mo- delo de entrada, sendo realizadas da mesma maneira que no modelo sem OVL.

A seguir s˜ao apresentados os princ´ıpios de tradu¸c˜ao dos observa- dores ovl always, ovl window e ovl next. Os outros observadores traduzidos est˜ao dispon´ıveis no Apˆendice B.

5.4.2 ovl always

Quando esse observador OVL ´e utilizado como restri¸c˜ao para entradas, o processo input generator tem o seguinte formato:

1 p r o c e s s i n p u t g e n e r a t o r [ g e n e r a t e d i n p u t s : o u t i n p u t l i s t ] (& o u t p u t l i s t : r e a d o u t p u t l i s t ) i s s t a t e s c l k f a l s e , c l k t r u e // v a r i a b l e s d e c l a r a t i o n 5 . . . i n i t t o c l k f a l s e from c l k f a l s e c l o c k := f a l s e // c l k f a l s e code 10 from c l k t r u e c l o c k := t r u e ; i n p u t 2 , . . . , i n p u t n := any where t e s t e x p r ; g e n e r a t e d i n p u t s ! i n p u t 1 , . . . , i n p u t n ; t o c l k f a l s e

Somente a express˜ao test expr ´e adicionada a cl´ausula where.

5.4.3 ovl window

Quando esse observador OVL ´e utilizado como restri¸c˜ao para entradas, o processo input generator tem o seguinte formato:

1 p r o c e s s i n p u t g e n e r a t o r [ g e n e r a t e d i n p u t s : o u t i n p u t l i s t ] (& o u t p u t l i s t : r e a d o u t p u t l i s t ) i s s t a t e s c l k f a l s e , c l k t r u e // v a r i a b l e s d e c l a r a t i o n 5 v a r o v l w i n d o w o p e n : b o o l := f a l s e , p r e o v l w i n d o w : b o o l := f a l s e , . . . i n i t t o c l k f a l s e

from c l k f a l s e 10 c l o c k := f a l s e // c l k f a l s e code from c l k t r u e c l o c k := t r u e ; // o v l w i n d o w code 15 i f e n d e v e n t t h e n o v l w i n d o w o p e n := f a l s e e l s e i f ( n o t p r e o v l w i n d o w ) and s t a r t e v e n t t h e n o v l w i n d o w o p e n := t r u e 20 end i f end i f ; p r e o v l w i n d o w := s t a r t e v e n t ; // /////////////////////// i n p u t 2 , . . . , i n p u t n := any where 25 ( n o t o v l w i n d o w o p e n ) o r ( o v l w i n d o w o p e n and t e s t e x p r ) ; g e n e r a t e d i n p u t s ! i n p u t 1 , . . . , i n p u t n ; t o c l k f a l s e

Para utilizar o ovl window como assume, al´em da adi¸c˜ao da express˜ao mostrada nas linhas 25-27 `a cl´ausula where, ´e necess´ario o c´odigo auxiliar mostrado nas linhas 15-22. Duas vari´aveis extras s˜ao criadas para auxiliar no processamento do observador, destacadas nas linhas 5-6.

5.4.4 ovl next

Quando esse observador OVL ´e utilizado como restri¸c˜ao para entradas, o processo input generator tem o seguinte formato:

1 p r o c e s s i n p u t g e n e r a t o r [ g e n e r a t e d i n p u t s : o u t i n p u t l i s t ] (& o u t p u t l i s t : r e a d o u t p u t l i s t ) i s s t a t e s c l k f a l s e , c l k t r u e // v a r i a b l e s d e c l a r a t i o n 5 v a r o v l n e x t f i f o : q u e u e 1 o f n a t := { | | } , o v l n e x t c n t : n a t := 0 , . . . i n i t t o c l k f a l s e from c l k f a l s e 10 c l o c k := f a l s e // c l k f a l s e code from c l k t r u e c l o c k := t r u e ; // o v l n e x t code 15 i f ( o v l n e x t c n t > 0 ) and ( s t a r t e v e n t = t r u e ) t h e n o v l n e x t f i f o := e n q u e u e ( o v l n e x t f i f o , o v l n e x t c n t ) end i f ; i f ( o v l n e x t c n t = num cks ) t h e n i f empty ( o v l n e x t f i f o ) t h e n 20 o v l n e x t c n t := 0 e l s e o v l n e x t c n t := o v l n e x t c n t − f i r s t ( o v l n e x t f i f o ) + 1 ; o v l n e x t f i f o := d e q u e u e ( o v l n e x t f i f o )

end i f 25 e l s e i f o v l n e x t c n t > 0 t h e n o v l n e x t c n t := o v l n e x t c n t + 1 e l s e i f s t a r t e v e n t = t r u e t h e n 30 o v l n e x t c n t := 1 end i f end i f end i f ; // /////////////////////// 35 i n p u t 2 , . . . , i n p u t n := any where ( t e s t e x p r and ( o v l n e x t c n t = num cks ) ) o r ( o v l n e x t c n t <> num cks ) ; g e n e r a t e d i n p u t s ! i n p u t 1 , . . . , i n p u t n ; t o c l k f a l s e

Para utilizar o ovl next como assume, al´em da adi¸c˜ao da ex- press˜ao mostrada nas linhas 36-37 a cl´ausula where, ´e necess´ario o c´odigo auxiliar mostrado nas linhas 15-33. Se a op¸c˜ao check mis- sing start for usada, a express˜ao ¬(test expr ∧ (ovl next cnt = 0)) deve ser adicionada ao where. Quando o parˆametro check overlap- ping for 0, a express˜ao ¬(start event ∧ (ovl next cnt > 0)) deve ser adicionada ao where.