Operatori bitwise e di riduzione in Verilog

Due ruoli per lo stesso simbolo

&, |, ^ e i loro fratelli invertiti compaiono in due forme distinte:

• Forma binaria (due operandi): a & b, operazione bit a bit tra vettori della stessa larghezza.
• Forma unaria (un operando): &a, riduzione di tutti i bit di a a un solo bit.

Il compilatore le distingue contando gli operandi. Per convenzione si parla di "operatori bitwise" per la forma binaria e di "operatori di riduzione" per quella unaria.

Bitwise: un bit alla volta

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

L'insieme completo:

Nota che ~&, ~|, ~^ si scrivono con la tilde prima e l'operatore dopo. Sono un unico token, senza spazi in mezzo.

Quando i due operandi hanno larghezze diverse, quello più stretto viene esteso con zeri a sinistra per pareggiare. Se vuoi l'estensione del segno, usa esplicitamente operandi con segno tramite $signed().

Riduzione: da molti bit a uno

Le forme unarie degli stessi operatori comprimono un vettore in un solo bit:

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

Cosa significa ciascuna:

• &data restituisce 1 se tutti i bit di data valgono 1, altrimenti 0. Utile per verificare "è tutto a uno?".
• |data restituisce 1 se almeno un bit di data vale 1, altrimenti 0. Utile per verificare "è diverso da zero?".
• ^data restituisce la parità, cioè lo XOR di tutti i bit: 1 se il numero di 1 è dispari, 0 se è pari.
• ~&data, ~|data, ~^data sono gli inversi dei precedenti.

Li troverai ovunque nel codice reale:

wire empty       = ~|fifo_count;       // empty solo se count vale zero
wire all_ones    = &mask;              // tutti i bit a 1
wire parity_bit  = ^data;              // parità di un byte
wire any_request = |request_vector;    // c'è qualche richiesta?

Le forme di riduzione sono concise e si sintetizzano in alberi di porte evidenti: & diventa una porta AND a più ingressi, | una OR a più ingressi, ^ un albero di XOR (che in hardware è anche il generatore di parità).

Pattern comuni

Impostare e azzerare bit

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

wire [7:0] set     = data | mask;     // forza il bit 3 a 1
wire [7:0] cleared = data & ~mask;    // forza il bit 3 a 0
wire [7:0] toggled = data ^ mask;     // inverte il bit 3
wire [7:0] tested  = data & mask;     // zero se il bit 3 era 0, diverso da zero altrimenti

Sono gli stessi idiomi di manipolazione dei bit che useresti in C. Si sintetizzano in operazioni a porta singola.

Verificare se un valore è tutto a uno

wire is_max = &counter;       // 1 se ogni bit di counter vale 1

Una riduzione AND con una sola porta, invece di scrivere counter == 8'hFF (che funzionerebbe comunque: di solito i sintetizzatori producono hardware identico).

Generare un bit di parità

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // bit di parità pari
    wire       odd_parity = ~^data;     // bit di parità dispari

    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

Rilevare un qualsiasi segnale attivo

wire any_pending = |request_vector;

Se request_vector è largo (diciamo 64 richiedenti), la riduzione OR lo comprime in un solo segnale che puoi mandare a un priority encoder o a un arbitro.

Operatori di shift

Già che parliamo di operatori a livello di bit, ecco gli shift:

• a << N sposta a a sinistra di N posizioni, riempiendo con zeri a destra.
• a >> N sposta a a destra di N posizioni, riempiendo con zeri a sinistra.
• a <<< N è lo shift aritmetico a sinistra (uguale a << per i valori senza segno).
• a >>> N è lo shift aritmetico a destra: riempie con il bit di segno quando a è con segno.

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

Gli shift di una quantità costante in hardware sono gratis (è solo un diverso cablaggio). Gli shift di una quantità variabile a runtime producono un barrel shifter, più grande ma comunque economico.

Cosa viene dopo

Ora hai visto tutti gli operatori che restituiscono un singolo valore. La prossima pagina, Concatenation and Replication, tratta la sintassi {} e {N{...}} che costruisce vettori più larghi a partire da pezzi: la userai di continuo per collegare moduli di larghezze diverse.