Verilog case: פענוח רב כיווני כמו שצריך

ההסתעפות הרב כיוונית

case הוא מבנה הניתוב השטוח של Verilog. נותנים לו ביטוי, והוא בוחר את הענף המתאים:

case (expression)
    pattern_1: statement_1;
    pattern_2: statement_2;
    pattern_3: begin
        statement_3a;
        statement_3b;
    end
    default: default_statement;
endcase

המבנה דומה ל-switch של C, אבל:

• אין break: כל ענף מסתיים באופן מובלע כשמתחיל הענף הבא.
• תבניות יכולות להיות וקטורים, לא רק מספרים שלמים.
• הסינתיסייזר הופך את כל המבנה ל-mux שטוח (או למפענח one-hot כשהתבניות מאפשרות זאת).

דוגמה מלאה: mux של 4 ל-1

module mux4(
    input  wire [1:0] sel,
    input  wire [7:0] in0, in1, in2, in3,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            2'd0: out = in0;
            2'd1: out = in1;
            2'd2: out = in2;
            2'd3: out = in3;
            default: out = 8'bx;
        endcase
    end
endmodule

module test;
    reg [1:0] sel;
    wire [7:0] out;
    wire [7:0] a = 8'hA0, b = 8'hB0, c = 8'hC0, d = 8'hD0;

    mux4 dut(.sel(sel), .in0(a), .in1(b), .in2(c), .in3(d), .out(out));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            sel = i[1:0];
            #1 $display("sel=%0d out=%h", sel, out);
        end
        $finish;
    end
endmodule

בגוף ה-case יש ארבע תבניות מפורשות ועוד default. הסינתיסייזר רואה כניסה של 2 ביטים שממופה לאחד מארבעה ערכים, ומפיק multiplexer של 4 ל-1. נקי, שטוח ומהיר.

למה צריך default

ב-case צירופי, השמטת default היא אותה מלכודת כמו if בלי else: כל ערך כניסה שלא הותאם משאיר את out בלי השמה, והסינתיסייזר מסיק latch.

ב-sel של 2 ביטים, התבניות שלמעלה מכסות את כל ארבעת הערכים האפשריים, כך שבתיאוריה default מיותר. בפועל:

1. הסינתיסייזר לא תמיד מוכיח שהמקרים ממצים.
2. הבורר עשוי להיות x או z בסימולציה, ואז הוא לא מתאים ל_אף_ מקרה מפורש.
3. הוספת מקרה חדש בהמשך עלולה להשאיר את התנהגות ברירת המחדל לא מוגדרת.

תמיד כתבו default. במכונות מצבים ובלוגיקת mux שבהן ידוע שברירת המחדל לא ניתנת להשגה, השמה של 'x:

default: out = 8'bx;

…אומרת לסינתיסייזר "זה don't-care, בצע אופטימיזציה בחופשיות", ומציגה x אדום בוהק בסימולציה אם המקרה הבלתי אפשרי בכל זאת מתרחש. כך מקבלים את הטוב משני העולמות.

מכונת מצבים בתוך case

השימוש הקלאסי ב-case הוא לוגיקת המעברים בין מצבים של מכונת מצבים סופית:

module traffic_light(
    input  wire       clk,
    input  wire       reset,
    output reg  [1:0] light    // 00=red, 01=yellow, 10=green
);
    localparam RED    = 2'd0;
    localparam GREEN  = 2'd1;
    localparam YELLOW = 2'd2;

    reg [1:0] state;
    reg [3:0] timer;

    always @(posedge clk) begin
        if (reset) begin
            state <= RED;
            timer <= 4'd0;
        end else if (timer == 4'd0) begin
            case (state)
                RED:    begin state <= GREEN;  timer <= 4'd6; end
                GREEN:  begin state <= YELLOW; timer <= 4'd2; end
                YELLOW: begin state <= RED;    timer <= 4'd5; end
                default: begin state <= RED;   timer <= 4'd0; end
            endcase
        end else begin
            timer <= timer - 4'd1;
        end
    end

    always @(*) light = state;
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [1:0] light;
    traffic_light dut(.clk(clk), .reset(reset), .light(light));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #200 $finish;
    end

    always @(posedge clk)
        $display("t=%0t light=%0d", $time, light);
endmodule

הבלוק case (state) הוא לוגיקת המעברים. כל ענף מחליט מה המצב הבא וכמה זמן להישאר בו. כאן default לא ניתן להשגה (אנחנו מכסים את RED/GREEN/YELLOW באופן ממצה במרחב של 2 ביטים), אבל הוא שם כרשת ביטחון: אם state הופך איכשהו ל-2'd3, מכונת המצבים חוזרת בצורה נקייה ל-RED במקום ליצור latch.

מכונות מצבים סופיות מעמיק בתבנית הזו.

כמה תבניות לענף אחד

אפשר לרשום כמה תבניות שחולקות הוראה אחת, מופרדות בפסיקים:

case (opcode)
    4'h0, 4'h1, 4'h2: result = a + b;
    4'h3, 4'h4:       result = a - b;
    4'h8:             result = a & b;
    default:          result = 8'd0;
endcase

כאן שני opcodes שמשמעותם "חיסור", ושלושה שמשמעותם "חיבור". הסינתיסייזר מחבר את התבניות ב-OR עבור המשווה.

casez ו-casex: התאמת don't-care

לפעמים רוצים להתאים תבנית שחלק מהביטים שלה לא מוגדרים, למשל "כל opcode שמתחיל ב-010":

casez (opcode)
    8'b010?_????: instruction = ALU_OP;
    8'b110?_????: instruction = LOAD_OP;
    8'b1110_????: instruction = JUMP_OP;
    default:      instruction = UNKNOWN;
endcasez

casez מתייחס ל-? (ול-z) בתבנית כאל don't-care. כל ? מתאים ל-0 או ל-1. שימושי לפענוח פורמטים של הוראות שבהם חלק ממיקומי הביטים לא בשימוש במחלקות opcode מסוימות.

casex מרחיב את זה ומתייחס גם ל-x כאל don't-care. casex מסוכן, כי אותות לא מאותחלים (שהם x בסימולציה) מתאימים ל_כל_ מקרה ויוצרים התנהגות מפתיעה. רוב מדריכי הסגנון המודרניים ממליצים על casez ואוסרים את casex.

ב-SystemVerilog יש גם case inside, שהיא הגרסה הנקייה מכולן: היא מקבלת טווחים ורשימות. אבל Verilog רגיל נעצר ב-casez.

case מול שרשרת if/else if

שני המבנים יכולים לבטא החלטות רב כיווניות, אבל הם עוברים סינתזה לחומרה שונה:

• case הוא ניתוב שטוח. הסינתיסייזר יכול לייצר מפענח one-hot, עץ mux מאוזן או מבנים שטוחים אחרים. זמן חישוב קבוע.
• if/else if הוא שרשרת עדיפויות. הסינתיסייזר מייצר מפל שבו כל רמה מוסיפה השהיה. איטי יותר באופן לוגריתמי.

מבחינה פונקציונלית הם חופפים. מבחינת סגנון: השתמשו ב-case בכל פעם שהתנאים עוסקים בערך של ביטוי יחיד. השתמשו ב-if/else if כשיש עדיפות אמיתית או כשהתנאים עוסקים באותות שונים.

// Better as case:
if      (sel == 2'd0) out = a;
else if (sel == 2'd1) out = b;
else if (sel == 2'd2) out = c;
else                  out = d;

// Better as if/else if:
if      (urgent_event)  next_state = HANDLE_URGENT;
else if (timer_expired) next_state = TIMEOUT;
else if (data_ready)    next_state = PROCESS;
else                    next_state = state;

שלושת התנאים הראשונים שואלים כולם "מה הערך של sel?", ולכן case נקרא טבעי יותר ועובר סינתזה שטוחה יותר. שלושת הבאים הם אירועים בלתי תלויים עם עדיפות ברורה, ולכן if/else if מתאים יותר.

מה הלאה

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