system verilog -notas

1. System Verilog

System Verilog é uma linguagem que foi baseada na linguagem de descrição de Hardware Verilog 95 e por esta razão engloba a maior parte dos aspectos de projeto do sistema e do testbench que Verilog oferece.

Entretanto System Verilog se propõe a oferecer mais possibilidades de forma a suportar que algumas funções avançadas de VHDL também sejam englobadas.

System Verilog

System Verilog

Edelweis Helena Garcez Ritt 2006

Além disto System Verilog se propõe a ser uma HDL e HVL ou seja, adequada para codificação (projeto) bem como verificação.. Isto demanda outras funcionalidades que ainda não eram disponíveis em Verilog ou VHDL, mas em E ou Open Vera. System Verilog foi muito influenciada por Open Vera e por isto se parece mais com esta HVL.

A linguagem completa:

2. Tipos

System Verilog Página 3

Edelweis Garcez Ritt

System Verilog dispõe dos seguintes tipos de dados:

Int e short int 2 estados (0 e 1)

integer 4 estados (0,1,Z e X)

long int 64 bits

int signed e unsigned

bit 2 estados

byte 8 bits signed

logic 4 estados

string

Enum

Declaração: <tipo> <objeto>;

Packed arrays é o que conhecemos em VHDL como bit_vector.

2.1. Enumeração

O tipo enumeração é semelhante ao C.

System Verilog


2.2. Arrays

System Verilog suporta Arrays, bem como as HDLs conhecidas. Existe o conecite de array packed e unpacked.

2.3. Arrays Dinâmicos

Os arrays dinâmicos também são possíveis em System Verilog, logicamente para a parte de verificação.

Exemplo de código:

int memoria[];

memoria=new[64];

memoria=new[128](memoria); //preserva o conteúdo do array de 64

int tamanho = size (memoria); //retorna o tamanho atual

memória.delete; // apaga o array dinâmico

Podemos indexar os arrays usando tipos diferentes

int vetor1[0];

int vetor2[“oi”];

2.4. Filas

System Verilog também oferece filas (queues) que aumentam e diminuem em tempo de execução e aceitam comandos de colocar na fila e tirar da fila.

Pode-se colocar elementos ou no começo ou no final e 0 indica o primeiro elemento, 1 o segundo e assim sucessivamente, enquanto que $ representa o último.

Um ponto importante é que a semântica exige um tempo de acesso constante.

Exemplos de filas com tamanho limitado ou ilimitado:

int canal[$]; //lista de inteiros

byte dados[$] = { 2h’00, 2h’FF}; //lista de bytes com inicialização

int fila_restrita[$:16]; //fila com no máximo 16 elementos

Exemplos de operações qe podem ser feitas com filas e já vem prontas em System Verilog:



int e, pos;

int canal2[$]; // outra fila sem limite

e=canal[0]; //pega o primeiro (mais a esquerda)elemento da fila

canal2=canal; // copia uma fila completa

canal[0]=e; // escreve na primeira posição da fila

canal=canal[1:$]; // copia a lista para ela mesma sem o primeiro elemento ou seja deleta o primeiro

canal2={e,canal}; //monta uma lista com o elemento e concatenado com a lista canal

canal={}; // esvazia a fila

canal = {canal{0:pos},e,canal{pos+1:$}}; // insere o elemento e na posição pos

Funções que existem para filas:

function int size(); //retorna o tamanho

function void delete(); // esvazia a fila

function void insert(); //coloca o elemento e na posição i, uso: <nome>.insert(I,e)

function queue_type pop_front(); //remove o primeiro elemento

function queue_type pop_back(); //remove o último elemento

function queue_type push_front(); //insere um primeiro elemento e, uso:<nome>.push_front(e)

function queue_type push_back(); //insere um último elemento e, uso:<nome>.push_back(e)

2.5. Interfaces

Uma interface agrupa e encapsula um conjunto de fios assim como uma struct faz isto com variáveis. Facilita o acesso e o uso.

As interfaces são instanciadas e nos poupam ficar definindo sinais que são saída em um módulo e entrada noutro.

System Verilog


Exemplo sem o uso de interfaces:

E exemplo usando interfaces:

2.6. Structs

Muito parecidas com structs de c ou c++.

typedef struct {

byte dado;

bit valid;

} estrutura;

2.7. Casting



Os tipos podem ser mudados usando um operador de casting, como em VHDL ou C.

Int’ (2.0 * 3.0) // transforma o resultado em int

2.8. Definição de tipos

Semelhante ao C

3. Escopo

System Verilog também permite declarar sinais e variáveis globais e locais

Int max = 10;

Int n;

module topo;

int n;

initial begin

automatic int i; // variável local como em C

n = 2;

end

initial begin: meu bloco

n=1

$root.n = n; // $root.n é a variável global e n é aqui a local

