Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> VHDL

Domine Verificação Aleatória Restrita com OSVVM

Verificação aleatória restrita é uma estratégia de testbench que depende da geração de transações pseudo-aleatórias para o device under test (DUT). O objetivo é alcançar cobertura funcional de um número de eventos predefinidos através de interação aleatória com o DUT.

Open Source VHDL Verification Methodology (OSVVM) é uma biblioteca VHDL gratuita que inclui vários pacotes convenientes para criar testbenches de verificação aleatória restrita. Estamos particularmente interessados no RandomPkg e CoveragePck, que usaremos neste artigo. Recomendo visitar a página GitHub do OSVVM para aprender mais sobre os recursos desta biblioteca.

O device under test

Vou mergulhar direto em um exemplo para explicar melhor como um testbench de verificação aleatória restrita difere do testbench clássico, que usa testes direcionados. Criamos um FIFO buffer circular no artigo anterior deste blog, mas não criamos um testbench auto-verificável para verificar a correção do módulo.

Vamos criar um testbench adequado para o FIFO buffer circular que usa verificação aleatória restrita.

 entity ring_buffer is generic ( RAM_WIDTH : natural; RAM_DEPTH : natural ); port ( clk : in std_logic; rst : in std_logic; -- Write port wr_en : in std_logic; wr_data : in std_logic_vector(RAM_WIDTH - 1 downto 0); -- Read port rd_en : in std_logic; rd_valid : out std_logic; rd_data : out std_logic_vector(RAM_WIDTH - 1 downto 0); -- Flags empty : out std_logic; empty_next : out std_logic; full : out std_logic; full_next : out std_logic; -- The number of elements in the FIFO fill_count : out integer range RAM_DEPTH - 1 downto 0 ); end ring_buffer; 

A entidade do módulo ring buffer é mostrada no código acima. Vamos tratar o DUT como uma black box, significando que não assumiremos conhecimento de como o DUT é implementado. Afinal, este artigo é sobre o testbench, não o FIFO buffer circular.

Instanciaremos o DUT no testbench usando o método de instanciação de entidade. A instanciação é trivial, então omitirei o código por agora, mas pode ser baixado mais adiante neste artigo.

Os genéricos do DUT serão mapeados para os seguintes valores:

Estratégia do testbench

Vamos passar pela estratégia de teste antes de começar a implementar qualquer coisa. A imagem abaixo mostra o conceito principal do testbench que estamos prestes a criar.

Domine Verificação Aleatória Restrita com OSVVM

Realizaremos transações de escrita aleatórias no lado de entrada do DUT. Os dados de entrada serão definidos para um valor aleatório a cada ciclo de clock, e os strobes na entrada de write enable terão duração aleatória.

Similarmente, realizaremos leituras aleatórias. Asseriremos o sinal de read enable em rajadas que duram um número aleatório de ciclos de clock.

Haverá um modelo comportamental em paralelo com o DUT. Este é um FIFO implementado diferentemente do ring buffer usado no DUT, mas ainda com a mesma interface. Diferente do DUT, o modelo comportamental não precisa ser sintetizável. Isso nos dá liberdade para usar recursos avançados de programação VHDL para criá-lo.

Compararemos a saída do DUT com a saída do modelo comportamental em um processo separado. Este processo será exclusivamente responsável por fazer esta comparação a cada ciclo de clock usando declarações assert. Se as duas implementações de FIFO se comportarem diferentemente a qualquer momento, uma falha de asserção causará a terminação da simulação com erro.

Finalmente, coletaremos dados de cobertura funcional observando as transações indo para e vindo do DUT. Um ponto de cobertura funcional poderia significar, por exemplo, uma leitura e escrita simultâneas, ou que o FIFO é preenchido pelo menos uma vez. Monitoraremos esses eventos em nosso processo sequenciador principal do testbench. A simulação será parada quando todos os eventos de cobertura funcional que estamos monitorando tiverem ocorrido.

Importando a biblioteca OSVVM

