Tutoriel sur les tableaux Verilog : des bases aux techniques avancées SystemVerilog

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Introduction

2. Types de données de base en Verilog

Différence entre reg et wire

• type wire Un wire est utilisé comme une ligne de connexion entre modules ou circuits. Il doit toujours être piloté par un autre signal, et les affectations sont effectuées à l’aide de l’instruction assign. Convient aux sorties de circuits combinatoires. Exemple :

  wire a;
  assign a = b & c;

• type reg Un reg est utilisé comme une variable pour stocker temporairement des valeurs. Il est affecté à l’intérieur de blocs de processus tels que always, et est généralement utilisé pour modéliser des éléments de stockage (verrous ou bascules). Exemple :

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

Types de données utilisables dans les tableaux

reg [7:0] data_array [0:15];  // An array storing 16 elements, each 8 bits wide

3. Concepts de base des tableaux

Déclaration des tableaux

reg [bit-width] array_name [index-range];

reg [7:0] data_array [0:15];  // An array of 16 elements, each storing 8-bit data

Accès aux éléments de tableau

data_array[0] = 8'hFF;   // Assign hexadecimal FF to the first element
data_array[1] = 8'd12;   // Assign decimal 12 to the second element

integer i;
always @(posedge clk) begin
    for (i = 0; i < 16; i = i + 1) begin
        data_array[i] <= 8'd0;
    end
end

Avantages des tableaux

• Traitement par lots : Avec une boucle for, vous pouvez appliquer la même opération à plusieurs signaux à la fois.
• Circuits structurés : Les tableaux aident à organiser plusieurs registres ou signaux, en gardant la représentation du circuit claire.
• Modélisation de mémoire : Vous pouvez implémenter des structures de mémoire simples telles que la RAM ou la ROM (expliqué dans le chapitre suivant).

Points à noter

4. Utilisation des tableaux multidimensionnels

Déclaration de tableaux multidimensionnels

reg [7:0] matrix [0:3][0:3];  // Defines a 4×4 matrix of 8-bit elements

Accès et affectation d’éléments

matrix[0][0] = 8'hA5;
matrix[2][3] = 8'd255;

Utilisation des boucles for

integer i, j;
always @(posedge clk) begin
    for (i = 0; i < 4; i = i + 1) begin
        for (j = 0; j < 4; j = j + 1) begin
            matrix[i][j] <= 8'd0;
        end
    end
end

Applications des tableaux multidimensionnels

• Utile dans les conceptions nécessitant des opérations matricielles ou le traitement de filtres.
• Peut être appliqué en traitement d’image ou traitement du signal numérique (DSP), pour la gestion de données au niveau des pixels.
• Utilisé dans les structures de blocs ROM/RAM et pour organiser des paires adresse-données.

Limitations et considérations

• Vérifiez la compatibilité des outils de synthèse, car certains outils peuvent ne pas prendre pleinement en charge les tableaux multidimensionnels.
• Des restrictions peuvent s’appliquer lorsqu’ils sont combinés avec des instanciations ou des interfaces.
• Comprenez les différences avec SystemVerilog pour éviter les problèmes de compatibilité (expliqué plus tard).

5. Modélisation de la mémoire avec des tableaux

Syntaxe de base pour les modèles de mémoire

reg [31:0] memory [0:1023];  // 32-bit × 1024-word memory

Écriture et lecture de la mémoire

// Write operation
always @(posedge clk) begin
    if (we) begin
        memory[addr] <= data_in;
    end
end

// Read operation
assign data_out = memory[addr];

• Les opérations d’écriture sont synchrones avec posedge clk et conditionnelles (contrôlées par we, enable d’écriture).
• Les opérations de lecture sont généralement implémentées avec assign pour des lectures combinatoires (asynchrones).

Initialisation de la mémoire

integer i;
initial begin
    for (i = 0; i < 1024; i = i + 1) begin
        memory[i] = 32'd0;
    end
end

initial begin
    $readmemh("rom_init.hex", memory);  // Initialize from a hex file
end

Cas d’utilisation pratiques

• Fichiers de registres dans les CPU ou microcontrôleurs
• Simulation comportementale de la Block RAM (BRAM) à l’intérieur des FPGA
• Vérification du comportement de la mémoire cache
• Simulation de la lecture de données ROM

Points à noter

• À mesure que la taille du tableau augmente, le temps de simulation et les ressources de synthèse augmentent également.
• Choisissez le timing de lecture (synchrone vs. asynchrone) avec soin en fonction des spécifications du design et des outils.
• Lors du ciblage de la synthèse, suivez les règles d’inférence de mémoire spécifiques recommandées par le fournisseur de l’outil.

6. Améliorations des tableaux en SystemVerilog

Tableaux dynamiques

Caractéristiques

• La taille du tableau peut être modifiée à l’exécution.
• Utile lorsque la taille est inconnue à l’avance ou variable pendant l’exécution.

Déclaration et exemple

int dyn_array[];             // Declare a dynamic array
dyn_array = new[10];         // Initialize with 10 elements
dyn_array[0] = 100;

Cas d’utilisation

• Stockage temporaire de données dans les bancs de test
• Gestion de tampons de taille variable

Tableaux associatifs

Caractéristiques

• Les indices peuvent être des valeurs arbitraires (entiers, chaînes, etc.).
• Fonctionne comme une table de hachage.

Déclaration et exemple

int assoc_array[string];     // Associative array using strings as keys
assoc_array["id_001"] = 42;

Cas d’utilisation

