Schlüsselwörter: Testbench, Simulation, Datei lesen/schreiben

Nach Abschluss des Verilog-Codedesigns muss noch ein wichtiger Schritt durchgeführt werden, nämlich die logische Funktionssimulation. Die Simulationsstimulusdatei wird Testbench genannt und an der obersten Ebene der Designmodule platziert, damit die Module systematisch instanziiert und zur Simulation aufgerufen werden können.

Es ist keine Übertreibung zu sagen, dass bei etwas komplexeren Verilog-Designs, wenn keine Simulation durchgeführt wird, mehr als 99.9999% der Designs nicht korrekt funktionieren werden, selbst für erfahrene Veteranen. Man kann nicht sagen, dass Simulation wichtiger als Design ist, aber im Allgemeinen nimmt die Simulation mehr Zeit in Anspruch als das Design. Manchmal kann das Schreiben einer Testbench angesichts verschiedener Anwendungsszenarien komplexer sein als das Verilog-Design. Daher unterscheidet die Digital-Schaltungs-Industrie speziell zwischen Designingenieuren und Verifikationsingenieuren.

Im Folgenden werden wir uns kurz mit der Testbench befassen.

Aufschlüsselung der Testbench-Struktur

Die allgemeine Struktur einer Testbench ist wie folgt:

Tatsächlich umfasst die grundlegendste Struktur einer Testbench Signal-Deklaration, Stimulus und Modulinstanziierung.

Je nach Komplexität des Designs müssen Takt- und Reset-Teile eingeführt werden. Natürlich ist bei komplexeren Designs auch der Stimulus-Teil komplexer. Wählen Sie entsprechend Ihren Verifikationsanforderungen aus, ob Selbstprüfungs- und Simulationsabbruch-Teile benötigt werden.

Natürlich können die Reset- und Takterzeugungsteile auch als Stimulus betrachtet werden, sodass sie alle in einem einzigen Anweisungsblock implementiert werden können. Das Selbstprüfungsergebnis kann auch als Bedingung für die Beendigung der Simulation verwendet werden.

Bei der tatsächlichen Simulation können Sie die Testbench nach Ihren eigenen persönlichen Gewohnheiten schreiben; dies ist nur eine persönliche Zusammenfassung.

Testbench-Simulationsbeispiel

In den vorherigen Kapiteln wurden bereits viele Testbenches geschrieben. Tatsächlich sind ihre Strukturen ungefähr gleich.

Im Folgenden geben wir ein einfaches Beispiel für Datenverkettung und führen eine spezifische Analyse der Testbench durch.

Ein funktionales Modul, das 2-Bit-Daten zu 8-Bit-Daten verkettet, wird wie folgt beschrieben:

Beispiel

