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

module  data_consolidation
    (
        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

`timescale 1ns/1ps

   //============== (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

initial clk = 0 ;
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 [1:0]    data_mem [39:0] ;
    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 :

rOuvrir un fichier texte en lecture seule, en autorisant uniquement la lecture des données.
wOuvrir 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éé.
aOuvrir 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éé.
rbOuvrir un fichier binaire en lecture seule, en autorisant uniquement la lecture des données.
wbOuvrir ou créer un fichier binaire en écriture seule, en autorisant uniquement l'écriture des données.
abOuvrir 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