Побитовые и reduction-операторы в Verilog

Две роли у одного символа

&, |, ^ и их инвертированные братья появляются в двух разных формах:

• Binary-форма (два операнда): a & b - побитовая операция между векторами одинаковой ширины.
• Унарная форма (один операнд): &a - reduction по всем битам a в один бит.

Компилятор различает их по количеству операндов. Принятая терминология: "побитовые операторы" для binary-формы и "reduction-операторы" для унарной.

Побитовые: бит за раз

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);   // побитовый AND
        $display("a | b = %b", a | b);   // побитовый OR
        $display("a ^ b = %b", a ^ b);   // побитовый XOR
        $display("~a    = %b", ~a);      // побитовый NOT (один операнд)
        $display("a ~^ b = %b", a ~^ b); // побитовый XNOR
        $finish;
    end
endmodule

Полный набор:

Оператор	Имя	Выходной бит на позиции N
a & b	AND	a[N] AND b[N]
a | b	OR	a[N] OR b[N]
a ^ b	XOR	a[N] XOR b[N]
a ~& b	NAND	NOT (a[N] AND b[N])
a ~| b	NOR	NOT (a[N] OR b[N])
a ~^ b	XNOR	NOT (a[N] XOR b[N])
~a	NOT	NOT a[N]

Заметь, что ~&, ~|, ~^ пишутся: сначала тильда, потом оператор. Это один токен; между ними нет пробела.

Когда у двух операндов разная ширина, более узкий zero-extend'ится слева, чтобы соответствовать. Если хочешь sign-extension, используй signed-операнды явно через $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. Полезен для "это non-zero?".
• ^data возвращает parity - XOR всех бит. 1, если нечётное число единиц, 0, если чётное.
• ~&data, ~|data, ~^data - инверсии вышеперечисленного.

В реальном коде их встретишь повсюду:

wire empty       = ~|fifo_count;       // empty, если count = 0
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, иначе non-zero

Это те же идиомы битовых манипуляций, что и в C. Синтезируются в операции из одного вентиля.

Проверка, что значение равно all-ones

wire is_max = &counter;       // 1, если каждый бит counter - 1

Reduction AND из одного вентиля - vs counter == 8'hFF (это тоже работает; синтезаторы обычно дают идентичное железо).

Генерация бита parity

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // even parity bit
    wire       odd_parity = ~^data;     // odd parity bit

    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'у.

Операторы сдвига

Раз уж разбираем bit-level операторы - сдвиги:

• a << N сдвигает a влево на N позиций, справа заполняет нулями.
• a >> N сдвигает a вправо на N позиций, слева заполняет нулями.
• a <<< N арифметический левый сдвиг (то же, что << для unsigned).
• 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);

        // Арифметический сдвиг вправо на знаковом значении сохраняет знак:
        $display("8'sb1100_0000 >>> 2 = %b", $signed(8'sb1100_0000) >>> 2);
        $finish;
    end
endmodule

Сдвиги на константную степень в железе бесплатны (просто перекоммутация). Сдвиги на runtime-переменную дают barrel shifter - больше, но всё ещё дешёво.

Что дальше

Ты увидел каждый оператор, возвращающий одно значение. Следующий документ - Concatenation and Replication - разбирает синтаксис {} и {N{...}}, который строит более широкие векторы из кусочков, что ты будешь использовать постоянно при стыковке модулей разной ширины.