module  data_consolidation
    (
        input           clk ,
        input           rstn ,
        input [1:0]     din ,          //Dateneingang
        input           din_en ,
        output [7:0]    dout ,
        output          dout_en        //Datenausgang
     );

   // Datenverschiebung und Zähler
    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 ;    //Datenzählung
            data_r        <= {data_r[5:0], din} ;  //Datenkonkatenation
        end
        else begin
            state_cnt <= 'b0 ;
        end
    end
    assign dout          = data_r ;

    // Datenausgabe-Freigabe
    reg                  dout_en_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            dout_en_r       <= 'b0 ;
        end
        //Wenn der Zählerstand 3 ist und die 4. Daten eingegeben werden, wird das Datenausgabe-Freigabesignal synchron ausgegeben
        else if (state_cnt == 2'd3 & din_en) begin  
            dout_en_r       <= 1'b1 ;
        end
        else begin
            dout_en_r       <= 1'b0 ;
        end
    end
    //Hier wird dout_en nicht direkt als reg-Variable deklariert; stattdessen wird sie über assign unter Verwendung zugehöriger Register zugewiesen
    assign dout_en       = dout_en_r;

endmodule

Die entsprechende Testbench-Beschreibung lautet wie folgt, mit hinzugefügten Datei-Lese-/Schreibanweisungen:

Beispiel

`timescale 1ns/1ps

   //============== (1) ==================
   //Signaldeklaration
module test ;
    reg          clk;
    reg          rstn ;
    reg [1:0]    din ;
    reg          din_en ;
    wire [7:0]   dout ;
    wire         dout_en ;

    //============== (2) ==================
    //Takterzeugung
    real         CYCLE_200MHz = 5 ; //
    always begin
        clk = 0 ; #(CYCLE_200MHz/2) ;
        clk = 1 ; #(CYCLE_200MHz/2) ;
    end

    //============== (3) ==================
    //Reset-Erzeugung
    initial begin
        rstn      = 1'b0 ;
        #8 rstn      = 1'b1 ;
    end

    //============== (4) ==================
    //Motivation
    int          fd_rd ;
    reg [7:0]    data_in_temp ;  //zur Selbstprüfung
    reg [15:0]   read_temp ;     //8bit-ASCII-Daten, 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 ;

        //Daten aus Datei lesen
        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

        //Daten stoppen
        @(posedge clk) ;  //(4.5)
        #2 din_en = 1'b0 ;
    end

    //Task öffnen
    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 --- Datei konnte nicht geöffnet werden: %s", file_dir_name);
        end
        else begin
            $display("--- iii --- %s wurde erfolgreich geöffnet.", file_dir_name);
        end
    endtask

    //============== (5) ==================
    //Modulinstanziierung
    data_consolidation u_data_process
    (
      .clk              (clk),
      .rstn             (rstn),
      .din              (din),
      .din_en           (din_en),
      .dout             (dout),
      .dout_en          (dout_en)
     );

    //============== (6) ==================
    //automatische Prüfung
    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) ==================
    //Simulationsende
    always begin
        #100;
        if ($time >= 10000)  begin
            if (!err_cnt) begin
                $display("-------------------------------------");
                $display("Datenverarbeitung ist OK!!!");
                $display("-------------------------------------");
            end
            else begin
                $display("-------------------------------------");
                $display("Fehler tritt bei der Datenverarbeitung auf!!!");
                $display("-------------------------------------");
            end
            #1 ;
            $finish ;
        end
    end

endmodule // test

Die Simulationsergebnisse sind wie folgt. Wie aus der Abbildung ersichtlich ist, erfüllt das Design der Datenintegrationsfunktion die Anforderungen:

Detaillierte Testbench-Analyse

1) Signaldeklaration

Beim Deklarieren eines Testbench-Moduls müssen im Allgemeinen keine Ports deklariert werden, da sich die Stimulussignale normalerweise innerhalb des Testbench-Moduls befinden und es keine externen Signale gibt.

Die deklarierten Variablen sollten alle den Ports des zu testenden Moduls entsprechen. Natürlich müssen die Variablen nicht dieselben Namen wie die Ports des zu testenden Moduls haben. Variablen, die den Eingangsports des zu testenden Moduls entsprechen, sollten jedoch als reg-Typ deklariert werden, wie clk, rstn usw., und Variablen, die den Ausgangsports entsprechen, sollten als wire-Typ deklariert werden, wie dout, dout_en.

2) Takterzeugung

Es gibt viele Möglichkeiten, einen Takt zu erzeugen; beispielsweise können auch die folgenden beiden Erzeugungsmethoden als Referenz dienen.

Beispiel

initial clk = 0 ;
always #(CYCLE_200MHz/2) clk = ~clk;

initial begin
    clk = 0 ;
    forever begin
        #(CYCLE_200MHz/2) clk = ~clk;
    end
end      

Es ist zu beachten, dass bei Verwendung der Invertierungsmethode zur Takterzeugung dem clk-Register ein Anfangswert zugewiesen werden muss.

Wenn zur Angabe von Zeitverzögerungen die Parameter-Methode verwendet wird, sollte dieser Parameter nicht als parameter-Typ deklariert werden, wenn der Verzögerungsparameter eine Gleitkommazahl ist. Beispielsweise hat im Beispiel die Variable CYCLE_200MHz den Wert 2.5. Wenn ihr Variablentyp parameter ist, beträgt die schließlich erzeugte Taktperiode wahrscheinlich 4ns. Natürlich muss auch die Präzision von timescale erhöht werden; Einheit und Präzision dürfen nicht gleich sein, da sonst der Bruchteil der Zeitverzögerungszuweisung nicht wirksam wird.

3) Reset-Erzeugung

Die Reset-Logik ist relativ einfach. Im Allgemeinen wird der Anfangswert auf 0 gesetzt und danach wird Reset nach einer kleinen Verzögerung auf 1 gesetzt.

Die meisten Simulationen hier verwenden einen Low-aktiven Reset.

4) Stimulus-Teil

Welche Art von Eingangssignalen der Stimulus-Teil erzeugen soll, wird entsprechend den Anforderungen des zu testenden Moduls entworfen.

In diesem Beispiel:

  • (4.1) Initialisieren Sie die Eingangssignale des zu testenden Moduls, um das Auftreten des unbekannten Werts X zu verhindern. Zur Erzeugung der Stimulusdaten müssen wir aus einer Datendatei lesen.
  • Bei (4.2) wird eine Task verwendet, um eine Datei zu öffnen. Solange die angegebene Datei existiert, kann ein von null verschiedenes Handle-Signal fp_rd erhalten werden. fp_rd gibt die Startadresse der Dateidaten an.
  • Die Operation bei (4.3) besteht darin, bis nach dem Reset zu warten, damit das System einen sicheren und stabilen testbaren Zustand hat.
  • Bei (4.4) beginnt es, Daten in einer Schleife zu lesen und Stimulus anzulegen. Das Senden von Daten auf der fallenden Flanke des Takts erfolgt, damit das zu testende Modul die Daten auf der steigenden Flanke besser abtasten kann.

Unter Verwendung der Systemaufgabe $fread wird die gelesene 16-Bit-Datenvariable über das Handle-Signal fd_rd in den Puffer read_temp eingespeist.

Der Screenshot der ersten paar Datenelemente in der Eingabedatendatei sieht wie folgt aus. Da $fread nur Binärdateien lesen kann, entspricht die erste Zeile der Eingabedatei dem ASCII-Code 330a. Um die Daten 3 in der Datei zu erhalten, sollten wir die Daten von Bit 9 bis Bit 8 der Variablen read_temp entnehmen.

Das Signal data_in_temp ist eine nachfolgende Integration des Eingabedatensignals. Später wird das Verifikationsmodul es als Referenz verwenden, um zu bestimmen, ob die Simulation normal verläuft und ob das Moduldesign korrekt ist.

  • Bei (4.5) dient die Entscheidung, die Dateneingabe nach einer Verzögerung von 2 Zyklen auf der steigenden Flanke des Takts zu stoppen, dazu, dass das zu testende Modul das letzte Datenfreigabesignal normal abtasten und die Daten korrekt integrieren kann.

Wenn die Datenmenge relativ klein ist, können Sie die Systemaufgabe $readmemh in Verilog verwenden, um hexadezimale Daten direkt Zeile für Zeile zu lesen. Wenn die Daten und das Format in der Datei data_in.dat unverändert bleiben, kann dieser Stimulus-Teil wie folgt beschrieben werden:

Beispiel

    reg [1:0]    data_mem [39:0] ;
    reg [7:0]    data_in_temp ;  //zur Selbstprüfung
    integer      k1 ;
    initial begin
        din_en    = 1'b0 ;
        din       = 'b0 ;
        $readmemh("../tb/data_in.dat", data_mem);
        wait (rstn) ;
        # CYCLE_200MHz ;

        //Daten aus Datei lesen
        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

        //Daten stoppen
        @(posedge clk) ;
        #2 din_en = 1'b0 ;
     end

5) Modulinstanziierung

Hier werden die am Anfang der Testbench deklarierten Signalvariablen verwendet, um das zu testende Modul zu instanziieren und zu verbinden.

6) Selbstprüfung

Wenn das Design relativ einfach ist, ist es durchaus möglich, anhand der Wellenformen der Eingangs- und Ausgangssignale festzustellen, ob das Design korrekt ist, und dieser Teil kann vollständig entfernt werden. Wenn viele Daten vorhanden sind, kann die Beobachtung mit bloßem Auge manchmal die Korrektheit des Designs nicht effektiv beurteilen. In diesem Fall erhöht das Hinzufügen eines Selbstprüfungsmoduls die Simulationseffizienz erheblich.

Im Beispiel, wenn das Datenausgangs-Enable dout_en aktiv ist, vergleichen wir die Ausgangsdaten dout mit den Referenzdaten read_temp (vom Stimulus-Teil erzeugt) und legen das Vergleichsergebnis in das Signal err_cnt. Schließlich können wir die Korrektheit des Designs intuitiv beurteilen, indem wir beobachten, ob das Signal err_cnt 0 ist.

Natürlich können wir, wie im Beispiel gezeigt, die Daten auch in eine entsprechende Datei schreiben und andere Methoden zum Vergleich verwenden.

7) Beenden der Simulation

Wenn wir den Teil zur Beendigung der Simulation nicht hinzufügen, läuft die Simulation unbegrenzt weiter, und zu lange Wellenformen sind manchmal unbequem zu analysieren. Verilog stellt die Systemaufgabe $finish bereit, um die Simulation zu stoppen.

Vor dem Stoppen der Simulation können die Ergebnisse der Selbstprüfung mit der Systemaufgabe $display im Terminal angezeigt werden.

Datei-Lese-/Schreiboptionen

Das Format der Systemaufgabe $fopen zum Öffnen einer Datei ist wie folgt:

fd = $fopen("<name_of_file>", "mode")

Ähnlich wie in der Sprache C ist die Bedeutung der Öffnungsmodus-Option "mode" wie folgt:

rÖffnet eine Textdatei schreibgeschützt, wobei nur das Lesen von Daten erlaubt ist.
wÖffnet eine Textdatei nur zum Schreiben, wobei nur das Schreiben von Daten erlaubt ist. Wenn die Datei existiert, wird der ursprüngliche Dateiinhalt gelöscht. Wenn die Datei nicht existiert, wird eine neue Datei erstellt.
aÖffnet eine Textdatei zum Anhängen und schreibt Daten am Ende der Datei. Wenn die Datei nicht existiert, wird eine neue Datei erstellt.
rbÖffnet eine Binärdatei schreibgeschützt, wobei nur das Lesen von Daten erlaubt ist.
wbÖffnet oder erstellt eine Binärdatei nur zum Schreiben, wobei nur das Schreiben von Daten erlaubt ist.
abÖffnet eine Binärdatei zum Anhängen und schreibt Daten am Ende der Datei.
r+Öffnet eine Textdatei zum Lesen und Schreiben, wobei sowohl Lesen als auch Schreiben erlaubt sind.
w+Öffnet oder erstellt eine Textdatei zum Lesen und Schreiben, wobei Lesen und Schreiben erlaubt sind. Wenn die Datei existiert, wird der ursprüngliche Dateiinhalt gelöscht. Wenn die Datei nicht existiert, wird eine neue Datei erstellt.
a+Öffnet eine Textdatei zum Lesen und Schreiben, wobei Lesen und Schreiben erlaubt sind. Wenn die Datei nicht existiert, wird eine neue Datei erstellt. Das Lesen der Datei beginnt am Anfang der Datei, und das Schreiben kann nur im Anhängemodus erfolgen.
rb+Öffnet eine binäre Textdatei zum Lesen und Schreiben, mit einer zu "r+" ähnlichen Funktionalität.
wb+Öffnet oder erstellt eine binäre Textdatei zum Lesen und Schreiben, mit einer zu "w+" ähnlichen Funktionalität.
ab+Öffnen Sie eine binäre Textdatei zum Lesen und Schreiben, mit einer Funktionalität ähnlich wie "a+".

Quellcode-Download

Herunterladen