לולאות for ב-Verilog: נפרשות בזמן הקומפילציה

הדומה לתוכנה

לולאת ה-for של Verilog היא העתק של זו של C:

for (i = 0; i < 8; i = i + 1) begin
    // body
end

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

ב-testbench זה מתנהג בדיוק כמו שהייתם מצפים מתוכנה. הסימולטור עובר על כל איטרציה בתורה:

module testbench_for;
    integer i;
    initial begin
        for (i = 0; i < 4; i = i + 1)
            $display("iteration i=%0d", i);
        $finish;
    end
endmodule

ארבע איטרציות, ארבע שורות פלט. בלי הפתעות.

ההפתעה מגיעה כששמים לולאת for בתוך קוד בר סינתזה.

הפרישה

לולאת for בבלוק always בר סינתזה לא הופכת ללולאה בזמן ריצה בחומרה. הסינתיסייזר פורש אותה בזמן ה-elaboration: הוא מרחיב את הלולאה ל-N עותקים של הגוף, כש-N הוא מספר האיטרציות:

module count_ones(
    input  wire [7:0] data,
    output reg  [3:0] count
);
    integer i;
    always @(*) begin
        count = 0;
        for (i = 0; i < 8; i = i + 1) begin
            if (data[i]) count = count + 1;
        end
    end
endmodule

module test;
    reg [7:0] d;
    wire [3:0] c;
    count_ones dut(.data(d), .count(c));

    initial begin
        d = 8'b0000_0000; #1 $display("data=%b count=%0d", d, c);
        d = 8'b1111_1111; #1 $display("data=%b count=%0d", d, c);
        d = 8'b1010_1100; #1 $display("data=%b count=%0d", d, c);
        d = 8'b0010_0001; #1 $display("data=%b count=%0d", d, c);
        $finish;
    end
endmodule

זה נראה כמו לולאה. בסימולציה, הסימולטור באמת עובר בלולאה על שמונה איטרציות. בסינתזה, הלולאה נפרשת לשמונה בדיקות מקביליות של data[0] עד data[7], שכולן קורות באותו זמן. הסינתיסייזר רואה:

count = 0;
if (data[0]) count = count + 1;
if (data[1]) count = count + 1;
if (data[2]) count = count + 1;
...
if (data[7]) count = count + 1;

…ואז הופך את הרצף לעץ מחברים. ההתנהגות בזמן ריצה היא "הסתכל על כל 8 הביטים בבת אחת וספור כמה מהם 1", במעבר צירופי אחד.

המשמעות: לולאת for ב-Verilog בר סינתזה אינה בחינם. לולאה של 64 איטרציות הופכת ל-64 עותקים של הגוף בחומרה. אם הגוף מורכב, בניתם זה עתה בלוק צירופי גדול. השתמשו בלולאות כש-N קטן (בין קומץ לכמה עשרות). במספרים גדולים יותר, בדרך כלל רוצים מונה מסונכרן לשעון ומכונת מצבים.

חובה גבולות קבועים

הסינתיסייזר יכול לפרוש את הלולאה רק אם הוא יודע את N בזמן ה-elaboration. כלומר, גבולות הלולאה חייבים להיות קבועים:

// Works - bound is constant
for (i = 0; i < 8; i = i + 1) ...

// Works - bound is a parameter
for (i = 0; i < WIDTH; i = i + 1) ...

// Doesn't synthesize - bound depends on a runtime signal
for (i = 0; i < dynamic_count; i = i + 1) ...

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

generate for מול for פרוצדורלי

מבנה נפרד אבל קשור הוא generate for, שמשתמש ב-genvar ונמצא מחוץ לבלוקים של always:

genvar i;
generate
    for (i = 0; i < 8; i = i + 1) begin : g
        bit_inverter inv(.x(in[i]), .y(out[i]));
    end
endgenerate

זה משכפל 8 מופעים של bit_inverter (מוסבר ב-יצירת מופעים של מודולים). זה מבני, אתם אומרים "צור 8 עותקים של תת המודול הזה", ולא התנהגותי.

