Verilog wire vs reg: cuándo usar cada uno (con ejemplos)

Dos nombres, un trabajo

Cada señal en Verilog tiene un tipo. Los dos tipos que conocerás primero son wire y reg. Los dos pueden mantener un valor. Los dos pueden ser de un bit o multibit. La diferencia no es sobre qué es la señal - es sobre quién la excita.

• Las señales wire se excitan fuera de bloques procedurales - por sentencias assign, por las salidas de submódulos, o por puertos de entrada de módulo.
• Las señales reg se excitan dentro de bloques procedurales - initial o always.

Esa es toda la regla. Los nombres de las palabras clave son raros porque preceden a la forma moderna de escribir Verilog. reg no siempre se convierte en un registro en hardware. Sigue leyendo para ver por qué.

Wire: la conexión continua

Un wire es un wire eléctrico. Lleva lo que sea que su driver esté produciendo, continuamente. Dos formas en las que un wire es excitado:

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

Tres cosas a observar:

• y y z se declaran wire en el módulo y wire de nuevo en el testbench.
• Se excitan con assign - esa es la forma de asignación continua. El lado derecho del = se vuelve a calcular cuando cualquier señal en él cambia.
• No podemos escribir y = a & b dentro de un bloque always manteniendo y como wire. El compilador lo rechazaría.

Si olvidas la palabra clave wire, Verilog declara implícitamente la señal como un wire de un solo bit por ti - lo que a veces es conveniente y a veces es un bug silencioso. La mayoría de los equipos habilitan una opción de la herramienta que da error en wires implícitos. Sé explícito y evita la trampa.

Reg: almacenamiento dentro de un bloque procedural

Un reg es una señal a la que asignas dentro de initial o always. El nombre es una reliquia de los primeros días del lenguaje cuando "reg" sonaba a "registro"; en uso moderno un reg es solo el tipo de cualquier señal a la que el código procedural escribe.

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 es reg dentro del módulo (porque el bloque always le escribe) y wire en el testbench (porque el puerto de salida del DUT lo excita). Misma señal, roles distintos, tipos distintos en cada scope.

Por qué "reg" no siempre significa "registro"

Aquí está la trampa más común de principiantes. Este módulo declara y como reg - pero el hardware sintetizado no contiene un 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

El bloque always @(*) es sensible a cualquier cambio de entrada. Es combinacional. Una herramienta de síntesis ve ese patrón y produce una puerta AND - sin flip-flop, sin reloj, solo lógica. La palabra clave reg es puramente un requisito sintáctico porque y se asigna dentro de un always.

Para conseguir un flip-flop real, el bloque always tiene que ser sensible a un flanco de reloj:

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

Ese es el patrón "sintetizador, por favor haz un flip-flop": lista de sensibilidad sincronizada por reloj, asignación no bloqueante. Misma palabra clave reg, hardware completamente distinto. Cubrimos la distinción en Always Block y Blocking vs Non-blocking.

La decisión en la práctica

Cada vez que declaras una señal, pregunta: ¿cómo la voy a excitar?

• ¿Excitar con assign? → wire.
• ¿Conectar al puerto de salida de un submódulo? → wire.
• ¿Puerto de entrada de módulo? → wire. (Las entradas siempre son wire.)
• ¿Excitar desde initial o always? → reg.
• ¿Puerto de salida de módulo excitado por código procedural? → output reg.
• ¿Puerto de salida de módulo excitado por assign? → output wire. (O simplemente output - la dirección sola por defecto va a wire.)

Ese árbol de decisión cubre cada situación que vas a encontrar en Verilog clásico.

Conflictos de drivers

Las señales wire pueden tener varios drivers en teoría - así es como funcionan los buses tri-state, donde varios módulos pueden excitar el mismo wire y los inactivos van a alta impedancia (z). Para lógica ordinaria, dos sentencias assign escribiendo el mismo wire producen comportamiento indefinido:

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

El simulador puede elegir uno, puede dejar la señal en X, depende de la herramienta. De todos modos es un bug. Un driver por wire a menos que estés construyendo un bus explícitamente.

Las señales reg solo pueden ser excitadas desde un bloque procedural. Dos bloques always ambos asignando al mismo reg es un error de síntesis y extraño en simulación. Misma regla: un driver.

La actualización de SystemVerilog: logic

SystemVerilog (el superset al que evolucionó Verilog) añade una única palabra clave que reemplaza a las dos: logic. Una señal logic puede ser excitada por assign o por un bloque procedural - pero no por ambos - y el compilador te detiene de configurar accidentalmente un bug de múltiples drivers.

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

Si estás empezando un proyecto desde cero y tu herramienta soporta SystemVerilog (que el editor de esta página lo hace, con -g2012), usar logic en todas partes simplifica las reglas. Los archivos .v clásicos todavía necesitan la división wire/reg, y verás los dos estilos en código real para siempre.

Qué viene a continuación

El siguiente doc - Vectors and Arrays - toma los mismos dos tipos y muestra cómo hacerlos multibit. Anchos de bus, rangos, dimensiones packed, la diferencia entre un vector de bits y un array de vectores. Todas las cosas que necesitas antes de poder construir algo más grande que un sumador de un bit.