Verilog testbench למתחילים: איך בודקים מודול

מה testbench הוא בעצם

testbench הוא פשוט מודול Verilog. ההבדל ממודול בר סינתזה הוא במה שיש בתוכו:

• אין לו פורטים: הוא הראש של היררכיית הסימולציה.
• הוא יוצר מופע של התכנון הנבדק.
• הוא מזין את הכניסות של ה-DUT מבלוקים של initial ו-always.
• הוא צופה בפלטים של ה-DUT עם $display, $monitor, או על ידי שמירת VCD.
• הוא מסיים את הסימולציה עם $finish.

זו כל העבודה. אין מילת מפתח מיוחדת של "testbench": מזהים testbench לפי מה שהוא עושה.

השלד הסטנדרטי

// Design under test: a tiny module we'll test.
module adder(
    input  wire [7:0] a,
    input  wire [7:0] b,
    output wire [8:0] sum
);
    assign sum = a + b;
endmodule

// Testbench: the rest of this file.
module test;
    // -----------------------------------------------------------------
    // 1. Signals to drive the DUT and observe its outputs.
    // -----------------------------------------------------------------
    reg  [7:0] a;
    reg  [7:0] b;
    wire [8:0] sum;

    // -----------------------------------------------------------------
    // 2. Instantiate the DUT.
    // -----------------------------------------------------------------
    adder dut(.a(a), .b(b), .sum(sum));

    // -----------------------------------------------------------------
    // 3. Stimulus + lifecycle.
    // -----------------------------------------------------------------
    initial begin
        $dumpfile("dump.vcd");
        $dumpvars(0, test);

        // Drive some interesting input combinations.
        a = 8'd0;   b = 8'd0;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd1;   b = 8'd2;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd200; b = 8'd100; #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'hFF;  b = 8'h01;  #1 $display("%h + %h = %h",   a, b, sum);

        $finish;
    end
endmodule

זו כל התבנית. חמישה חלקים, קל להעתיק, קל להתאים.

ל-DUTs צירופיים (כמו המחבר) לא צריך שעון. ל-DUTs סדרתיים כן, וזו השכבה הבאה.

יצירת שעון ל-DUTs סדרתיים

כשל-DUT יש כניסת clk, ה-testbench צריך לייצר שעון. השורה הסטנדרטית:

reg clk = 0;
always #5 clk = ~clk;

היא הופכת את clk כל 5 יחידות זמן. כל היפוך הוא חצי ממחזור השעון, ולכן המחזור המלא הוא 10 יחידות (מחזור אחד = גבוה ל-5 ונמוך ל-5). אם ה-timescale שלכם הוא 1ns / 1ps (ברירת המחדל ברוב הסימולטורים), זה שעון של 100 MHz.

בחרו את חצי המחזור לפי מה שרוצים למדל. לשעון של 10 MHz באותו timescale, השתמשו ב-#50. לשעון של 200 MHz, ב-#2.5 (או שנו את ה-timescale).

רצף reset

תכנונים סינכרוניים צריכים reset שמוחזק גבוה כמה מחזורים אחרי זמן 0, ואז משוחרר. הצורה המקובלת:

reg reset = 1;     // start asserted

initial begin
    // Hold reset for a few clocks.
    #20 reset = 0;
end

זה משאיר את reset גבוה עד זמן 20, ואז מוריד אותו. עד ש-reset יורד, השעון כבר עבר כמה מחזורים, כל flip-flop לכד את ערך ה-reset, והתכנון במצב ידוע.

ל-reset פעיל בנמוך (reset_n במקום reset), הופכים את הערך ההתחלתי:

reg reset_n = 0;   // active-low: 0 means asserted

initial begin
    #20 reset_n = 1;
end

testbench סדרתי מלא

שילוב של שעון, reset וגירוי:

module counter(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset)       count <= 4'd0;
        else if (enable) count <= count + 4'd1;
    end
endmodule