A biblioteca OSVVM pode ser usada com qualquer simulador que suporte VHDL-2008. Ela já pode estar incluída nas bibliotecas padrão que vêm com seu simulador. Está incluída no ModelSim PE Student Edition, que pode ser baixado gratuitamente da Mentor Graphics.

O ModelSim vem com uma versão mais antiga do OSVVM, mas tudo bem, tem tudo que precisamos. Podemos simplesmente importar os pacotes random e coverage assim:

 library osvvm; use osvvm.RandomPkg.all; use osvvm.CoveragePkg.all; 

A versão mais recente da biblioteca OSVVM pode sempre ser baixada da página GitHub. Faça isso se seu simulador não a tiver incluída, ou se quiser usar os recursos mais recentes da biblioteca.

Declarando variáveis OSSVM

A biblioteca OSVVM contém pacotes com tipos protegidos. Variáveis criadas destes seriam limitadas em escopo ao processo em que foram definidas. Portanto, declararemos elas como variáveis compartilhadas na região declarativa da arquitetura do testbench, como mostrado no código abaixo.

 -- OSVVM variables shared variable rv : RandomPType; shared variable bin1, bin2, bin3, bin4, bin5, bin6 : CovPType; 

A variável rv do tipo RandomPType é para gerar valores aleatórios. Precisamos apenas de uma destas, porque podemos usar o mesmo objeto em todo processo onde precisamos gerar valores aleatórios. A última linha declara seis variáveis do tipo CovPType.

Declaramos seis variáveis de cobertura porque vamos ter seis metas de cobertura, nos referiremos a estes objetos como "bins". As variáveis compartilhadas têm que ser inicializadas antes de poderem ser usadas para coletar dados de cobertura. Fazemos isso chamando o procedimento AddBins em cada um dos bins CovPType.

 -- Set up coverage bins bin1.AddBins("Write while empty", ONE_BIN); bin2.AddBins("Read while full", ONE_BIN); bin3.AddBins("Read and write while almost empty", ONE_BIN); bin4.AddBins("Read and write while almost full", ONE_BIN); bin5.AddBins("Read without write when almost empty", ONE_BIN); bin6.AddBins("Write without read when almost full", ONE_BIN); 

Fornecemos uma descrição em string do bin de cobertura como primeiro parâmetro para o procedimento AddBins. Esta string reaparecerá no final da simulação quando imprimirmos as estatísticas para cada bin de cobertura. Como você pode ver nas descrições de texto, vamos usar os bins para verificar se alguns casos de canto muito específicos ocorreram.

AddBins é um procedimento sobrecarregado que pode ser usado para criar vários scoreboards dentro das variáveis de bin. No entanto, teremos apenas um scoreboard associado a cada bin. Portanto, forneceremos a constante de conveniência ONE_BIN como parâmetro para o procedimento AddBins. Isso inicializará as variáveis CovPType com um bin cada. Os scoreboards representados pelos bins são considerados cobertos quando os eventos que monitoram ocorreram pelo menos uma vez.

Gerando entrada aleatória

Vamos começar criando o processo que gera dados de entrada para o DUT. O FIFO buffer circular é projetado para ignorar tentativas de overwrite e over-read. Portanto, podemos simplesmente escrever dados aleatórios em rajadas de duração aleatória. Não temos que pensar se o DUT realmente está pronto para absorver os dados ou não.

 PROC_WRITE : process begin wr_en <= rv.RandSlv(1)(1) and not rst; for i in 0 to rv.RandInt(0, 2 * RAM_DEPTH) loop wr_data <= rv.RandSlv(RAM_WIDTH); wait until rising_edge(clk); end loop; end process; 

A única consideração que este processo toma é que o DUT não está em reset. Aleatoriamente habilitamos ou desabilitamos o sinal de write enable na primeira linha deste processo, mas ele só será habilitado se rst for '0'.

