Upload
italoroger
View
602
Download
7
Embed Size (px)
Citation preview
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
Edelweis Helena Garcez Ritt 2006
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:
System Verilog Página 5
Edelweis Garcez Ritt
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
Edelweis Helena Garcez Ritt 2006
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
System Verilog Página 7
Edelweis Garcez Ritt
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
Edelweis Helena Garcez Ritt 2006
>> 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:
System Verilog Página 9
Edelweis Garcez Ritt
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
Edelweis Helena Garcez Ritt 2006
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;
System Verilog Página 11
Edelweis Garcez Ritt
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
Edelweis Helena Garcez Ritt 2006
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
System Verilog Página 13
Edelweis Garcez Ritt
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
Edelweis Helena Garcez Ritt 2006
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
System Verilog Página 15
Edelweis Garcez Ritt
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
Edelweis Helena Garcez Ritt 2006
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
System Verilog Página 17
Edelweis Garcez Ritt
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
Edelweis Helena Garcez Ritt 2006
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 Página 19
Edelweis Garcez Ritt
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
Edelweis Helena Garcez Ritt 2006
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 Página 21
Edelweis Garcez Ritt