Verilog wire vs reg : quand utiliser chacun (avec exemples)

Deux noms, un seul job

Chaque signal en Verilog a un type. Les deux types que tu rencontreras en premier sont wire et reg. Les deux peuvent retenir une valeur. Les deux peuvent être sur un bit ou multi-bits. La différence ne porte pas sur ce que le signal est - mais sur qui le pilote.

• Les signaux wire sont pilotés en dehors des blocs procéduraux - par des instructions assign, par les sorties de sous-modules, ou par les ports d'entrée du module.
• Les signaux reg sont pilotés à l'intérieur des blocs procéduraux - initial ou always.

Voilà toute la règle. Les noms des mots-clés sont maladroits parce qu'ils précèdent la façon moderne d'écrire du Verilog. reg ne devient pas toujours un registre dans le matériel. Lis la suite pour comprendre pourquoi.

Wire : la connexion continue

Un wire est un fil électrique. Il transporte ce que son pilote produit, en permanence. Deux façons qu'un wire soit piloté :

module wires(input wire a, input wire b, output wire y, output wire z);
    // Piloté par une assignation continue.
    assign y = a & b;

    // Piloté par la sortie d'un sous-module - montré pour la complétude.
    // (le vrai sous-module est omis ici)
    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

Trois choses à remarquer :

• y et z sont déclarés wire dans le module et wire à nouveau dans le testbench.
• Ils sont pilotés par assign - c'est la forme assignation continue. La partie droite du = est recalculée chaque fois qu'un signal qu'elle contient change.
• On ne peut pas écrire y = a & b à l'intérieur d'un bloc always tout en gardant y comme wire. Le compilateur refuserait.

Si tu oublies le mot-clé wire, Verilog déclare implicitement le signal comme un wire 1 bit à ta place - ce qui est parfois pratique et parfois un bug silencieux. La plupart des équipes activent une option d'outil qui erreur sur les wires implicites. Sois explicite et évite le piège.

Reg : du stockage à l'intérieur d'un bloc procédural

Un reg est un signal que tu assignes à l'intérieur de initial ou always. Le nom est un vestige des débuts du langage où « reg » sonnait comme « register » ; dans l'usage moderne, un reg est juste le type de tout signal que du code procédural écrit.

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 est reg à l'intérieur du module (parce que le bloc always y écrit) et wire dans le testbench (parce que le port de sortie du DUT le pilote). Même signal, rôles différents, types différents selon le contexte.

Pourquoi « reg » ne veut pas toujours dire « registre »

Voici le piège le plus courant chez les débutants. Ce module déclare y comme reg - mais le matériel synthétisé ne contient pas de 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

Le bloc always @(*) est sensible à n'importe quel changement d'entrée. C'est combinatoire. Un outil de synthèse voit ce motif et produit une porte AND - pas de flip-flop, pas d'horloge, juste de la logique. Le mot-clé reg est purement une exigence syntaxique parce que y est assigné à l'intérieur d'un always.

Pour obtenir un vrai flip-flop, le bloc always doit être sensible à un front d'horloge :

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

C'est le motif synthèse-outil-fais-moi-un-flip-flop : liste de sensibilité cadencée, assignation non-blocking. Même mot-clé reg, matériel complètement différent. On couvre la distinction dans Always Block et Blocking vs Non-blocking.

La décision en pratique

Chaque fois que tu déclares un signal, demande-toi : comment vais-je le piloter ?

• Piloté avec assign ? → wire.
• Connecté au port de sortie d'un sous-module ? → wire.
• Port d'entrée d'un module ? → wire. (Les entrées sont toujours des wire.)
• Piloté depuis initial ou always ? → reg.
• Port de sortie d'un module piloté par du code procédural ? → output reg.
• Port de sortie d'un module piloté par assign ? → output wire. (Ou juste output - la direction seule par défaut donne wire.)

Cet arbre de décision couvre chaque situation que tu rencontreras en Verilog classique.

Conflits de pilotage

Les signaux wire peuvent avoir plusieurs pilotes en théorie - c'est comme ça que fonctionnent les bus tri-state, où plusieurs modules peuvent piloter le même wire et les inactifs passent en haute impédance (z). Pour la logique ordinaire, deux instructions assign écrivant le même wire produisent un comportement indéfini :

assign y = a;
assign y = b;   // MAUVAIS - y a deux pilotes

Le simulateur peut en choisir un, peut X-er le signal, ça dépend de l'outil. Quoi qu'il en soit c'est un bug. Un pilote par wire sauf si tu construis explicitement un bus.

Les signaux reg ne peuvent être pilotés que par un seul bloc procédural. Deux blocs always assignant tous deux le même reg est une erreur de synthèse et un comportement bizarre en simulation. Même règle : un seul pilote.

La mise à jour SystemVerilog : logic

SystemVerilog (le sur-ensemble vers lequel Verilog a évolué) ajoute un seul mot-clé qui remplace les deux : logic. Un signal logic peut être piloté par assign ou par un bloc procédural - mais pas les deux - et le compilateur t'empêche de créer accidentellement un bug multi-pilotes.

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

Si tu démarres un projet from scratch et que ton outil supporte SystemVerilog (ce qui est le cas de l'éditeur sur cette page, avec -g2012), utiliser logic partout simplifie les règles. Les fichiers .v classiques ont toujours besoin du split wire/reg, et tu verras les deux styles dans la nature pour toujours.

La suite

Le prochain document - Vecteurs et tableaux - prend ces mêmes deux types et montre comment les rendre multi-bits. Largeurs de bus, plages, dimensions packées, la différence entre un vecteur de bits et un tableau de vecteurs. Tout ce dont tu as besoin avant de construire quoi que ce soit de plus gros qu'un additionneur 1 bit.