O for-loop subsequente escreverá dados aleatórios no DUT por um número aleatório de ciclos de clock, mesmo que o sinal de enable não esteja ativo. Podemos fazer isso porque o DUT deve ignorar a porta wr_data a menos que o sinal wr_en seja '1'. Após o for-loop, o programa voltará ao início do processo, disparando outra transação de escrita aleatória.

Realizando leituras aleatórias

O processo que lê dados do DUT é similar ao processo de escrita. Podemos ativar aleatoriamente o sinal rd_en a qualquer momento porque o DUT é projetado para ignorar tentativas de leitura quando vazio. Os dados que aparecem na porta rd_data não são realmente verificados. Este processo apenas controla o sinal de read enable.

 PROC_READ : process begin rd_en <= rv.RandSlv(1)(1) and not rst; for i in 0 to rv.RandInt(0, 2 * RAM_DEPTH) loop wait until rising_edge(clk); end loop; end process; 

Verificação comportamental

Construiremos um modelo comportamental do DUT dentro de nosso testbench para verificar seu comportamento. Esta é uma estratégia de testbench bem conhecida. Primeiro, alimentamos o modelo comportamental simultaneamente com a mesma entrada do DUT. Então, podemos comparar a saída dos dois para verificar se o DUT tem o comportamento correto.

Domine Verificação Aleatória Restrita com OSVVM

A imagem acima mostra o layout básico de tal testbench. O modelo comportamental trabalha em paralelo com o DUT. Usamos como blueprint para verificar as saídas do DUT contra.

O FIFO do testbench

Usaremos uma lista encadeada para implementar o modelo comportamental. Listas encadeadas não podem ser sintetizadas, mas são perfeitas para testbenches. Você pode recordar o artigo Como criar uma Lista Encadeada em VHDL se é leitor regular deste blog. Usaremos o código dele para implementar o modelo comportamental para o FIFO buffer circular.

 package DataStructures is type LinkedList is protected procedure Push(constant Data : in integer); impure function Pop return integer; impure function IsEmpty return boolean; end protected; end package DataStructures; 

A declaração do pacote para a Lista Encadeada FIFO é mostrada no código acima. É um tipo protegido que tem três funções: Push, Pop e IsEmpty. Estas são usadas para adicionar e remover elementos do FIFO, bem como para verificar se há zero elementos restantes nele.

 -- Testbench FIFO that emulates the DUT shared variable fifo : LinkedList; 

Tipos protegidos são construtos semelhantes a classe em VHDL. Criaremos um objeto da lista encadeada declarando uma variável compartilhada na região declarativa do testbench, como mostrado no código acima.

O modelo comportamental

Para emular totalmente o comportamento do FIFO buffer circular, declaramos dois novos sinais que espelham os sinais de saída do DUT. O primeiro sinal contém o dado de saída do modelo comportamental, e o segundo é o sinal valid associado.

 -- Testbench FIFO signals signal fifo_out : integer; signal fifo_out_valid : std_logic := '0'; 

O código acima mostra a declaração dos dois sinais de saída do modelo comportamental. Não precisamos de sinais de entrada dedicados para o modelo comportamental, porque eles são os mesmos que estão conectados ao DUT. Estamos usando sinais para emular a saída do DUT porque isso nos permite coletar dados de cobertura facilmente, como veremos mais adiante neste artigo.

 PROC_BEHAVIORAL_MODEL : process begin wait until rising_edge(clk) and rst = '0'; -- Emulate a write if wr_en = '1' and full = '0' then fifo.Push(to_integer(unsigned(wr_data))); report "Push " & integer'image(to_integer(unsigned(wr_data))); end if; -- Emulate a read if rd_en = '1' and empty = '0' then fifo_out <= fifo.Pop; fifo_out_valid <= '1'; else fifo_out_valid <= '0'; end if; end process; 

O processo que implementa o modelo comportamental do FIFO buffer circular é mostrado no código acima. Este processo será disparado a cada borda de subida do clock, se o sinal de reset não estiver ativo.