end

endmodule

4. Operadores

Entre os vários tipos existem operadores que podem ser usados:

& e ~& E e não-e

| e ~| Ou e não-ou

^ e ~^

== e !== Igualdade e desigualdade

System Verilog


>> e << shifts

4.1. Operador Overloading

System Verilog suporta overloading. Exemplo:

typedef struct {

int A;

real B

} estrutura_mista;

estrutura_mista X,Y,Z;

bind + function estrutura_mista fadds(estrutura_mista,estrutura_mista);

bind + function estrutura_mista faddi(estrutura_mista, integer);

assign X= Y + 2; // vai chamar a função faddi

assign Y += Z; // vai chamar a função fadds

Note que para cada ligação teria que definir a função. No exemplo faltou a definição usando estrutura_mista e real, por exemplo.

5. Literais

Literais funcionam de maneira semelhante a Verilog.

reg [31:0} a,b;

reg [15:0] c,d;

...

a = 32’hf0ab;

c = 16’hFFFF;

a = ‘0; // enche um array packed de 0s

Existem além destes literais de tempo

#10 a<= 1;

#5ns b <= !b;

6. Descrever hardware

Naturalmente como uma HDl system verilog deve permitir a escrita de um hardware. Isto é feito definindo-se módulos de hardware. Vejamos um exemplo:



module gera_clock (output tipo clk);

parameter logic valor_inicial=0;

parameter type tipo = bit;

parameter time atraso = 100;

initial clk<= valor_inicial;

always #atraso clk <= !clk;

endmodule

module topo;

logic clk;

gera_clock #(.valor_inicial(1’b1), .atraso(50), .tipo(int)) c clk; //instância do gerador de clock

always @clk $display (“Clock= %b”, clk);

initial

begin

repeat(10) @posedge(clk);

$finish(0);

end

endmodule

7. Descrever Verificação

Em System Verilog a DUT e o código do testbench são separados. Isto é oferecedio pela linguagem.

Em System Verilog toda a automatização que tinha que ser feita a mão usando as linguagens de verificação normais pode ser automatizada dentro da linguagem.

Exemplo:

virtual class EnvBaseClass;

virtual task pre_test();

virtual task start_test();

virtual task main_test();

virtual task stop_test();

virtual task post_test();

virtual task finish_test();

endclass

System Verilog


class EnvClass extends EnvBaseClass;

task main();

pre_test();

start_test();

endtask

task pre_test();

blabla //define o pre_teste como quiser preparando o que for preciso

andtask

//e aqui as outras tarefas que se precisar redefinir

endmodule

program Meu_estbench(interface dut_if);

EnvClass Meu_Ambiente = new;

initial

begin

fork

Meu_ambiente.main();

join_none

end

final

begin

Meu_ambiente.finish_test();

$finish;

end

endprogram

8. Classes

System Verilog oferece classes, uma vez que é uma linguagem orientada a objetos, portanto oferece encapsulamento, herança e polimorfismo.

System Verilog oferece Métodos (Method) da mesma forma que qualquer linguagem orientada a objetos faz, além de funções e tarefas (functions e tasks). A principal diferença entre funções e tarefas é que tarefas podem ser bloqueadas e funções não.

Além disto, temos handle e instâncias para os objetos. Note que system verilog não tem nenhum outro tipo de ponteiros como c ou c++.

Exemplo:

class pacote;

Blabla;

cnd class;



pacote pacote1; // ponteiro para um estrutura apontando para nada

pacote pacote2=new; // cria o ponteiro e já aloca uma área

A palavra this serve para identificar a versão local.

Class minha_classe;

Int a;

task propriedade(int a)

this.a=a; // para não ser ambiguo

end task

end class

Nestes casos o melhor é talvez usar nomes diferentes, mas isto faz parte do estilo.

8.1. Construtores

Assim como as linguagens orientadas a objetos system verilog tem construtores, alguns já embutidos como new ou delete e os de aplicação específica. Não se pode chamar tarefas de construtores.

8.2. Escopo

Da mesma forma que verilog, System verilog permite observar todos os sinais dando o caminho completo dentro da hierarquia, o que não é possível usando-se VHDL.

9. Blocos de Programa

È uma maneira de se encapsular o que é usado no testbench da sua DUT. Esta barreira existe naturalmente se estamos utilizando uma HDL e HVL, mas no caso de System Verilog poderia se misturar as coisas e assim existe a necessidade desta separação.

Além disto blocos de programa ajudam na portabilidade e reuso. È uma maneira metodológica de isolar os transactors.

Características: tem um único bloco de inicialização; executa eventos em uma fase de verificação sincronizada aos eventos de simulação; pode usar a tarefa $exit que termina a simulação depois que todos os blocos de programa acabaram de executar.

10. Interfaces

