Mots-clés : testbench, simulation, lecture/écriture de fichier
Une fois la conception du code Verilog terminée, une étape importante reste à réaliser, à savoir la simulation fonctionnelle logique. Le fichier de stimulus de simulation est appelé un testbench et est placé au niveau supérieur des modules de conception afin que les modules puissent être systématiquement instanciés et invoqués pour la simulation.
Il n'est pas exagéré de dire que pour des conceptions Verilog légèrement complexes, si la simulation n'est pas effectuée, plus de 99.9999% des conceptions ne fonctionneront pas correctement, même pour des vétérans expérimentés. On ne peut pas dire que la simulation est plus importante que la conception, mais d'une manière générale, la simulation prend plus de temps que la conception. Parfois, en considérant divers scénarios d'application, écrire un testbench peut être plus complexe qu'une conception Verilog. Par conséquent, l'industrie des circuits numériques distingue spécifiquement les ingénieurs de conception et les ingénieurs de vérification.
Ci-dessous, nous allons faire une brève étude du testbench.
Décomposition de la structure du testbench
La structure générale d'un testbench est la suivante :
En fait, la structure la plus basique d'un testbench comprend la déclaration des signaux, le stimulus et l'instanciation de module.
Selon la complexité de la conception, les parties d'horloge et de réinitialisation doivent être introduites. Bien sûr, pour des conceptions plus complexes, la partie stimulus sera également plus complexe. Selon vos besoins de vérification, choisissez si des parties d'auto-vérification et de terminaison de simulation sont nécessaires.
Bien sûr, les parties de génération de réinitialisation et d'horloge peuvent également être considérées comme un stimulus, de sorte qu'elles peuvent toutes être implémentées dans un seul bloc d'instructions. Le résultat d'auto-vérification peut également être utilisé comme condition pour mettre fin à la simulation.
En simulation réelle, vous pouvez écrire le testbench selon vos propres habitudes personnelles ; ce n'est qu'un résumé personnel.
Exemple de simulation de testbench
De nombreux testbenches ont déjà été écrits dans les chapitres précédents. En fait, leurs structures sont à peu près les mêmes.
Ci-dessous, nous donnons un exemple simple de concaténation de données et effectuons une analyse spécifique du testbench.
Un module fonctionnel qui concatène des données de 2 bits en données de 8 bits est décrit comme suit :
Exemple
(
input clk ,
input rstn ,
input [1:0] din , //données d'entrée
input din_en ,
output [7:0] dout ,
output dout_en //données de sortie
);
// décalage de données et compteur
reg [7:0] data_r ;
reg [1:0] state_cnt ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
state_cnt <= 'b0 ;
data_r <= 'b0 ;
end
else if (din_en) begin
state_cnt <= state_cnt + 1'b1 ; //Comptage des données
data_r <= {data_r[5:0], din} ; //Concaténation de données
end
else begin
state_cnt <= 'b0 ;
end
end
assign dout = data_r ;
// activation de la sortie de données
reg dout_en_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
dout_en_r <= 'b0 ;
end
//Lorsque le compteur est à 3 et que la 4e donnée est entrée, émettre de manière synchrone le signal d'activation de sortie de données
else if (state_cnt == 2'd3 & din_en) begin
dout_en_r <= 1'b1 ;
end
else begin
dout_en_r <= 1'b0 ;
end
end
//Ici, dout_en n'est pas déclaré directement comme variable reg ; à la place, il est affecté via assign en utilisant les registres associés
assign dout_en = dout_en_r;
endmodule
La description correspondante du banc de test est la suivante, avec les instructions de lecture/écriture de fichiers ajoutées :
Exemple
//============== (1) ==================
//déclaration des signaux
module test ;
reg clk;
reg rstn ;
reg [1:0] din ;
reg din_en ;
wire [7:0] dout ;
wire dout_en ;
//============== (2) ==================
//génération d'horloge
real CYCLE_200MHz = 5 ; //
always begin
clk = 0 ; #(CYCLE_200MHz/2) ;
clk = 1 ; #(CYCLE_200MHz/2) ;
end
//============== (3) ==================
//génération de reset
initial begin
rstn = 1'b0 ;
#8 rstn = 1'b1 ;
end
//============== (4) ==================
//motivation
int fd_rd ;
reg [7:0] data_in_temp ; //pour auto-vérification
reg [15:0] read_temp ; //données ASCII 8bit, 8bit \n
initial begin
din_en = 1'b0 ; //(4.1)
din = 'b0 ;
open_file("../tb/data_in.dat", "r", fd_rd); //(4.2)
wait (rstn) ; //(4.3)
# CYCLE_200MHz ;
//lire les données depuis le fichier
while (! $feof(fd_rd) ) begin //(4.4)
@(negedge clk) ;
$fread(read_temp, fd_rd);
din = read_temp[9:8] ;
data_in_temp = {data_in_temp[5:0], din} ;
din_en = 1'b1 ;
end
//arrêter les données
@(posedge clk) ; //(4.5)
#2 din_en = 1'b0 ;
end
//ouvrir la tâche
task open_file;
input string file_dir_name ;
input string rw ;
output int fd ;
fd = $fopen(file_dir_name, rw);
if (! fd) begin
$display("--- iii --- Échec de l'ouverture du fichier : %s", file_dir_name);
end
else begin
$display("--- iii --- %s a été ouvert avec succès.", file_dir_name);
end
endtask
//============== (5) ==================
//instanciation de module
data_consolidation u_data_process
(
.clk (clk),
.rstn (rstn),
.din (din),
.din_en (din_en),
.dout (dout),
.dout_en (dout_en)
);
//============== (6) ==================
//vérification automatique
reg [7:0] err_cnt ;
int fd_wr ;
initial begin
err_cnt = 'b0 ;
open_file("../tb/data_out.dat", "w", fd_wr);
forever begin
@(negedge clk) ;
if (dout_en) begin
$fdisplay(fd_wr, "%h", dout);
end
end
end
always @(posedge clk) begin
#1 ;
if (dout_en) begin
if (data_in_temp != dout) begin
err_cnt = err_cnt + 1'b1 ;
end
end
end
//============== (7) ==================
//fin de simulation
always begin
#100;
if ($time >= 10000) begin
if (!err_cnt) begin
$display("-------------------------------------");
$display("Data process is OK!!!");
$display("-------------------------------------");
end
else begin
$display("-------------------------------------");
$display("Error occurs in data process!!!");
$display("-------------------------------------");
end
#1 ;
$finish ;
end
end
endmodule // test
Les résultats de simulation sont les suivants. Comme on peut le voir sur la figure, la conception de la fonction d'intégration des données répond aux exigences :
Analyse détaillée du banc de test
1) Déclaration des signaux
Lors de la déclaration d'un module de banc de test, il n'est généralement pas nécessaire de déclarer des ports, car les signaux de stimulation sont généralement à l'intérieur du module de banc de test et il n'y a aucun signal externe.
Les variables déclarées doivent toutes correspondre aux ports du module sous test. Bien entendu, les variables ne doivent pas nécessairement avoir les mêmes noms que les ports du module sous test. Cependant, les variables correspondant aux ports d'entrée du module sous test doivent être déclarées de type reg, telles que clk, rstn, etc., et les variables correspondant aux ports de sortie doivent être déclarées de type wire, telles que dout, dout_en.
2) Génération d'horloge
Il existe de nombreuses façons de générer une horloge ; par exemple, les deux méthodes de génération suivantes peuvent également être utilisées comme référence.
Exemple
always #(CYCLE_200MHz/2) clk = ~clk;
initial begin
clk = 0 ;
forever begin
#(CYCLE_200MHz/2) clk = ~clk;
end
end
Il convient de noter que lors de l'utilisation de la méthode d'inversion pour générer une horloge, une valeur initiale doit être affectée au registre clk.
Lors de l'utilisation de la méthode des paramètres pour spécifier des délais, si le paramètre de délai est un nombre à virgule flottante, ce paramètre ne doit pas être déclaré comme type parameter. Par exemple, dans l'exemple, la variable CYCLE_200MHz a une valeur de 2.5. Si son type de variable est parameter, la période d'horloge finalement générée est susceptible d'être de 4ns. Bien sûr, la précision de timescale doit également être augmentée ; l'unité et la précision ne peuvent pas être identiques, sinon la partie fractionnaire de l'affectation du délai ne prendra pas effet.
3) Génération de reset
La logique de reset est relativement simple. Généralement, la valeur initiale est mise à 0, puis après un petit délai, reset est mis à 1.
La plupart des simulations ici utilisent un reset actif à l'état bas.
4) Partie stimulus
Le type de signaux d'entrée que la partie stimulus doit générer est conçu en fonction des besoins du module sous test.
Dans cet exemple :
- (4.1) Initialiser les signaux d'entrée du module sous test afin d'éviter l'apparition de la valeur inconnue X. Pour générer les données de stimulus, nous devons lire depuis un fichier de données.
- À (4.2), une tâche est utilisée pour ouvrir un fichier. Tant que le fichier spécifié existe, un signal de descripteur non nul fp_rd peut être obtenu. fp_rd spécifie l'adresse de début des données du fichier.
- L'opération en (4.3) consiste à attendre après la réinitialisation, afin que le système ait un état testable sûr et stable.
- À (4.4), il commence à lire les données et à appliquer le stimulus dans une boucle. L'envoi de données sur le front descendant de l'horloge vise à ce que le module sous test puisse mieux échantillonner les données sur le front montant.
À l'aide de la tâche système $fread, la variable de données de 16 bits lue est injectée dans le tampon read_temp via le signal de descripteur fd_rd.
La capture d'écran des premières données du fichier de données d'entrée est la suivante. Comme $fread ne peut lire que des fichiers binaires, la première ligne du fichier d'entrée correspond au code ASCII 330a. Par conséquent, pour obtenir la donnée 3 dans le fichier, nous devons prendre les données du bit 9 au bit 8 de la variable read_temp.