O modelo comportamental empurra um novo valor para o FIFO do testbench sempre que o sinal wr_en é asserido enquanto o sinal full é '0'. Similarmente, a lógica de leitura no processo do modelo comportamental funciona ouvindo os sinais rd_en e empty. O último é controlado pelo DUT, mas verificaremos que está funcionando no próximo processo que criaremos.

Verificando as saídas

Toda a lógica responsável por verificar as saídas do DUT é reunida em um processo chamado "PROC_VERIFY". Usamos declarações assert para verificar que as saídas do DUT correspondem às do modelo comportamental. Também verificamos que o DUT e o modelo comportamental concordam sobre quando o FIFO está vazio.

O código para o processo de verificação é mostrado abaixo.

 PROC_VERIFY : process begin wait until rising_edge(clk) and rst = '0'; -- Check that DUT and TB FIFO are reporting empty simultaneously assert (empty = '1' and fifo.IsEmpty) or (empty = '0' and not fifo.IsEmpty) report "empty=" & std_logic'image(empty) & " while fifo.IsEmpty=" & boolean'image(fifo.IsEmpty) severity failure; -- Check that the valid signals are matching assert rd_valid = fifo_out_valid report "rd_valid=" & std_logic'image(rd_valid) & " while fifo_out_valid=" & std_logic'image(fifo_out_valid) severity failure; -- Check that the output from the DUT matches the TB FIFO if rd_valid then assert fifo_out = to_integer(unsigned(rd_data)) report "rd_data=" & integer'image(to_integer(unsigned(rd_data))) & " while fifo_out=" & integer'image(fifo_out) severity failure; report "Pop " & integer'image(fifo_out); end if; end process; 

O processo é disparado pela borda de subida do clock, como vemos na primeira linha de código. O DUT é um processo clockado, e a lógica downstream conectada ao DUT também é esperada para ser síncrona ao sinal de clock. Portanto, faz sentido verificar as saídas na borda de subida do clock.

O segundo bloco de código verifica que o sinal empty vindo do DUT é asserido apenas quando o FIFO do testbench está vazio. O DUT e o modelo comportamental ambos têm que concordar que o FIFO está vazio ou não para este teste passar.

Então segue uma comparação dos sinais valid de dados de leitura. O DUT e o modelo comportamental devem estar outputando dados simultaneamente, caso contrário há algo errado.

Finalmente, verificamos que o dado de saída do DUT corresponde ao próximo elemento que damos pop do FIFO do testbench. Isso, claro, só acontece se o sinal rd_valid for asserido, significando que o sinal rd_data pode ser amostrado.

Coletando dados de cobertura

Para controlar o fluxo principal do testbench, criaremos um processo sequenciador. Este processo inicializará os bins de cobertura, rodará os testes e parará o testbench quando todas as metas de cobertura forem atingidas. O código abaixo mostra o processo completo "PROC_SEQUENCER".

 PROC_SEQUENCER : process begin -- Set up coverage bins bin1.AddBins("Write while empty", ONE_BIN); bin2.AddBins("Read while full", ONE_BIN); bin3.AddBins("Read and write while almost empty", ONE_BIN); bin4.AddBins("Read and write while almost full", ONE_BIN); bin5.AddBins("Read without write when almost empty", ONE_BIN); bin6.AddBins("Write without read when almost full", ONE_BIN); wait until rising_edge(clk); wait until rising_edge(clk); rst <= '0'; wait until rising_edge(clk); loop wait until rising_edge(clk); -- Collect coverage data bin1.ICover(to_integer(wr_en = '1' and empty = '1')); bin2.ICover(to_integer(rd_en = '1' and full = '1')); bin3.ICover(to_integer(rd_en = '1' and wr_en = '1' and empty = '0' and empty_next = '1')); bin4.ICover(to_integer(rd_en = '1' and wr_en = '1' and full = '0' and full_next = '1')); bin5.ICover(to_integer(rd_en = '1' and wr_en = '0' and empty = '0' and empty_next = '1')); bin6.ICover(to_integer(rd_en = '0' and wr_en = '1' and full = '0' and full_next = '1')); -- Stop the test when all coverage goals have been met exit when bin1.IsCovered and bin2.IsCovered and bin3.IsCovered and bin4.IsCovered and bin5.IsCovered and bin6.IsCovered; end loop; report("Coverage goals met"); -- Make sure that the DUT is empty before terminating the test wr_en <= force '0'; rd_en <= force '1'; loop wait until rising_edge(clk); exit when empty = '1'; end loop; -- Print coverage data bin1.WriteBin; bin2.WriteBin; bin3.WriteBin; bin4.WriteBin; bin5.WriteBin; bin6.WriteBin; finish; end process; 

