Curso de Engenharia de Controle e Automação

IFES Campus Serra

Arquitetura de Computadores
Prof. Rafael Emerick Z. De Oliveira

Laboratório 1 – Parte 3 – Criando um Testbench com

autoverificação
Objetivo: Criar um módulo testbench para o DUT sequêncial

Introdução
Escrever um testbench é tão complexo como escrever o próprio código RTL.
Atualmente, os ASIC estão ficando cada vez mais complexos e, assim, verificá-los
tornou-se um desafio. Normalmente, 60-70% do tempo necessário para qualquer
ASIC é gasto em verificação/validação/teste. Apesar disso, a maioria dos engenheiros
de ASIC ainda acham que não há glória na verificação.

Criando o DUT
Antes de escrever o testbench, é importante ter a especificação do projeto do
“dispositivo sob teste” (Device Under Test, DUT). As especificações precisam ser
claramente compreendidas e um plano de teste, que basicamente documenta a
arquitetura do banco de teste e os cenários de teste (casos de teste) em detalhes,
precisa ser feito

Contador.sv
Crie um novo projeto, conforme Parte 1, no ModelSim para um contador. Assuma
que teremos que testar um simples contador de 4bits que realiza a contagem sempre
que a entrada enable é ativada, e reseta a zero quando a entrada reset é ativada. Reset
é sincrono com o clock.
Plano de testes

Escreveremos um testbench de auto-verificação. Nosso testbench parecerá algo com a

figura abaixo:

DUT é instanciado no testbench, e neste haverá um gerador de clock, reset, enable e

lógica de comparação, que basicamente calcula os valores esperados do contador e
comparam com a saída dele.

Antes de realizar os testes, é necessário realizar a geração do sinal do clock, para isso,
vamos escrever nosso counter_tb.sv, adicionando-o no projeto.
Após adicionar seu testbench no projeto, verifique se o clock está sendo gerado da
maneira adequada, analise o formato de onda gerado. Simule o seu testbench e
verfique.

O clock foi gerado corretamente?

Testbench com auto-verificação

Adicione o seguinte trecho de código ao seu testbench counter_tb.sv, após o sinal do

clock...

Para realizar auto-verificações será necessário utilizar de recursos que não são
sintetizáveis, úteis apenas para fase de verificações. Esse é o caso $dumpfile, que é
usado para especificar um arquivo que o simulador usará para armazenar a forma de
onda, que pode ser usado mais tarde por um visualizador de forma de onda.
Já $dumpvar orienta o compilador a inicializar o dumping de todos os sinais para o
arquivo “counter.vcd”.

O $display é usado para imprimir texto na tela ou variáveis no stdout(tela), \t para

inserir tabs. A sintax é a mesma utilizada na função printf na linguagem C. $monitor
na segunda linha é ligeiramente diferente: $monitor mante o track das mudanças nas
variáveis que estão listadas como parâmetros, se alguma delas mudar, ele imprimirá
seus valores na respectiva radix especificada. (radix: b→binário, o→octal, h→ hex, d
→ decimal; padrão é decimal).

$finish é usado para termina a simulação após #100 unidades de tempo.

Agora compile o código. Após compila-lo, clique duas vez no módulo testbench na
“library”. Para executar a simulação, ao invés de usar o botão de execução, vá ao
prompt de comando e digite “run”:

O que aconteceu de diferente?

Escrevendo um Testbench

O primeiro passo de qualquer criação de Testbench é a construção de um template

dummy que será usado basicamente para declarar entradas para o DUT como reg e
saídas do DUT como wires (SystemVerilog use tudo logic), então instancia-se a DUT
como mostrado no código abaixo. Note que não existe lista de portas para o testbench
código fonte aqui: http://www.asic-world.com/code/verilog_tutorial/counter_tb1.v

O próximo passo poderia ser adicionar a lógica de geração do clock. Antes de

adicionar o gerador de clock, é necessário direcionar todas as entradas para o DUT
para algum estado conhecido inicial, como mostrado no código abaixo.

http://www.asic-world.com/code/verilog_tutorial/counter_tb2.v

Simule esse testbench e o contador. Verifique o diagrama de ondas.

CONTINUAÇÃO DO TEST BENCH

Agora vamos testar o simulação com verifição e impressão de mensagens na tela,

para isso, precisamos ajustar nosso TB com o código abaixo:
código: http://www.asic-world.com/code/verilog_tutorial/counter_tb3.v

$dumpfile é usado para especificar o arquivo que o simulador armazenará o formato

de onda, que poderá ser usado em visualizadores.

$dumpvars basicamente orienta o compilador a iniciar o dumping de todos os sinais

em “counter.vcd”.

$display é usado para imprimir textos ou variáveis na tela, \t é para inserir tabs. A
sintaxe é a mesma do printf do C. $monitor, na segunda linha, é um pouco diferente:
$monitor mantém o histórico de mudanças das variáveis que estão na lista
(clk,reset,enable,cout). Independentemente da mudança de qualquer uma, ele
imprimirá seus valores, na respectiva representação especificação (binário, hex, etc).

$finish é usado para terminar a simulação após #100 unidades de tempo (note: todo
bloco initial e alwayes inicia a execução no tempo 0).

Agora compile e execute o TB, veja a saída no terminal console do simulador.

Referência:
Esse laboratório é uma tradução as pressas do tutorial online ;) :
http://www.asic-world.com/verilog/art_testbench_writing1.html