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