Verilog wire מול reg: מתי להשתמש בכל אחד (עם דוגמאות)

שני שמות, תפקיד אחד

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

• אותות wire מוזנים מחוץ לבלוקים פרוצדורליים: על ידי פקודות assign, על ידי יציאות של תת-מודולים, או על ידי פורטי כניסה של המודול.
• אותות reg מוזנים בתוך בלוקים פרוצדורליים: initial או always.

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

wire: החיבור הרציף

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

module wires(input wire a, input wire b, output wire y, output wire z);
    // Driven by a continuous assignment.
    assign y = a & b;

    // Driven by a sub-module output - shown for completeness.
    // (the actual sub-module is omitted here)
    assign z = a | b;
endmodule

module test;
    reg a, b;
    wire y, z;

    wires dut(.a(a), .b(b), .y(y), .z(z));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            {a, b} = i[1:0];
            #1 $display("a=%b b=%b y=%b z=%b", a, b, y, z);
        end
        $finish;
    end
endmodule

שלושה דברים לשים לב אליהם:

• y ו-z מוצהרים כ-wire במודול, ושוב כ-wire ב-testbench.
• הם מוזנים על ידי assign, וזו צורת ההשמה הרציפה. הצד הימני של ה-= מחושב מחדש בכל פעם שאות כלשהו בו משתנה.
• אי אפשר לכתוב y = a & b בתוך בלוק always ולהשאיר את y כ-wire. הקומפיילר ידחה את זה.

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

reg: אחסון בתוך בלוק פרוצדורלי

reg הוא אות שמקבל ערך בתוך initial או always. השם הוא שריד מימיה הראשונים של השפה, כש-"reg" נשמע כמו "register". בשימוש המודרני reg הוא פשוט הטיפוס של כל אות שקוד פרוצדורלי כותב אליו.

module regs(input wire clk, input wire reset, output reg [3:0] count);
    always @(posedge clk) begin
        if (reset) count <= 0;
        else       count <= count + 1;
    end
endmodule

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

    regs dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

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

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

count הוא reg בתוך המודול (כי בלוק ה-always כותב אליו) ו-wire ב-testbench (כי פורט הפלט של ה-DUT מזין אותו). אותו אות, תפקידים שונים, וטיפוסים שונים בכל תחום.

למה "reg" לא תמיד אומר "רגיסטר"

זו מלכודת המתחילים הנפוצה ביותר. המודול הזה מצהיר על y כ-reg, אבל החומרה שמתקבלת מהסינתזה לא מכילה flip-flop:

module not_a_register(input wire a, input wire b, output reg y);
    always @(*) begin
        y = a & b;
    end
endmodule

module test;
    reg a, b;
    wire y;

    not_a_register dut(.a(a), .b(b), .y(y));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            {a, b} = i[1:0];
            #1 $display("a=%b b=%b y=%b", a, b, y);
        end
        $finish;
    end
endmodule

בלוק ה-always @(*) רגיש ל_כל_ שינוי בכניסה. הוא צירופי. כלי סינתזה מזהה את התבנית הזו ומפיק שער AND: בלי flip-flop, בלי שעון, רק לוגיקה. מילת המפתח reg היא דרישה תחבירית בלבד, כי y מקבל ערך בתוך always.

כדי לקבל flip-flop אמיתי, בלוק ה-always חייב להיות רגיש לקצה שעון:

always @(posedge clk) begin
    q <= d;
end

זו התבנית שאומרת לכלי הסינתזה "בבקשה תייצר flip-flop": רשימת רגישות מתוזמנת בשעון והשמה non-blocking. אותה מילת מפתח reg, חומרה שונה לגמרי. אנחנו מכסים את ההבחנה בבלוק always ובBlocking מול Non-blocking.

ההחלטה בפועל

בכל פעם שאתם מצהירים על אות, שאלו: איך אזין אותו?

• מזינים עם assign? → wire.
• מחברים לפורט פלט של תת-מודול? → wire.
• פורט כניסה של המודול? → wire. (כניסות הן תמיד wire.)
• מזינים מתוך initial או always? → reg.
• פורט פלט של המודול שמוזן על ידי קוד פרוצדורלי? → output reg.
• פורט פלט של המודול שמוזן על ידי assign? → output wire. (או פשוט output: כיוון לבדו הוא wire כברירת מחדל.)

עץ ההחלטות הזה מכסה כל מצב שתפגשו ב-Verilog רגילה.

התנגשויות בין מקורות הזנה

לאותות wire יכולים להיות בתיאוריה כמה מקורות הזנה. כך עובדים bus-ים של tri-state: כמה מודולים יכולים להזין את אותו wire, והלא פעילים עוברים לעכבה גבוהה (z). בלוגיקה רגילה, שתי פקודות assign שכותבות לאותו wire יוצרות התנהגות לא מוגדרת:

assign y = a;
assign y = b;   // BAD - y has two drivers

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

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

העדכון של SystemVerilog: logic

SystemVerilog (ההרחבה ש-Verilog התפתחה אליה) מוסיפה מילת מפתח אחת שמחליפה את שתיהן: logic. אות logic יכול להיות מוזן על ידי assign או על ידי בלוק פרוצדורלי, אבל לא בשניהם, והקומפיילר עוצר אתכם מלייצר בטעות באג של כמה מקורות הזנה.

module modern(input logic a, input logic b, output logic y);
    assign y = a ^ b;
endmodule

אם אתם מתחילים פרויקט מאפס והכלי שלכם תומך ב-SystemVerilog (העורך בדף הזה תומך, עם -g2012), שימוש ב-logic בכל מקום מפשט את הכללים. קבצי .v רגילים עדיין צריכים את ההפרדה בין wire/reg, ותמשיכו לראות את שני הסגנונות בשטח עוד הרבה זמן.

מה הלאה

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