Operatory w Verilogu: arytmetyczne, porównania, logiczne i warunkowy

Co w Verilogu oznacza "operator"

Operatory przyjmują wyrażenia niosące sygnały i tworzą nowe wyrażenia niosące sygnały. a + b to sprzęt: syntezator zamienia go w sumator. a == b to sprzęt: buduje komparator. Nic z tego nie jest "kodem, który się wykonuje". To wszystko "układy opisane przez operator".

Pełne menu operatorów jest na tyle małe, że da się je zapamiętać. Ten artykuł omawia operatory arytmetyczne, porównania, logiczne i warunkowy. Artykuł Operatory bitowe i redukcyjne omawia operatory działające na bitach, które nie mają bezpośrednich odpowiedników w programowaniu.

Arytmetyka: + - * / %

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

Trzy rzeczy, które warto wiedzieć:

1. Dzielenie jest całkowite. 7/2 daje 3, a nie 3.5. Verilog nie ma typu zmiennoprzecinkowego (no, jest real, ale tylko w symulacji).
2. Dzielenie i modulo są w sprzęcie kosztowne. /4 jest w porządku (syntezator zamienia je w przesunięcie w prawo), ale /n dla n zmiennego w czasie działania buduje wielocyklowy dzielnik, którego prawie nigdy nie chcesz.
3. Przepełnienie się zawija. Dodanie dwóch N-bitowych wartości bez znaku, których suma przekracza N bitów, obcina wynik do N bitów. Jeśli chcesz zachować przeniesienie, zadeklaruj wynik o jeden bit szerszy:

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

Porównania: == != < > <= >=

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

Wszystkie sześć operatorów porównania zwraca wynik jednobitowy: 1, gdy warunek jest prawdziwy, 0, gdy fałszywy, i x, gdy którykolwiek argument ma bit x albo z. Do obsługi przypadku x/z służą === i !== (operatory równości dokładnej), omówione w artykule Wartości X i Z.

<= jest tu operatorem porównania (mniejsze lub równe). Te same znaki oznaczają też przypisanie nieblokujące w bloku proceduralnym (q <= d). Rozróżnia je kontekst: wewnątrz wyrażenia to porównanie, a po lewej stronie przypisywanej wartości to przypisanie. To nakładanie się myli, ale dla parsera jest jednoznaczne.

Operatory logiczne: && || !

Operatory logiczne traktują argumenty jako wartości logiczne (wszystko niezerowe to prawda, zero to fałsz) i dają wynik jednobitowy:

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

Kluczowe rozróżnienie, które trzeba przyswoić: logiczne && to nie bitowe &.

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)

To samo dotyczy || i |. Operatorów logicznych używaj w warunkach if i predykatach ?:, a bitowych wtedy, gdy każda pozycja bitu ma być łączona przez AND/OR niezależnie.

&& i || mają skrócone wartościowanie w sensie znanym z C: prawa strona nie jest obliczana, jeśli wynik jest już przesądzony przez lewą. Ma to znaczenie w testbenchach, które sprawdzają wskaźniki albo wywołania funkcji, ale rzadko w syntezowalnym RTL, gdzie i tak wszystko dzieje się równolegle.

Operator warunkowy: ?:

Operator trójargumentowy to twój najlepszy przyjaciel przy budowaniu multiplekserów i wyrażeń warunkowych:

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

Wzorzec cond ? a : b to w sprzęcie multiplekser 2 na 1 z jednobitowym wyborem. Łańcuchy takich wyrażeń sprawdzają się przy wyborze z 3 i 4 wariantów, ale powyżej tego instrukcja case (omówiona w artykule Instrukcja case) jest dużo czytelniejsza.

Operator ?: to też standardowy sposób na nadanie rejestrowi wartości domyślnej, którą tylko czasem nadpisujesz:

next_value = update ? new_data : next_value;

Reguły szerokości: pułapka dla początkujących

Reguły szerokości dla operatorów arytmetycznych w Verilogu są znane z tego, że zaskakują. W skrócie:

• Szerokość wyniku to maksimum szerokości wejść.
• Jeśli wynik jest przypisywany do czegoś szerszego, jest rozszerzany zerami (albo bitem znaku, jeśli jest ze znakiem).
• Szerokość obliczeń pośrednich to także szerokość wyniku, co oznacza, że przepełnienie następuje już w obliczeniu pośrednim.

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

Pierwsze mnożenie się przepełnia, bo oba argumenty mają 8 bitów, więc wynik też ma 8 bitów, a 40000 się w nich nie mieści. Drugie działa, bo przed mnożeniem jawnie poszerzamy a.

Techniki naprawy:

• Użyj operatora konkatenacji {8'b0, a}, żeby rozszerzyć zerami.
• Użyj $unsigned(a) albo $signed(a), żeby wpłynąć na interpretację.
• W razie wątpliwości rzutuj wyrażenia pośrednie na większe szerokości.

Priorytet operatorów

Nie zapamiętasz całej tabeli, ale będziesz polegać na kilku regułach:

• *, /, % wiążą silniej niż +, -.
• Porównania wiążą silniej niż operatory logiczne (&&, ||).
• Operator warunkowy ?: ma bardzo niski priorytet, więc w większych wyrażeniach jego gałęzie zwykle wymagają nawiasów.
• W razie wątpliwości dodaj nawiasy. Symulator nie liczy opłat za znaki.

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

Co dalej

Znasz już wszystkie operatory, które wyglądają jak ich odpowiedniki z programowania. Następny artykuł, Operatory bitowe i redukcyjne, omawia operatory bez bezpośrednich odpowiedników w programowaniu: bitowe AND/OR/XOR na każdym bicie oraz formy redukcyjne, które zwijają cały wektor do jednego bitu.