As interfaces representam as portas que comunicam os módulos. Na verdade serve como uma maneira de definir bundles de tipos e reusa-los. As interfaces não tem direção e assim evita ficar definindo um port de uma lado como saída e de outro como entrada como se conhece em VHDL.

System Verilog


11. Clocking Blocks

System Verilog oferece os clocking locos que são declarados usando a palavra clocking e endclocking. Esta construção serve para identificar os diferentes domínios de clock, e contém informações sobre o sinal de clock, o timing e a sincronização dos blocos nos quais este clock é usado. Usar domínios de clock no testbench permite usar a metodologia baseada em ciclos ao invés da baseada em eventos. Isto facilita que não haja race conditions do testbench em relação ao DUT.

12. Randomizando a Verificação

Como já vimos na aula de testbench e verificação,´é difícil decidir qual os dados que devem ser usados para as “perguntas” que fazemos ao sistema, e lá já vimos a possibilidade de utilizar random data, ou seja dados randômicos, sendo que a cada rodada da regressão estamos testando algo diferente ou podemos rodar a verificação com dados randômicos até conseguir uma cobertura de código que seja ok para nós.

class randomica;

rand int campo1;

rand int rand2;

function new();

int status;

status=randomize();

end function;

end class;

12.1. pre- e post-randomize



Duas classes vazias que estão ai para serem reescritas com coisas que precisam ser feitas antes ou depois da randomização.

Srand(semente) pode inicializar a semente da função de randomização.

12.2. Tipos de randomização

Verilog já continha a função random, que gera um valor randômico dentro de um intervalo de valores. System Verilog oferece além do random, o random cíclico, o qual gera dados determinísticos se a mesma semente for usada.

Randcase: Pode-se também randomizar que tipo de função será chamada:

Class lala;

task main();

pre_test();

start_test();

randcase

5: main_test(); //25%

5: stress_tes(); //25%

1: error_teste(); //5%

9: normal_test(); //45%

end case;

stop_test();

end task;

12.3. Restrições

Uma vez que queremos dados randômicos, mas existem dados que não nos interessa, é possível restringir os dados randômicos que são gerados.

class base;

rand int y;

rand int x;

constraint R {y >x;} //expressão booleana

End class

Também é possível dar probabilidades para dados em um intervalo ou valor acontecerem.

12.3.1. Restrições Interativas

Uma facilidade que System Verilog também oferece é a possibilidade de gerar restrições interativas.

class C;

rand byte A[];

System Verilog


constraint C1{foreach {A[i]} A[i] inside {2,4,8,16}; }

constraint C2{foreach{A[j]} A[j]>2 *j; }

endclass

13. Abstração e reuso

O uso de abstração e reuso é muito importante para eficiência do time de verificação. Muitas das construções que são oferecidas são relacionadas com programação orientada a objetos. Sabe-se que temos que reaproveitar o código de verificação para aumentar a eficiência do time e o reuso. O código de verificação deve ser portável e OOP auxilia neste aspecto.

13.1. Herança

Herança é um conceito que existe em OOP e que nos serve para a verificação.

E oferece uma herança like, ou seja parecido.

class BasePacket

int id;

byte Payload[];

task send(bit data[]);

endtask

endclass

class ATMPacket extends BasePacket;

byte header[0:4];

function new; // redefine a função

super.new(); // chama o constructor pai

payload = new[48];

.....

end function;

task send(bit data[]); // sobreescreve o método pai

....

endtask

endclass

System Verilog não suporta herança múltipla, mas não é extremamente necessário para os propósitos da verificação. Super. serve para redefinir o método-pai.

Também é possível reescrever um método completamente:

class minha_base;

virtual task metodo_a();

blabla

endtask



endclass

class minha_classe extends minha_base;

task metodo_a();

bla bla

endtask

endclass

ou reescrever partes e reusar (herdar) outras.

Exemplo mais completo:

Este exemplo não tem nada de excepcional, simplesmente defina a escrita e leitura no barramento. Mas note que agora podemos usar esta classe superior para fazer uma classe entendida, por exemplo, que escreve erroneamente, para ver como o sistema se comporta com erros. Em geral o comportamento errôneo é bem parecido tendo apenas um erro de CRC ou um bit errado ou um byte diferente. Assim vejamos uma extensão deste tipo que escreve mas usando o bit mais significativo corrupto escrevendo nele 0.

Ou usar a escrita para “guardar” em algum lugar meu valor para comparação posterior.

Outra possibilidade seria definir um outro método e usar o super. para “herdar” o que já existe. É outra maneira de implementar.

13.2. Classes Abstratas

System Verilog


Usam-se classes abstratas como um template para novas classes. Serve para reuso. A idéia é particionar a funcionalidade em classes básicas e classes derivadas o que ajuda o reuso, mas note que isto deve ser planejado.

virtual class BasePacket;

int id;

