אופרטורים ב-Verilog: אריתמטיקה, השוואה, לוגיקה ותנאי

מה "אופרטור" אומר ב-Verilog

אופרטורים מקבלים ביטויים שנושאים אותות ומפיקים ביטויים חדשים שנושאים אותות. a + b הוא חומרה: הסינתיסייזר הופך אותו למחבר. a == b הוא חומרה: הוא בונה משווה. שום דבר מזה אינו "קוד שרץ"; הכול הוא "מעגלים שהאופרטור מתאר".

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

אריתמטיקה: + - * / %

module arithmetic;
    initial begin
        $display("17 +  5 = %0d", 17 + 5);
        $display("17 -  5 = %0d", 17 - 5);
        $display("17 *  5 = %0d", 17 * 5);
        $display("17 /  5 = %0d", 17 / 5);   // integer division: 3
        $display("17 %% 5 = %0d", 17 % 5);   // modulo: 2
        $display("-3 *  4 = %0d", -3 * 4);   // works with signed
        $finish;
    end
endmodule

שלושה דברים שכדאי לדעת:

1. חילוק הוא חילוק שלמים. 7/2 הוא 3, לא 3.5. ל-Verilog אין טיפוס float (טוב, יש real, אבל הוא לסימולציה בלבד).
2. חילוק ושארית יקרים בחומרה. /4 זה בסדר (הסינתיסייזר הופך אותו להזזה ימינה), אבל /n עם n שמשתנה בזמן ריצה בונה מחלק רב מחזורי שכמעט אף פעם לא תרצו.
3. גלישה מתגלגלת. חיבור של שני ערכים בלי סימן של N ביטים שחורג מ-N ביטים נקטם ל-N ביטים. אם רוצים ללכוד את הנשא, מצהירים על התוצאה ברוחב של ביט אחד יותר:

wire [7:0] a, b;
wire [8:0] sum = a + b;   // 9-bit sum captures carry out

השוואה: == != < > <= >=

module comparison;
    initial begin
        $display("5 ==  5 = %b", 5 == 5);
        $display("5 !=  3 = %b", 5 != 3);
        $display("5 <   3 = %b", 5 < 3);
        $display("5 >=  5 = %b", 5 >= 5);

        // Watch out: comparing with x produces x, not 0
        $display("1'bx == 1'b0 = %b", 1'bx == 1'b0);   // x
        $display("1'bx === 1'b0 = %b", 1'bx === 1'b0); // 0

        $finish;
    end
endmodule

כל ששת אופרטורי ההשוואה מחזירים תוצאה של ביט יחיד: 1 אם אמת, 0 אם שקר, x אם באחד האופרנדים יש ביט x או z. כדי לטפל במקרה של x/z, פנו ל-=== ול-!== (אופרטורי ה-case equality) שמוסברים ב-ערכי X ו-Z.

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

לוגיקה: && || !

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

module logical;
    initial begin
        $display("(5 > 3) && (2 < 4) = %b", (5 > 3) && (2 < 4));
        $display("(5 > 3) || (2 > 4) = %b", (5 > 3) || (2 > 4));
        $display("!(5 > 3)           = %b", !(5 > 3));

        // Logical on multi-bit values: anything nonzero is "true"
        $display("4'b1100 && 4'b0011 = %b", 4'b1100 && 4'b0011);   // 1
        $display("4'b1100 || 4'b0000 = %b", 4'b1100 || 4'b0000);   // 1
        $finish;
    end
endmodule

ההבחנה הקריטית שצריך להפנים: && לוגי אינו & ביט אחר ביט.

4'b1100 && 4'b0011   // 1 (both are non-zero, logical AND is true)
4'b1100 &  4'b0011   // 4'b0000 (no bit positions are 1 in both)

אותו דבר לגבי || מול |. השתמשו באופרטורים לוגיים בתנאי if ובפרדיקטים של ?:; השתמשו ב-bitwise כשרוצים שכל מיקום ביט יעבור AND/OR באופן עצמאי.