Le signal data_in_temp est une intégration ultérieure du signal de données d'entrée. Plus tard, le module de vérification l'utilisera comme référence pour déterminer si la simulation est normale et si la conception du module est correcte.
- À (4.5), le choix d'arrêter les données d'entrée après avoir retardé de 2 cycles sur le front montant de l'horloge vise à ce que le module sous test puisse normalement échantillonner le dernier signal d'activation des données et intégrer correctement les données.
Lorsque la quantité de données est relativement faible, vous pouvez utiliser la tâche système $readmemh en Verilog pour lire directement les données hexadécimales ligne par ligne. En conservant les données et le format du fichier data_in.dat inchangés, cette partie stimulus peut être décrite comme suit :
Exemple
reg [7:0] data_in_temp ; //pour auto-vérification
entier k1 ;
initial begin
din_en = 1'b0 ;
din = 'b0 ;
$readmemh("../tb/data_in.dat", data_mem);
wait (rstn) ;
# CYCLE_200MHz ;
//lire les données depuis le fichier
for(k1=0; k1<40; k1=k1+1) begin
@(negedge clk) ;
din = data_mem[k1] ;
data_in_temp = {data_in_temp[5:0], din} ;
din_en = 1'b1 ;
end
//arrêter les données
@(posedge clk) ;
#2 din_en = 1'b0 ;
end
5) Instanciation de module
Ici, les variables de signal déclarées au début du banc de test sont utilisées pour instancier et connecter le module sous test.
6) Auto-vérification
Si la conception est relativement simple, il est tout à fait possible de déterminer si la conception est correcte à travers les formes d'onde des signaux d'entrée et de sortie, et cette partie peut être complètement supprimée. S'il y a beaucoup de données, l'observation à l'œil nu ne permet parfois pas de juger efficacement de l'exactitude de la conception. À ce moment-là, ajouter un module d'auto-vérification augmentera considérablement l'efficacité de la simulation.
Dans l'exemple, lorsque la validation de sortie de données dout_en est active, nous comparons les données de sortie dout avec les données de référence read_temp (générées par la partie stimulus) et plaçons le résultat de la comparaison dans le signal err_cnt. Enfin, nous pouvons juger intuitivement de l'exactitude de la conception en observant si le signal err_cnt vaut 0.
Bien sûr, comme le montre l'exemple, nous pouvons également écrire les données dans un fichier correspondant et utiliser d'autres méthodes pour la comparaison.
7) Fin de la simulation
Si nous n'ajoutons pas la partie de terminaison de simulation, la simulation s'exécutera indéfiniment, et des formes d'onde trop longues sont parfois peu pratiques à analyser. Verilog fournit la tâche système $finish pour arrêter la simulation.
Avant d'arrêter la simulation, les résultats de l'auto-vérification peuvent être affichés dans le terminal à l'aide de la tâche système $display.
Options de lecture/écriture de fichiers
Le format de la tâche système $fopen utilisée pour ouvrir un fichier est le suivant :
fd = $fopen("<name_of_file>", "mode")
Comme dans le langage C, la signification de l'option de mode d'ouverture "mode" est la suivante :
| r | Ouvrir un fichier texte en lecture seule, en autorisant uniquement la lecture des données. |
|---|---|
| w | Ouvrir un fichier texte en écriture seule, en autorisant uniquement l'écriture des données. Si le fichier existe, le contenu original du fichier sera supprimé. Si le fichier n'existe pas, un nouveau fichier sera créé. |
| a | Ouvrir un fichier texte en ajout et écrire des données à la fin du fichier. Si le fichier n'existe pas, un nouveau fichier sera créé. |
| rb | Ouvrir un fichier binaire en lecture seule, en autorisant uniquement la lecture des données. |
| wb | Ouvrir ou créer un fichier binaire en écriture seule, en autorisant uniquement l'écriture des données. |
| ab | Ouvrir un fichier binaire en ajout et écrire des données à la fin du fichier. |
| r+ | Ouvrir un fichier texte en lecture et en écriture, en autorisant à la fois la lecture et l'écriture. |
| w+ | Ouvrir ou créer un fichier texte en lecture et en écriture, en autorisant la lecture et l'écriture. Si le fichier existe, le contenu original du fichier sera supprimé. Si le fichier n'existe pas, un nouveau fichier sera créé. |
| a+ | Ouvrir un fichier texte en lecture et en écriture, en autorisant la lecture et l'écriture. Si le fichier n'existe pas, un nouveau fichier sera créé. La lecture du fichier commence au début du fichier, et l'écriture ne peut se faire qu'en mode ajout. |
| rb+ | Ouvrir un fichier texte binaire en lecture et en écriture, avec des fonctionnalités similaires à "r+". |
| wb+ | Ouvrir ou créer un fichier texte binaire en lecture et en écriture, avec des fonctionnalités similaires à "w+". |
| ab+ | Ouvrir un fichier texte binaire en lecture et écriture, avec une fonctionnalité similaire à "a+". |
Téléchargement du code source
Téléchargement