Primeiro, inicializamos os objetos de bin de cobertura chamando o procedimento AddBins neles, como já discutimos anteriormente neste artigo. Então, após o reset ser liberado, passamos a coletar dados de cobertura. A cada borda de subida do clock, o código dentro do loop construct será executado.

O primeiro bloco de código dentro do loop é para coletar dados de cobertura. Podemos chamar o procedimento ICover no bin para registrar um hit no ponto de cobertura que ele representa. Se fornecermos o parâmetro inteiro 0, a chamada não terá efeito. Se usarmos o parâmetro inteiro 1, contará como um hit.

Há apenas um "bin" dentro de cada objeto de bin de cobertura, porque os inicializamos usando a constante ONE_BIN. Este único bin pode ser alcançado chamando ICover(1). Podemos registrar um hit ou miss no ponto de cobertura convertendo nossas expressões booleanas para os inteiros 1 ou 0 usando a função to_integer

Após os dados de cobertura serem registrados, verificamos se todas as metas de cobertura foram atingidas chamando a função IsCovered em todos os bins. Então, saímos do loop se todas as metas de cobertura foram atingidas.

Garantiremos que o DUT esteja vazio antes de terminar o teste. Para isso, assumimos controle dos processos de escrita e leitura forçando o sinal wr_en a '0' e o sinal rd_en a '1'.

Finalmente, imprimimos estatísticas de quantas vezes cada meta de cobertura foi atingida chamando a função WriteBin em cada um dos bins de cobertura. A palavra-chave finish no final do processo fará o simulador parar a simulação.

Rodando o testbench

Você pode baixar o projeto ModelSim completo com todos os arquivos VHDL usando o formulário abaixo.

Após carregarmos o projeto executando o do-file incluído no Zip, podemos rodar o testbench simplesmente digitando "runtb" no console do ModelSim. O tempo de execução do testbench será aleatório porque as metas de cobertura são atingidas aleatoriamente. No entanto, os resultados do teste são reproduzíveis porque na verdade é uma sequência pseudo-aleatória que é usada.

Não inicializamos uma seed em nosso código, significando que o valor de seed padrão será usado para o gerador pseudo-aleatório. É possível definir uma seed diferente chamando o procedimento InitSeed no objeto RandomPType, isso produzirá uma sequência aleatória diferente.

A saída do console

A saída impressa no console do ModelSim após darmos o comando "runtb" é mostrada abaixo. Haverá muitos pushes e pops aleatórios do FIFO do testbench enquanto a simulação roda.

VSIM 2> runtb # ** Warning: Design size of 15929 statements or 2 leaf instances exceeds # ModelSim PE Student Edition recommended capacity. # Expect performance to be quite adversely affected. # ** Note: Push 34910 # Time: 790 ns Iteration: 0 Instance: /ring_buffer_tb ... # ** Note: Pop 37937 # Time: 83100 ns Iteration: 0 Instance: /ring_buffer_tb # ** Note: Pop 13898 # Time: 83110 ns Iteration: 0 Instance: /ring_buffer_tb # %% WriteBin: # %% Write while empty Bin:(1) Count = 2 AtLeast = 1 # # %% WriteBin: # %% Read while full Bin:(1) Count = 3 AtLeast = 1 # # %% WriteBin: # %% Read and write while almost empty Bin:(1) Count = 106 AtLeast = 1 # # %% WriteBin: # %% Read and write while almost full Bin:(1) Count = 1 AtLeast = 1 # # %% WriteBin: # %% Read without write when almost empty Bin:(1) Count = 1 AtLeast = 1 # # %% WriteBin: # %% Write without read when almost full Bin:(1) Count = 3 AtLeast = 1 # # Break in Process PROC_SEQUENCER at C:/crv/ring_buffer_tb.vhd line 127 