הבחנה מהירה:

• for פרוצדורלי (בתוך always): פורש הוראות בתוך בלוק התנהגותי יחיד.
• for של generate (מחוץ ל-always): משכפל מבנים שלמים: מופעים, הוראות assign, בלוקים עם שם.

השתמשו במה שמתאים למה שאתם משכפלים.

איפה for מצטיין: פעולות על וקטורים

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

module reverse_bytes(
    input  wire [31:0] in,
    output reg  [31:0] out
);
    integer i;
    always @(*) begin
        for (i = 0; i < 32; i = i + 1) begin
            out[i] = in[31 - i];
        end
    end
endmodule

module test;
    reg  [31:0] x;
    wire [31:0] y;
    reverse_bytes dut(.in(x), .out(y));

    initial begin
        x = 32'hDEAD_BEEF; #1 $display("in=%h out=%h", x, y);
        x = 32'h0000_0001; #1 $display("in=%h out=%h", x, y);
        $finish;
    end
endmodule

32 איטרציות, כל אחת מבצעת השמה של ביט אחד: הרבה יותר קריא מכתיבה ידנית של 32 השמות. הסינתיסייזר פורש את זה בצורה נקייה.

while, repeat, forever

מעבר ל-for, יש ב-Verilog עוד שלושה מבני לולאה, בעיקר ל-testbenches:

// Run until a condition fails
while (~done) begin
    @(posedge clk);
    cycles = cycles + 1;
end

// Run N times - simpler than for when you don't need a counter
repeat (8) @(posedge clk);

// Run forever - clock generators, monitoring loops
always #5 clk = ~clk;
forever begin
    @(posedge clk);
    $display("count=%0d", count);
end

while, repeat ו-forever ניתנים לסינתזה רק במקרים צרים (בעיקר repeat עם מספר קבוע וגוף מסונכרן לשעון). ב-testbenches הם כלים שימושיים; ב-RTL בר סינתזה העדיפו for עם מונה ומכונת מצבים מפורשת.

for פרוצדורלי ב-testbenches

ב-testbench, לולאות for מתנהגות כמו בתוכנה. השתמשו בהן בחופשיות:

module sweep_test;
    reg [7:0] a, b;
    wire [8:0] sum;

    assign sum = a + b;

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            for (integer j = 0; j < 4; j = j + 1) begin
                a = i;
                b = j;
                #1 $display("%0d + %0d = %0d", a, b, sum);
            end
        end
        $finish;
    end
endmodule

לולאות מקוננות עוברות על כל צירוף של שתי כניסות של 2 ביטים. הסימולטור מריץ את האיטרציות לפי הסדר. אין דאגות של פרישה: testbenches לא עוברים סינתזה.

טעויות נפוצות

שימוש בלולאת for בקוד בר סינתזה עם גבול לא קבוע. הסינתיסייזר ידחה את זה. אם הגבול נקבע בזמן ריצה, בנו מונה ומכונת מצבים.

לשכוח שגוף הלולאה הופך לחומרה מקבילית. לולאה של 64 איטרציות עם מכפל בגוף היא 64 מכפלים מקביליים, כנראה לא מה שרציתם. ב-datapaths רחבים, בנו מכפל יחיד והזינו אותו באופן סדרתי.

ערבוב integer i ו-reg בשם i. אלה תחומים שונים; ה-integer גובר בתוך הלולאה. בחרו שמות ברורים כדי להימנע מהבלבול.

מה הלאה

עכשיו יש לכם את כל המבנים הפרוצדורליים ש-Verilog מציעה. הפרק הבא מחבר הכול לתבניות שמתכנני חומרה באמת משתמשים בהן: לוגיקה מסונכרנת לשעון, כלומר flip-flops, אוגרים ו-pipelines, ו-מכונות מצבים סופיות, הניב הסטנדרטי לכל בקר עם כמה מצבי פעולה.