Vecteurs et tableaux Verilog : signaux multi-bits expliqués

Un wire vs plusieurs

Jusqu'ici chaque signal qu'on a vu était sur un bit. Les vrais designs ne ressemblent presque jamais à ça - les adresses font 16 ou 32 bits, les bus de données 8 ou 64, les pixels RGB 24. Verilog te donne un seul mécanisme pour rendre n'importe quel signal multi-bits : ajouter une plage entre crochets.

wire [7:0] data;       // wire 8 bits, bit 7 est MSB, bit 0 est LSB
reg  [15:0] address;   // reg 16 bits
output reg [31:0] result; // sortie de module 32 bits

Les nombres entre crochets sont les positions de bits des bits les plus et les moins significatifs. [7:0] veut dire « ce signal a des bits numérotés de 7 à 0 », ce qui fait 8 bits au total. Le premier nombre est l'indice haut. Le second est le bas.

Tu verras occasionnellement [0:7] à la place - même nombre de bits, endianness opposée pour le slicing. La forme [haut:bas] est la convention industrielle écrasante ; reste là-dessus sauf raison forte de t'en écarter.

Un exemple complet : un additionneur 8 bits

module adder8(
    input  wire [7:0] a,
    input  wire [7:0] b,
    output wire [8:0] sum
);
    // 8 bits + 8 bits peut produire un résultat 9 bits (une retenue sortante).
    assign sum = a + b;
endmodule

module test;
    reg  [7:0] a, b;
    wire [8:0] sum;

    adder8 dut(.a(a), .b(b), .sum(sum));

    initial begin
        a = 8'd10;  b = 8'd20;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd200; b = 8'd100;  #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'hFF;  b = 8'h01;   #1 $display("%h + %h = %h",   a, b, sum);
        $finish;
    end
endmodule

Chaque + additionne les deux vecteurs 8 bits et produit un résultat 9 bits. Les littéraux comme 8'd10 veulent dire « une valeur décimale 10 de 8 bits de large » - on couvre ça dans Littéraux numériques.

Slicing : extraire des bits

Une fois que tu as un vecteur, tu peux extraire des bits individuels ou des plages contiguës :

module slicing(input wire [15:0] data);
    initial begin
        $display("full data   = %b", data);
        $display("low byte    = %b", data[7:0]);
        $display("high byte   = %b", data[15:8]);
        $display("nibble[3:1] = %b", data[3:1]);
        $display("bit 9       = %b", data[9]);
    end
endmodule

module test;
    initial begin
        force test.dut.data = 16'b1010_1100_0011_0101;
        #1 $finish;
    end

    slicing dut();
endmodule

Ne te focalise pas sur la ligne force du testbench - on a juste besoin d'un moyen d'injecter une valeur pour démontrer le slicing. Ce qui est intéressant, ce sont les slices eux-mêmes.

Quelques règles :

• La direction du slice doit correspondre à la déclaration. Si tu as déclaré [7:0], slice avec [haut:bas]. Inverser la direction est une erreur de syntaxe.
• Slicer hors-plage produit x (inconnu) en simulation. L'outil de synthèse peut warner ou erreur.
• La sélection de bit est zéro-basée sur l'indice écrit - data[0] est le bit nommé 0, qui (pour une déclaration [7:0]) est le LSB.

Slices à base variable : +: et -:

Un besoin courant : « donne-moi 8 bits à partir du bit N ». Tu ne peux pas écrire data[N+7:N] directement parce que Verilog exige que les deux bouts de la plage soient des constantes. La syntaxe qui résout ça :

data[base +: width]   // width bits à partir de `base`, en MONTANT
data[base -: width]   // width bits à partir de `base`, en DESCENDANT

module variable_slice;
    reg [31:0] word = 32'hDEAD_BEEF;

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            $display("byte %0d = %h", i, word[i*8 +: 8]);
        end
        $finish;
    end
endmodule

La largeur est constante (on prend 8 bits à la fois), mais la base peut être une expression runtime. C'est exactement ce dont tu as besoin pour des mémoires adressables par octet, des taps de registre à décalage, etc.

Tableaux : un cran au-dessus des vecteurs

Un vecteur est un seul signal multi-bits. Un tableau est une collection de vecteurs, indexés indépendamment :

reg [31:0] mem [0:1023];

Cette déclaration a deux plages, et les deux plages veulent dire des choses différentes :

• [31:0] est la dimension packée - la largeur de chaque mot individuel.
• [0:1023] est la dimension non packée - combien il y a de mots.

Donc mem est 1024 registres 32 bits séparés. Tu accèdes à un mot avec un seul indice :

mem[5] = 32'hCAFE_BABE;       // écris le mot 5
data   = mem[address];        // lis le mot à l'adresse `address`

module memory_demo;
    reg [7:0] mem [0:7];   // 8 octets
    integer i;

    initial begin
        for (i = 0; i < 8; i = i + 1) mem[i] = i * i;

        for (i = 0; i < 8; i = i + 1)
            $display("mem[%0d] = %0d", i, mem[i]);

        $finish;
    end
endmodule

C'est une mini mémoire qui contient des carrés. Les vrais designs utilisent le même motif pour contenir des banques de registres, des tables de lookup, des FIFOs, et tout autre stockage on-chip plus grand qu'un seul vecteur.

Packed vs unpacked : pourquoi ça compte

Le split entre dimensions packées et non packées apparaît partout. Savoir lequel est lequel évite beaucoup de debug :

• Un vecteur packé est un seul signal. Tu peux traiter l'ensemble comme un nombre : data + 1 marche, data == 32'h0 marche, data[7:0] marche.
• Un tableau non packé est plusieurs signaux. Tu ne peux pas traiter l'ensemble comme un nombre : mem + 1 est une erreur de syntaxe. Tu dois d'abord extraire un mot spécifique.

Plusieurs dimensions packées sont aussi légales :

reg [3:0][7:0] regs;   // 4 octets packés ensemble en un signal 32 bits

regs[0] est un octet (l'octet bas). regs dans l'ensemble fait 32 bits. SystemVerilog s'en sert beaucoup.

Plusieurs dimensions non packées créent une mémoire 2D :

reg [31:0] frame [0:479][0:639];  // 480x640 pixels 32 bits

Tu accèdes à un seul pixel avec frame[y][x]. C'est à ça que ressemblerait un buffer d'image en HDL.

La suite

Tu peux maintenant déclarer et manipuler n'importe quel signal de la largeur dont tu as besoin. Le prochain document - Paramètres - montre comment rendre ces largeurs configurables pour que le même module marche en 8 bits dans une instance et en 32 bits dans une autre. Puis on passera aux règles d'écriture des littéraux numériques (8'b1010_1100, 32'hDEAD_BEEF), et aux valeurs x/z qui apparaissent dès que quelque chose n'est pas piloté.