Estatísticas para todos os bins de cobertura são impressas quando todas as metas de cobertura foram atingidas. Alguns dos bins foram atingidos apenas uma vez, enquanto um foi atingido 106 vezes. Mas no final, cada bin foi atingido pelo menos uma vez. Assim, podemos saber que todos os eventos que definimos bins de cobertura para foram testados e verificados.

A forma de onda

Vamos examinar a forma de onda para ter uma ideia do que o testbench tem feito. A imagem abaixo mostra a forma de onda com o sinal fill_count representado como valor analógico. O FIFO está cheio quando o traço para este sinal está no topo, e vazio quando está na base.

Domine Verificação Aleatória Restrita com OSVVM

Como podemos ver na forma de onda, o buffer circular está sendo preenchido e esvaziado aleatoriamente. Ainda assim, não programamos explicitamente estas inclinações e declínios no nível de preenchimento. No entanto, estamos vendo um padrão orgânico de interação com o DUT.

Mais sobre verificação aleatória restrita

Verificação aleatória restrita é uma boa estratégia de testbench quando o vetor de teste tem muitas permutações para um teste exaustivo ser prático. Interações aleatórias exibem comportamento mais natural que um teste de caso de canto direcionado teria feito, sem sacrificar precisão.

Podemos ter certeza que todos os casos de canto foram atingidos, desde que tenhamos configurado a coleta de dados de cobertura corretamente. O benefício adicional é que testes randomizados são mais propensos a expor fraquezas no DUT que você não está testando especificamente. Desde que você conheça todos os casos de canto, pode criar testes direcionados para eles. Mas casos de canto são facilmente esquecidos, e é quando você pode se beneficiar da metodologia de verificação aleatória restrita.

Este artigo apenas arranhou a superfície do que você pode fazer com verificação aleatória restrita. Recomendo ler a documentação na página GitHub do OSVVM para se aprofundar no assunto.

Também recomendo o curso Advanced VHDL Testbenches and Verification da SynthWorks, do qual não sou afiliado. No entanto, participei da versão de 5 dias deste curso físico. O curso é ministrado por Jim Lewis, presidente do VHDL Analysis and Standardization Group (VASG). No geral, um ótimo investimento para qualquer empresa que queira levar seus testbenches VHDL para o próximo nível.


VHDL

  1. Cadence Revela Soluções de Emulação e Prototipagem Rapid-Performance para Verificação de SoC de Bilhões de Portas
  2. Siemens Impulsiona Sistema Veloce com Quatro Novos Produtos, Permitendo Verificação Assistida por Hardware Contínua
  3. Synopsys Revela Suite Completa HBM3 IP para Sistemas Multi-Die, Aumentando Largura de Banda para 921 GB/s
  4. Sistema Integrado de Controle de Acesso com QR, RFID e Verificação de Temperatura
  5. Os Desafios Imprevisíveis da Manutenção: Insights do Especialista Jason Afara
  6. Gerar Números Aleatórios em Java: Guia Prático com Random e Math.random
  7. Java 8 Streams: Abordagem Declarativa para Processamento de Dados
  8. Torno de Mesa Inclinada Hurco TM8 – Design Compacto, Controle de Precisão e Ferramentas Versáteis
  9. Design de PCB de Alta Velocidade: Processamento de Sinal Diferencial e Verificação por Simulação
  10. Programa de Verificação de Desempenho de Compressores Rotativos CAGI: Garantindo Operação Confiável e Eficiente