• Stockage des valeurs de configuration pour les paramètres
• Recherche de valeurs par ID ou nom

Files d’attente

Caractéristiques

• Se comporte comme une structure FIFO (First-In, First-Out).
• Prend en charge une insertion et une suppression faciles, idéal pour les flux de données dynamiques.

Déclaration et exemple

int queue_array[$];          // Declare a queue array

queue_array.push_back(10);   // Add element at the end
queue_array.push_front(5);   // Add element at the front
int val = queue_array.pop_front();  // Remove element from the front

Cas d’utilisation

• Stockage temporaire de données (tampons FIFO)
• Gestion des événements et des transactions

Comparaison et utilisation

Points à noter

• Ces tableaux améliorés sont des fonctionnalités propres à SystemVerilog et non disponibles dans Verilog.
• L’étendue du support de synthèse dépend de l’outil, et ils sont principalement utilisés pour les bancs de test.
• Si vous ciblez un FPGA ou un ASIC, vérifiez toujours si ces fonctionnalités sont prises en charge avant l’implémentation.

7. Bonnes pratiques pour les opérations sur les tableaux

Clarifier l’intention avec des commentaires et des noms

• Utilisez des noms significatifs pour les tableaux : reg [7:0] sensor_data [0:7];
• Ajoutez des commentaires pour décrire le but ou les unités :

// Stores 8-bit data from 8 sensors
reg [7:0] sensor_data [0:7];

Faire attention aux limites des boucles

• Limites supérieures incorrectes → accès hors limites (erreurs logiques ou avertissements du simulateur)
• Décidez soigneusement d’utiliser < ou <= pour la terminaison de la boucle

integer i;
always @(posedge clk) begin
    for (i = 0; i < 8; i = i + 1) begin
        sensor_data[i] <= 8'd0;
    end
end

Toujours initialiser explicitement

initial begin
    for (i = 0; i < 256; i = i + 1)
        mem[i] = 32'd0;
end

Concevoir des Modules Réutilisables

• Utiliser parameter pour rendre les tailles de tableaux configurables :

parameter DEPTH = 16;
reg [7:0] buffer [0:DEPTH-1];

• Permettre le passage de paramètres externes améliore la réutilisabilité du module.

Considérer la Synthétisabilité

• Tableaux reg unidimensionnels en Verilog : généralement synthétisables
• Tableaux dynamiques/associatifs/file d’attente en SystemVerilog : non synthétisables (pour simulation seulement)

Utiliser les Tableaux vs. Modules de Manière Appropriée

• Opérations petites et identiques → tableaux avec boucles for
• Fonctionnalité différente ou conceptions à grande échelle → conception modulaire et hiérarchique

8. Questions Fréquemment Posées (FAQ)

Q1. J’obtiens une erreur lors de l’utilisation de tableaux multidimensionnels en Verilog. Pourquoi ?

A1.

reg [7:0] matrix [0:3][0:3];  // Supported only in Verilog 2001 or later

• Assurez-vous que votre environnement de développement est conforme à Verilog 2001 ou ultérieur .
• Si des limitations persistent, réécrivez en utilisant des tableaux unidimensionnels avec des indices calculés.

reg [7:0] matrix_1d [0:15];  // Flattened 4x4 array, accessed with (i*4 + j)

Q2. Si je décris la RAM en utilisant des tableaux en Verilog, cela fonctionnera-t-il sur du matériel ?

A2.

reg [31:0] mem [0:255];  // 32-bit × 256-word RAM

• L’outil de synthèse doit reconnaître cette description comme une inférence de RAM en bloc .
• Le timing de lecture/écriture (synchrone vs. asynchrone) et le style d’accès doivent suivre des modèles spécifiques ou l’outil peut ne pas inférer la mémoire correctement.

• Suivez le guide de synthèse fourni par votre fournisseur FPGA/ASIC.
• Si le comportement diffère entre la simulation et le matériel, vérifiez les logs et déboguez étape par étape.

Q3. Puis-je utiliser les tableaux dynamiques, tableaux associatifs ou files d’attente de SystemVerilog dans du matériel réel ?

A3.

• Stockage temporaire de données dans les bancs de test
• Implémentations de randomisation ou de scoreboard dans les environnements de vérification
• Descriptions de transactions complexes

• Tout code de conception utilisant ces types de tableaux sera ignoré ou causera des erreurs dans les outils de synthèse.
• Si une implémentation matérielle est requise, convertissez-les en tableaux reg ou unidimensionnels de longueur fixe.

9. Conclusion

Points clés à retenir

• En comprenant les types de données de base Verilog (reg et wire), vous pouvez éviter les erreurs lors de la manipulation des tableaux.
• Les tableaux unidimensionnels sont des structures essentielles pour regrouper des données et modéliser la mémoire.
• Les tableaux multidimensionnels sont pris en charge depuis Verilog 2001 et versions ultérieures, permettant des conceptions de type matrice.
• SystemVerilog introduit des structures flexibles telles que les tableaux dynamiques, les tableaux associatifs et les files d’attente (principalement pour la simulation et la vérification).
• En suivant les meilleures pratiques de gestion des tableaux (initialisation, nommage, réutilisabilité, considérations de synthèse), vous pouvez écrire un code de meilleure qualité.

Conseils pratiques

Sujets suivants recommandés

• Utiliser les instructions generate pour la génération dynamique de circuits avec des tableaux
• Combiner interface avec des tableaux pour la conception de bus
• Implémenter des FIFO, des tampons circulaires et des optimisations de ROM en utilisant des tableaux