אופרטורי Bitwise ו-Reduction ב-Verilog

שני תפקידים לאותו סימן

&, |, ^ והאחים ההפוכים שלהם מופיעים בשתי צורות שונות:

• צורה בינארית (שני אופרנדים): a & b, פעולה ביט אחר ביט בין וקטורים באותו רוחב.
• צורה אונרית (אופרנד אחד): &a, צמצום של כל הביטים של a לביט יחיד.

הקומפיילר מבחין ביניהן לפי מספר האופרנדים. המוסכמה המקובלת היא לקרוא לצורה הבינארית "אופרטורי bitwise" ולצורה האונרית "אופרטורי reduction".

Bitwise: ביט אחד בכל פעם

module bitwise;
    wire [7:0] a = 8'b1100_1010;
    wire [7:0] b = 8'b0101_1100;

    initial begin
        $display("a    = %b", a);
        $display("b    = %b", b);
        $display("a & b = %b", a & b);   // bitwise AND
        $display("a | b = %b", a | b);   // bitwise OR
        $display("a ^ b = %b", a ^ b);   // bitwise XOR
        $display("~a    = %b", ~a);      // bitwise NOT (one operand)
        $display("a ~^ b = %b", a ~^ b); // bitwise XNOR
        $finish;
    end
endmodule

הסט המלא:

שימו לב ש-~&, ~|, ~^ נכתבים עם הטילדה קודם והאופרטור אחריה. הם טוקן אחד, בלי רווח ביניהם.

כשלשני האופרנדים יש רוחב שונה, הצר מביניהם מורחב באפסים בצד הביטים העליונים כדי להשתוות. אם רוצים הרחבת סימן, משתמשים במפורש באופרנדים עם סימן בעזרת $signed().

Reduction: מהרבה ביטים לאחד

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

module reduction;
    wire [7:0] data1 = 8'b1111_1111;
    wire [7:0] data2 = 8'b0000_0001;
    wire [7:0] data3 = 8'b0101_0101;
    wire [7:0] data4 = 8'b0000_0000;

    initial begin
        $display("data = %b   &data  |data  ^data  $isunknown", data1);
        $display("       %b      %b     %b     %b", data1, &data1, |data1, ^data1);
        $display("       %b      %b     %b     %b", data2, &data2, |data2, ^data2);
        $display("       %b      %b     %b     %b", data3, &data3, |data3, ^data3);
        $display("       %b      %b     %b     %b", data4, &data4, |data4, ^data4);
        $finish;
    end
endmodule

מה כל אחד אומר:

• &data מחזיר 1 אם כל הביטים של data הם 1, אחרת 0. שימושי לבדיקות "האם הכול אחדות?".
• |data מחזיר 1 אם ביט כלשהו של data הוא 1, אחרת 0. שימושי לבדיקות "האם זה שונה מאפס?".
• ^data מחזיר את ה-parity, כלומר XOR של כל הביטים. 1 אם מספר האחדות אי זוגי, 0 אם זוגי.
• ~&data, ~|data, ~^data הם ההיפוכים של אלה.

תראו אותם בכל מקום בקוד אמיתי:

wire empty       = ~|fifo_count;       // empty רק אם count הוא אפס
wire all_ones    = &mask;              // כל הביטים דולקים
wire parity_bit  = ^data;              // parity של בייט
wire any_request = |request_vector;    // האם משהו התבקש?

צורות ה-reduction תמציתיות ועוברות סינתזה לעצי שערים ברורים: & הופך לשער AND עם כניסות רבות, | לשער OR עם כניסות רבות, ו-^ לעץ XOR (שהוא גם מחולל ה-parity בחומרה).

תבניות נפוצות

הדלקה וכיבוי של ביטים

wire [7:0] data;
wire [7:0] mask = 8'b0000_1000;

wire [7:0] set     = data | mask;     // מכריח את ביט 3 להיות 1
wire [7:0] cleared = data & ~mask;    // מכריח את ביט 3 להיות 0
wire [7:0] toggled = data ^ mask;     // הופך את ביט 3
wire [7:0] tested  = data & mask;     // אפס אם ביט 3 היה 0, אחרת שונה מאפס

אלה אותם ניבים של מניפולציית ביטים שהייתם משתמשים בהם ב-C. הם עוברים סינתזה לפעולות של שער יחיד.

בדיקה אם ערך שווה לכל האחדות

wire is_max = &counter;       // 1 אם כל ביט של counter הוא 1

reduction AND עם שער אחד, לעומת כתיבה של counter == 8'hFF (שגם עובדת; סינתיסייזרים בדרך כלל מייצרים חומרה זהה).

יצירת ביט parity

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // ביט parity זוגי
    wire       odd_parity = ~^data;     // ביט parity אי זוגי

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            data = 8'd1 << i;
            #1 $display("data=%b parity=%b odd=%b", data, parity, odd_parity);
        end
        $finish;
    end
endmodule

זיהוי אות פעיל כלשהו

wire any_pending = |request_vector;

אם request_vector רחב (נגיד 64 מבקשים), ה-reduction OR מתכווץ לאות יחיד שאפשר להזין ל-priority encoder או ל-arbiter.

אופרטורי הזזה

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

• a << N מזיז את a שמאלה ב-N מיקומי ביטים, וממלא באפסים את הביטים התחתונים.
• a >> N מזיז את a ימינה ב-N מיקומי ביטים, וממלא באפסים את הביטים העליונים.
• a <<< N הזזה אריתמטית שמאלה (זהה ל-<< בערכים בלי סימן).
• a >>> N הזזה אריתמטית ימינה: ממלאת בביט הסימן כש-a הוא עם סימן.

module shifts;
    initial begin
        $display("8'b0011_1100 << 2 = %b", 8'b0011_1100 << 2);
        $display("8'b0011_1100 >> 2 = %b", 8'b0011_1100 >> 2);

        // Arithmetic right shift on signed value preserves sign:
        $display("8'sb1100_0000 >>> 2 = %b", $signed(8'sb1100_0000) >>> 2);
        $finish;
    end
endmodule

הזזה בכמות קבועה היא בחינם בחומרה (רק חיווט מחדש). הזזה במשתנה שנקבע בזמן ריצה מייצרת barrel shifter, שהוא גדול יותר אבל עדיין זול.

מה הלאה

ראיתם עכשיו כל אופרטור שמחזיר ערך יחיד. המסמך הבא, שרשור ושכפול, עוסק בתחביר {} ו-{N{...}} שבונה וקטורים רחבים יותר מחלקים, ותשתמשו בו כל הזמן כשמחברים בין מודולים ברוחבים שונים.