Verilog if-else: לוגיקה מותנית בבלוקים פרוצדורליים

תחביר מוכר, מודל מנטלי שונה

if/else נראה בדיוק כמו ב-C:

if (condition) begin
    // ... statements ...
end else begin
    // ... statements ...
end

אבל הכללים שונים, כי Verilog היא לא תוכנה. שני דברים שכדאי לזכור:

1. if/else חי רק בתוך בלוק פרוצדורלי. אי אפשר לכתוב if עצמאי ברמת המודול.
2. מה ש-if/else הופך אליו בסינתזה תלוי בסוג הבלוק. בבלוק צירופי הוא הופך ל-multiplexer או ל-priority encoder. בבלוק מסונכרן לשעון הוא הופך ל-flip-flop עם לוגיקת עדכון מותנית.

בתוך בלוק צירופי

module max_of_three(
    input  wire [7:0] a,
    input  wire [7:0] b,
    input  wire [7:0] c,
    output reg  [7:0] max
);
    always @(*) begin
        if (a >= b && a >= c)
            max = a;
        else if (b >= c)
            max = b;
        else
            max = c;
    end
endmodule

module test;
    reg [7:0] a, b, c;
    wire [7:0] max;
    max_of_three dut(.a(a), .b(b), .c(c), .max(max));

    initial begin
        a = 8'd10; b = 8'd20; c = 8'd15; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        a = 8'd50; b = 8'd30; c = 8'd40; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        a = 8'd5;  b = 8'd5;  c = 8'd50; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        $finish;
    end
endmodule

הבלוק הצירופי always @(*) רץ מחדש בכל פעם ש-a, b או c משתנים. שרשרת ה-if/else בוחרת ענף אחד, מבצעת השמה ל-max, והבלוק מסתיים. מכיוון ש-max מקבל השמה תמיד (בכל מסלול יש השמה), הסינתיסייזר מייצר לוגיקה צירופית טהורה, בלי latch.

שימו לב ש-max מוצהר כ-reg למרות שאין flip-flop בחומרה. אותו כלל כמו תמיד: כל מה שמקבל השמה בתוך always חייב להיות reg.

מלכודת ה-latch

זה הבאג הנפוץ ביותר בקוד צירופי של מתחילים:

// WRONG - infers a latch
always @(*) begin
    if (enable)
        out = data;
    // no else! when `enable` is low, what does `out` do?
end

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

שתי דרכים לתקן:

// Fix 1: explicit else branch
module no_latch_1(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        if (enable) out = data;
        else        out = 8'd0;
    end
endmodule

// Fix 2: default assignment at the top
module no_latch_2(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        out = 8'd0;             // default first
        if (enable) out = data; // override if condition holds
    end
endmodule

module test;
    reg en;
    reg [7:0] d;
    wire [7:0] out1, out2;

    no_latch_1 u1(.enable(en), .data(d), .out(out1));
    no_latch_2 u2(.enable(en), .data(d), .out(out2));

    initial begin
        en = 0; d = 8'h55; #1 $display("en=%b d=%h out1=%h out2=%h", en, d, out1, out2);
        en = 1; d = 8'hAA; #1 $display("en=%b d=%h out1=%h out2=%h", en, d, out1, out2);
        $finish;
    end
endmodule

שתיהן מייצרות את אותה חומרה צירופית: mux של 2 ל-1. תבנית "ברירת מחדל בראש הבלוק" מתאימה יותר כשיש הרבה השמות מותנות לאותו אות.

בתוך בלוק מסונכרן לשעון

module counter_with_reset(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    output reg  [7:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 8'd0;
        else if (enable)  count <= count + 8'd1;
        // else: implicit hold (count keeps its value - that's what a flip-flop does)
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg enable = 0;
    wire [7:0] count;

    counter_with_reset dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  enable = 1;
        #50 enable = 0;
        #20 enable = 1;
        #30 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b enable=%b count=%0d", $time, reset, enable, count);
endmodule

שימו לב מה שונה מהמקרה הצירופי:

• הבלוק הוא always @(posedge clk): הטריטוריה של flip-flops.
• ההשמה משתמשת ב-<= (לא חוסמת).
• אין else למקרה של "לא reset ולא enable". זה בסדר. בבלוק מסונכרן לשעון, כששום ענף לא מופעל, ה-flip-flop פשוט מחזיק את הערך הקודם שלו, וזה בדיוק מה ש-flip-flop עושה פיזית. לא מוסק latch, כי האות כבר הוא אוגר.

זה המקום היחיד שבו השמטת else בטוחה. מחוץ לבלוקים מסונכרנים לשעון, תמיד טפלו בכל מסלול.

שרשרת else if: priority encoder

לשרשרת של הוראות else if יש עדיפות מובלעת: תנאים מוקדמים גוברים על מאוחרים:

module priority_encoder(
    input  wire [3:0] requests,
    output reg  [1:0] grant,
    output reg        any
);
    always @(*) begin
        any = |requests;
        if      (requests[0]) grant = 2'd0;
        else if (requests[1]) grant = 2'd1;
        else if (requests[2]) grant = 2'd2;
        else if (requests[3]) grant = 2'd3;
        else                  grant = 2'd0;
    end
endmodule

module test;
    reg [3:0] req;
    wire [1:0] grant;
    wire any;
    priority_encoder dut(.requests(req), .grant(grant), .any(any));

    initial begin
        req = 4'b0000; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b0010; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b1010; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b1111; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        $finish;
    end
endmodule

ל-requests[0] יש העדיפות הגבוהה ביותר: אם הוא דולק, ה-grant הוא 0 בלי קשר למה שהביטים הגבוהים יותר עושים. הסינתיסייזר הופך את השרשרת ל-mux מדורג: בודק קודם את ביט 0, אחר כך את ביט 1, ביט 2 וביט 3. כל רמה מוסיפה קצת השהיה.

אם התנאים מוציאים זה את זה, למשל בפענוח כניסת one-hot, משפט case (המסמך הבא) מייצר חומרה שטוחה ומהירה יותר משרשרת else if. השתמשו בצורת ה-case כשאין דרישת עדיפות אמיתית.

if בלי else בקוד מסונכרן לשעון

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

always @(posedge clk) begin
    if (load) target <= incoming;
    // no else: when load is low, target keeps its value
end

זה אוגר עם load enable. רוב אוגרי ה-pipeline, המונים ואוגרי התצורה משתמשים בתבנית הזו.

begin/end והוראות בודדות

כמו ב-C, אפשר להשמיט את begin/end בהוראה בודדת:

if (a) out = 1;
else   out = 0;

לכל מה שיותר מהוראה אחת, השתמשו בבלוק:

if (a) begin
    out = 1;
    flag = 1;
end else begin
    out = 0;
    flag = 0;
end

שתי התבניות מתערבבות בחופשיות. מדריכי סגנון בדרך כלל ממליצים להשתמש תמיד ב-begin/end, כדי שהוספת הוראה שנייה לא תכאב.

מה הלאה

המסמך הבא, משפט case, עוסק ב-case, הכלי הנכון לפענוח רב כיווני (מכונות מצבים, ניתוב opcodes, טבלאות ROM). אחריו מגיעות לולאות for, ששונות בדקות מבנות הדודות שלהן בתוכנה, כי הן נפרשות בזמן ה-elaboration.