Operatory bitowe i redukcyjne w Verilogu

Dwie role tego samego symbolu

&, |, ^ i ich odwrócone odpowiedniki występują w dwóch różnych postaciach:

• Forma dwuargumentowa (dwa argumenty): a & b, czyli operacja bitowa między wektorami o tej samej szerokości.
• Forma jednoargumentowa (jeden argument): &a, czyli redukcja wszystkich bitów a do jednego bitu.

Kompilator odróżnia je po liczbie argumentów. Przyjęło się mówić "operatory bitowe" o formie dwuargumentowej i "operatory redukcyjne" o formie jednoargumentowej.

Operacje bitowe: bit po bicie

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

Pełny zestaw:

Zwróć uwagę, że ~&, ~|, ~^ zapisuje się z tyldą na początku i operatorem po niej. To jeden token, bez spacji w środku.

Gdy argumenty mają różne szerokości, węższy jest rozszerzany zerami z lewej strony do szerokości drugiego. Jeśli chcesz rozszerzenia ze znakiem, użyj jawnie argumentów ze znakiem przez $signed().

Redukcja: z wielu bitów w jeden

Jednoargumentowe formy tych samych operatorów zwijają wektor do jednego bitu:

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

Co oznacza każdy z nich:

• &data zwraca 1, jeśli wszystkie bity data są równe 1, w przeciwnym razie 0. Przydaje się do sprawdzania, czy wartość składa się z samych jedynek.
• |data zwraca 1, jeśli którykolwiek bit data jest równy 1, w przeciwnym razie 0. Przydaje się do sprawdzania, czy wartość jest niezerowa.
• ^data zwraca parzystość, czyli XOR wszystkich bitów. 1 przy nieparzystej liczbie jedynek, 0 przy parzystej.
• ~&data, ~|data, ~^data to odwrotności powyższych.

Spotkasz je wszędzie w prawdziwym kodzie:

wire empty       = ~|fifo_count;       // puste wtedy i tylko wtedy, gdy count to zero
wire all_ones    = &mask;              // wszystkie bity ustawione
wire parity_bit  = ^data;              // parzystość bajtu
wire any_request = |request_vector;    // czy jest jakieś żądanie?

Formy redukcyjne są zwięzłe i syntezują się do oczywistych drzew bramek: & do wielowejściowej bramki AND, | do wielowejściowej bramki OR, a ^ do drzewa XOR (które w sprzęcie jest zarazem generatorem parzystości).

Typowe wzorce

Ustawianie i zerowanie bitów

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

wire [7:0] set     = data | mask;     // wymusza 1 na bicie 3
wire [7:0] cleared = data & ~mask;    // wymusza 0 na bicie 3
wire [7:0] toggled = data ^ mask;     // odwraca bit 3
wire [7:0] tested  = data & mask;     // zero, jeśli bit 3 był 0, w przeciwnym razie niezero

To te same idiomy manipulacji bitami, których używa się w C. Syntezują się do operacji na pojedynczych bramkach.

Sprawdzanie, czy wartość to same jedynki

wire is_max = &counter;       // 1, jeśli każdy bit counter to 1

Redukcyjne AND z jedną bramką zamiast zapisu counter == 8'hFF (który też zadziała, a syntezatory zwykle tworzą z niego identyczny sprzęt).

Generowanie bitu parzystości

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // bit parzystości (parzysty)
    wire       odd_parity = ~^data;     // bit parzystości (nieparzysty)

    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

Wykrywanie dowolnego aktywnego sygnału

wire any_pending = |request_vector;

Jeśli request_vector jest szeroki (na przykład 64 zgłaszających), redukcyjne OR zwija go do jednego sygnału, który można podać na koder priorytetowy albo arbiter.

Operatory przesunięcia

Skoro mowa o operatorach bitowych, oto przesunięcia:

• a << N przesuwa a w lewo o N pozycji bitowych i wypełnia zerami z prawej strony.
• a >> N przesuwa a w prawo o N pozycji bitowych i wypełnia zerami z lewej strony.
• a <<< N to arytmetyczne przesunięcie w lewo (dla wartości bez znaku działa jak <<).
• a >>> N to arytmetyczne przesunięcie w prawo: wypełnia bitem znaku, gdy a jest ze znakiem.

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

Przesunięcia o stałą liczbę pozycji są w sprzęcie darmowe (to tylko inne połączenie przewodów). Przesunięcia o wartość znaną dopiero w czasie działania tworzą barrel shifter, który jest większy, ale wciąż tani.

Co dalej

Znasz już wszystkie operatory zwracające pojedynczą wartość. Następny artykuł, Konkatenacja i replikacja, omawia składnię {} i {N{...}}, która buduje szersze wektory z kawałków. Będziesz jej używać stale przy łączeniu modułów o różnych szerokościach.