Verilog wire vs reg: quando usare l'uno o l'altro (con esempi)

Due nomi, un solo compito

Ogni segnale in Verilog ha un tipo. I primi due tipi che incontrerai sono wire e reg. Entrambi possono contenere un valore. Entrambi possono essere a un bit o multi-bit. La differenza non riguarda cosa è il segnale, ma chi lo pilota.

• I segnali wire sono pilotati fuori dai blocchi procedurali: da istruzioni assign, dalle uscite dei sottomoduli o dalle porte di ingresso del modulo.
• I segnali reg sono pilotati dentro i blocchi procedurali: initial o always.

Questa è tutta la regola. I nomi delle parole chiave sono scomodi perché risalgono a prima del modo moderno di scrivere Verilog. reg non sempre diventa un registro nell'hardware. Continua a leggere per capire perché.

Wire: la connessione continua

Un wire è un filo elettrico. Trasporta in modo continuo qualunque cosa stia producendo il suo driver. Ecco due modi in cui un wire viene pilotato:

module wires(input wire a, input wire b, output wire y, output wire z);
    // Driven by a continuous assignment.
    assign y = a & b;

    // Driven by a sub-module output - shown for completeness.
    // (the actual sub-module is omitted here)
    assign z = a | b;
endmodule

module test;
    reg a, b;
    wire y, z;

    wires dut(.a(a), .b(b), .y(y), .z(z));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            {a, b} = i[1:0];
            #1 $display("a=%b b=%b y=%b z=%b", a, b, y, z);
        end
        $finish;
    end
endmodule

Tre cose da notare:

• y e z sono dichiarati wire nel modulo e di nuovo wire nel testbench.
• Sono pilotati da assign, cioè la forma di assegnazione continua. Il lato destro dell'= viene ricalcolato ogni volta che cambia uno qualsiasi dei segnali che contiene.
• Non possiamo scrivere y = a & b dentro un blocco always lasciando y come wire. Il compilatore lo rifiuterebbe.

Se dimentichi la parola chiave wire, Verilog dichiara implicitamente il segnale come wire a un bit al posto tuo: a volte è comodo, a volte è un bug silenzioso. La maggior parte dei team attiva un'opzione dello strumento che dà errore sui wire impliciti. Sii esplicito ed eviti la trappola.

Reg: memorizzazione dentro un blocco procedurale

Un reg è un segnale a cui assegni un valore dentro initial o always. Il nome è un residuo dei primi tempi del linguaggio, quando "reg" suonava come "register"; nell'uso moderno un reg è semplicemente il tipo di qualsiasi segnale in cui scrive il codice procedurale.

module regs(input wire clk, input wire reset, output reg [3:0] count);
    always @(posedge clk) begin
        if (reset) count <= 0;
        else       count <= count + 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [3:0] count;

    regs dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #80 $finish;
    end

    always @(posedge clk) $display("t=%0t count=%0d", $time, count);
endmodule

count è reg dentro il modulo (perché il blocco always ci scrive) e wire nel testbench (perché lo pilota la porta di uscita del DUT). Stesso segnale, ruoli diversi, tipi diversi in ciascuno scope.

Perché "reg" non significa sempre "registro"

Ecco la trappola più comune per chi inizia. Questo modulo dichiara y come reg, ma l'hardware sintetizzato non contiene alcun flip-flop:

module not_a_register(input wire a, input wire b, output reg y);
    always @(*) begin
        y = a & b;
    end
endmodule

module test;
    reg a, b;
    wire y;

    not_a_register dut(.a(a), .b(b), .y(y));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            {a, b} = i[1:0];
            #1 $display("a=%b b=%b y=%b", a, b, y);
        end
        $finish;
    end
endmodule

Il blocco always @(*) è sensibile a qualsiasi cambiamento degli ingressi. È combinatorio. Uno strumento di sintesi riconosce questo pattern e produce una porta AND: niente flip-flop, niente clock, solo logica. La parola chiave reg è un puro requisito sintattico, perché y viene assegnato dentro un always.

Per ottenere un vero flip-flop, il blocco always deve essere sensibile a un fronte di clock:

always @(posedge clk) begin
    q <= d;
end

Questo è il pattern "caro sintetizzatore, fammi un flip-flop": lista di sensibilità sul clock, assegnazione non-blocking. Stessa parola chiave reg, hardware completamente diverso. Approfondiamo la distinzione in Blocco always e Blocking e non-blocking.

La scelta in pratica

Ogni volta che dichiari un segnale, chiediti: come lo pilotarò?

• Lo piloti con assign? → wire.
• Lo colleghi alla porta di uscita di un sottomodulo? → wire.
• Porta di ingresso del modulo? → wire. (Gli ingressi sono sempre wire.)
• Lo piloti da initial o always? → reg.
• Porta di uscita del modulo pilotata da codice procedurale? → output reg.
• Porta di uscita del modulo pilotata da assign? → output wire. (Oppure solo output: la sola direzione equivale a wire per impostazione predefinita.)

Questo albero decisionale copre ogni situazione che incontrerai nel Verilog classico.

Conflitti tra driver

In teoria i segnali wire possono avere più driver: è così che funzionano i bus tri-state, dove più moduli possono pilotare lo stesso wire e quelli inattivi passano ad alta impedenza (z). Nella logica ordinaria, due istruzioni assign che scrivono sullo stesso wire producono un comportamento indefinito:

assign y = a;
assign y = b;   // BAD - y has two drivers

Il simulatore potrebbe sceglierne uno o portare il segnale a X: dipende dallo strumento. In ogni caso è un bug. Un solo driver per wire, a meno che tu non stia costruendo esplicitamente un bus.

I segnali reg possono essere pilotati da un solo blocco procedurale. Due blocchi always che assegnano entrambi lo stesso reg sono un errore di sintesi e producono risultati strani in simulazione. Stessa regola: un solo driver.

La novità di SystemVerilog: logic

SystemVerilog (il superset in cui si è evoluto Verilog) aggiunge un'unica parola chiave che sostituisce entrambe: logic. Un segnale logic può essere pilotato da assign oppure da un blocco procedurale, ma non da entrambi, e il compilatore ti impedisce di creare per sbaglio un bug con più driver.

module modern(input logic a, input logic b, output logic y);
    assign y = a ^ b;
endmodule

Se inizi un progetto da zero e il tuo strumento supporta SystemVerilog (come fa l'editor di questa pagina, con -g2012), usare logic ovunque semplifica le regole. I file .v classici hanno ancora bisogno della distinzione wire/reg, e nel codice reale vedrai entrambi gli stili per sempre.

Cosa viene dopo

La prossima guida, Vettori e array, prende gli stessi due tipi e mostra come renderli multi-bit. Larghezze dei bus, range, dimensioni packed, la differenza tra un vettore di bit e un array di vettori. Tutto ciò che ti serve prima di poter costruire qualcosa di più grande di un sommatore a un bit.