virtual task send(bit [0:47] data);

endtask

endclass

class ATMPacket extends BasePacket;

byte header[0:4];

task send(bit[0:47]); //implementação da nova tarefa

.....

Endtask

endclass

13.3. Polimorfismo

“Polimorfismo é o princípio pelo qual duas ou mais classes derivadas de uma mesma superclasse podem invocar métodos que têm a mesma identificação (assinatura), mas comportamentos distintos, especializados para cada classe derivada, usando para tanto uma referência a um objeto do tipo da superclasse”

Por exemplo, definimos simplesmente o envio de dados (pacote) de 31 bits.

virtual class pacote;

bit [31:0] dados;

virtual task enviar;

endtask

endclass

Mas suponha que temos mais de um tipo de pacote, com campos diferentes. Assim,

class pacote_ATM extends pacote;

bit [55:0] dados;

task enviar;

bla bla

endtask

endclass

class pacoteToken extends pacote;

bit [127:0] dados;

task enviar;

bla bla

endtask

endclass



Define-se duas classes diferentes, mas que enviam pacotes de dados, cada uma tendo a sua tarefa de envio diferenciada.

pacote ListadePacotes[100]

pacote_ATM pa = new; // cria um pacote ATM

pacoteToken pt = new; //cria um pacote Token

ListadPacotes[0]=pa;

ListadePacotes[1]=pt;

...

ListadePacotes[0].enviar; // sabe que deve usar o enviar do pacote ATM

ListadePacotes[1].enviar; //sabe que deve usa o enviar de pacotes do tipo Token.

13.4. Pacotes

System Verilog oferece o mesmo tipo de pacote que VHDL. A declaração é feita no arquivo de package.

package ClassesBasicas;

virtual class Base;

int id;

virtual task status;

endtask

end class

…

endpackage

Depois usa-se no programa principal:

program BFM;

import ClassesBasicas::Base;

class CPUEnv extends Base;

task status;

...

endtask

endclass

....

endprogram

14. Cobertura de Código

A linguagem System Verilog tem construções para ajudar a métrica de cobertura. Existem dois tipos de cobertura de código: uma que é automaticamente extraída do código e que foi vista em uma aula específica, e outra que é especificada pelo ususário e serve para correlacionar o ambiente de verificação com a funcionalidade requerida (spec).

System Verilog


As construções aqui apresentadas servem para o segundo caso, tambpem chamado de cobertura funcional.

A cobertura funcional é uma métrica que indica o quanto da spec foi verificada é usada para relacionar com o ambiente de verificação os córner cases, as invariantes da especificação e algumas outras condições.

Uma vez que este tipo de cobertura tem que ser definida pelo usuário, precisamos de uma forma de especificar na linguagem, e System verilog oferece esta possibilidade.

Exemplo

Quantas vezes o a foi igual a 1? Uma vez que se estivermos fazendo uma verificação randômica pode acontecer que os dados não estejam sendo usados uma vez que rodamos poucas vezes a nossa simulação.

Cobertura cruzada: quantas vezes aconteceu de a ser igual a 1 e b igual a 2.

Assim em System verilog podemos definir uma covergroup um grupo que deve se coberto e pontos neste coverpoints.

14.1. Bins

Os bins são contêiners que podem ser criados para valores num intervalo. Na verdade quanddo definimos um tipo de dados sabemos que o intervalo é maior do que os valores que vão realmente ocorrer, assim podsso definir “baldes” para colocar meus valores utilizando para a cobertura funcional os valores que mais me interessam

15. Comunicação e Automatização



System Verilog é uma linguagem orientada a eventos. Eventos são dispoarados automaticamente como o que acontece numa sensitivity list. System Verilog também permite iniciar eventos manualmente.

Exemplo:

Pode-se usar o .triggered para indicar a condição de um evento ter sido disparado.

15.1. Semáforos

System verilog oferece infra-estrutura para semáforos

Imagine a situação de um BFM que pode somente escrever ou ler, ou seja, uma situação de exclusão mútua. Assim pode-se definir o semáforo in_use de forma que somente um dos processos vai ser disparado.

Desta forma podemos utilizar o mesmo barramento.

System Verilog


15.2. Mailboxes

Mailboxes permitem a comunicação assíncrona entre módulos. Todos os problemas que existem, tipo FIFO etc é automaticamente colocada a disposição.

16. Asserções

As asserções não serão tratadas aqui, pois farão parte de uma aula exclusiva para elas juntamente com PSL.

17. Usando System Verilog como uma linguagem de Verificação em ambientes VHDL

Considerações:

• Arquiteura: O topo é System Verilog ou VHDL

• Como conectamos a DUT em VHDl em um Testvbench em Sysem verilog

Teria que usar alguma ferramenta que permitisse se ver (por exemplo o SignalSpy da mentor).

system verilog -notas

Documents