module test;
    // -- DUT signals --
    reg  clk = 0;
    reg  reset = 1;
    reg  enable = 0;
    wire [3:0] count;

    // -- DUT instance --
    counter dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    // -- Clock generator (10-unit period) --
    always #5 clk = ~clk;

    // -- Stimulus --
    initial begin
        $dumpfile("dump.vcd");
        $dumpvars(0, test);

        #20 reset = 0;        // release reset after 2 cycles
        #5  enable = 1;       // start counting
        #80 enable = 0;       // pause
        #20 enable = 1;       // resume
        #20 $finish;          // total simulation: ~145 units
    end

    // -- Monitoring on every rising edge --
    always @(posedge clk) begin
        $display("t=%0t reset=%b enable=%b count=%0d",
                 $time, reset, enable, count);
    end
endmodule

זה testbench מלא למונה של 4 ביטים. לחצו Run ותראו את המונה יוצא מ-reset, סופר למעלה כשהוא מאופשר, נעצר כש-enable יורד, ממשיך כשהוא עולה, ואז נעצר.

שלושה דברים שכדאי לשים לב אליהם במבנה:

1. שלושה מוקדי פעילות נפרדים: מחולל השעון (always אחד), הגירוי (initial אחד), והמעקב (always נוסף). לכל אחד תפקיד אחד.
2. ההשהיות # בבלוק הגירוי נמדדות ביחידות זמן, לא במחזורי שעון. אם מחזור השעון הוא 10 יחידות, אז #10 הוא בדיוק מחזור אחד. יש testbenches שמשתמשים במקום זאת ב-@(posedge clk), שמקדם מחזור אחד בלי קשר לאורך המחזור.
3. המעקב משתמש ב-$display מתוך בלוק always @(posedge clk). זה מדפיס בכל מחזור. לפלט מתוחכם יותר, עברו ל-$monitor (מוסבר בהמשך).

גירוי לפי מחזורים

לפעמים "חכו N מחזורים" נקרא טוב יותר מ"חכו N יחידות זמן":

initial begin
    @(posedge clk);     // wait for next clock edge
    reset = 0;

    repeat (5) @(posedge clk);   // wait 5 more cycles
    enable = 1;

    repeat (8) @(posedge clk);
    enable = 0;

    repeat (10) @(posedge clk);
    $finish;
end

@(posedge clk) חוסם עד הקצה העולה הבא של השעון. repeat (N) @(posedge clk); מחכה N מחזורים. הסגנון הזה לא תלוי באורך מחזור השעון: אם משנים את תדר השעון, הגירוי עדיין עושה את אותו הדבר במונחי מחזורים.

ב-testbenches ראשונים, השהיות # פשוטות יותר. ב-testbenches של ייצור שעשויים לרוץ בכמה מהירויות שעון, הסגנון לפי מחזורים בטוח יותר.

בדיקות שבודקות את עצמן

ה-testbench עד עכשיו מדפיס מה קרה, ומשאיר לכם לקרוא את הפלט. testbench שבודק את עצמו בודק את הפלט ומדווח הצלחה או כישלון:

initial begin
    #1;
    a = 10; b = 20;
    #1;
    if (sum !== 30) begin
        $display("FAIL: 10 + 20 = %0d (expected 30)", sum);
        $finish;
    end
    a = 250; b = 5;
    #1;
    if (sum !== 255) begin
        $display("FAIL: 250 + 5 = %0d (expected 255)", sum);
        $finish;
    end

    $display("PASS");
    $finish;
end

השתמשו ב-!== (אופרטור ה-case inequality) ליתר ביטחון: הוא לא מחזיר x כשבאחד האופרנדים יש ביטים לא ידועים. התבנית: מזינים כניסות, מחכים שהדברים יתייצבו, משווים לציפייה, ומדווחים הצלחה או כישלון.

בדיקה עצמית היא בעלת ערך רב בחבילות רגרסיה: אלפי בדיקות יכולות לרוץ בלי השגחה, ורק כישלונות דורשים תשומת לב.

מה הלאה

עכשיו יש לכם צורת testbench שמספיקה לכל מודול. המסמכים הבאים עוסקים בכלים שנכנסים לתוך ה-testbench: Display ו-Monitor לפלט טקסט עשיר יותר, Dumpfile ו-VCD לדיבוג גרפי עם waveforms, ו-Timescale והשהיות לשליטה מדויקת על הקשר בין זמן הסימולציה לזמן אמיתי.