System Verilog

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

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

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 3

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.

Edelweis Garcez Ritt

 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:

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 5

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.

Edelweis Garcez Ritt

 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

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 7

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

Edelweis Garcez Ritt

 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:

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 9

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

Edelweis Garcez Ritt

 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;

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 11

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.

Edelweis Garcez Ritt

 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

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 13

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[];

Edelweis Garcez Ritt

 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

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 15

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

Edelweis Garcez Ritt

 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

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 17

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).

Edelweis Garcez Ritt

 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

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 19

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.

Edelweis Garcez Ritt

 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).

Edelweis Helena Garcez Ritt 2006

 System Verilog Página 21

Edelweis Garcez Ritt