&& ו-|| מבצעים short-circuit במובן של C: צד ימין לא מחושב אם התוצאה כבר נקבעה על ידי צד שמאל. זה חשוב ב-testbenches שבודקים מצביעים או קריאות לפונקציות; זה לעיתים רחוקות משנה ב-RTL בר סינתזה, שבו הכול קורה במקביל בכל מקרה.

האופרטור המותנה: ?:

האופרטור התלת מקומי הוא החבר הכי טוב שלכם לבניית muxes וביטויים מותנים:

module muxes;
    wire [3:0] a = 4'hA;
    wire [3:0] b = 4'hB;
    wire sel;

    // 2-to-1 mux:
    wire [3:0] out = sel ? a : b;

    // 4-to-1 mux as a chain of ?:
    reg [1:0] sel4;
    wire [3:0] in0, in1, in2, in3;
    wire [3:0] out4 = (sel4 == 2'd0) ? in0
                    : (sel4 == 2'd1) ? in1
                    : (sel4 == 2'd2) ? in2
                    : in3;

    initial begin
        $display("a=%h b=%h out=%h",  a, b, out);
        $finish;
    end
endmodule

התבנית cond ? a : b היא בחומרה multiplexer של 2 ל-1 עם בורר של ביט אחד. שרשור שלהם בסדר לבחירות של 3 ו-4 כיוונים, אבל מעבר לזה משפט case (מוסבר ב-משפט case) קריא הרבה יותר.

האופרטור ?: הוא גם הדרך הסטנדרטית לתת לאוגר ערך ברירת מחדל שדורסים רק לפעמים:

next_value = update ? new_data : next_value;

כללי רוחב: המלכודת של המתחילים

כללי הרוחב של Verilog לאופרטורים אריתמטיים ידועים כמפתיעים. הגרסה הקצרה:

• הרוחב של התוצאה הוא המקסימום של רוחבי הכניסות.
• אם התוצאה מושמת למשהו רחב יותר, היא מורחבת באפסים (או מורחבת סימן אם היא עם סימן).
• הרוחב של חישובי ביניים הוא גם רוחב התוצאה, כלומר הגלישה קורית כבר בחישוב הביניים.

module width_trap;
    reg [7:0]  a, b;
    reg [15:0] product;

    initial begin
        a = 8'd200;
        b = 8'd200;

        // a * b "should" be 40000 (fits in 16 bits)
        // but the multiply happens at 8 bits, overflows, then assigns
        product = a * b;
        $display("8-bit *: product = %0d (expected 40000)", product);

        // Fix: cast one operand to wider before multiplying
        product = {8'b0, a} * b;
        $display("widened: product = %0d", product);

        $finish;
    end
endmodule

הכפל הראשון גולש כי רוחבי שני האופרנדים הם 8 ביטים, ולכן רוחב התוצאה הוא 8 ביטים, ו-40000 לא נכנס. השני עובד כי הרחבנו את a במפורש לפני הכפל.

טכניקות התיקון:

• השתמשו באופרטור השרשור {8'b0, a} כדי להרחיב באפסים.
• השתמשו ב-$unsigned(a) או ב-$signed(a) כדי להשפיע על הפרשנות.
• כשיש ספק, המירו ביטויי ביניים לרוחבים גדולים יותר.

קדימות אופרטורים

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

• *, /, % נקשרים חזק יותר מ-+, -.
• השוואה נקשרת חזק יותר מאופרטורים לוגיים (&&, ||).
• לאופרטור המותנה ?: יש קדימות נמוכה מאוד: בביטויים גדולים יותר בדרך כלל צריך סוגריים סביב הענפים שלו.
• כשיש ספק, שימו סוגריים. הסימולטור לא גובה לפי תו.

out = (mode == 2'd0) ? a + b : a - b;   // clearer with parens

מה הלאה

כיסיתם את כל האופרטורים שנראים כמו בני הדודים שלהם בתוכנה. המסמך הבא, Bitwise ו-Reduction, עוסק באופרטורים שאין להם מקבילה ישירה בתוכנה: AND/OR/XOR לכל ביט, וצורות ה-reduction שמכווצות וקטור שלם לביט יחיד.