Opérateurs Verilog expliqués : Guide des opérations arithmétiques, bit à bit et de décalage

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

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

1. Vue d’ensemble du Verilog HDL et l’importance des opérateurs

2. Représentation numérique en Verilog

Format de base de la représentation numérique

<bit-width>'<base><value>

Explication de chaque composant

• Bit-width : Spécifie le nombre de bits occupés par la valeur.
• Exemple : 4 signifie 4 bits.
• Base : Spécifie le radice. Les notations suivantes sont utilisées :
• b : Binaire
• o : Octal
• d : Décimal
• h : Hexadécimal
• Value : Le nombre réel.

Exemples

• 4'b1010 → binaire sur 4 bits représentant 10.
• 8'd255 → décimal sur 8 bits représentant 255.
• 16'hABCD → hexadécimal sur 16 bits représentant ABCD.

Omission de la largeur de bits

Attention

Valeurs indéfinies et impédance élevée

• 1'bx : Valeur indéfinie.
• 1'bz : Impédance élevée.

3. Vue d’ensemble et classification des opérateurs

Classification des opérateurs

1. Arithmetic Operators * Utilisés pour effectuer des calculs numériques. * Exemples : + , - , * , / , %
2. Bitwise Operators * Effectuent des opérations logiques au niveau du bit. * Exemples : & , | , ^ , ~
3. Reduction Operators * Réduisent les opérations logiques bit à bit en un résultat d’un seul bit. * Exemples : & , | , ^
4. Shift Operators * Décalent les séquences de bits vers la gauche ou la droite. * Exemples : << , >> , <<< , >>>
5. Relational Operators * Comparent deux valeurs renvoient un résultat booléen. * Exemples : < , <= , > , >= , == , !=
6. Conditional Operator * Renvoie une valeur en fonction d’une condition. * Exemple : ? :
7. Concatenation Operator * Concatène plusieurs séquences de bits en une seule. * Exemple : {}

Vue d’ensemble de chaque catégorie

Bases des opérateurs arithmétiques

• Exemple d’utilisation :

  reg [7:0] a, b, result;
  assign result = a + b; // add a and b

Bases des opérateurs bit à bit

• Exemple d’utilisation :

  reg [3:0] a, b, result;
  assign result = a & b; // AND operation

Bases des opérateurs de réduction

• Exemple d’utilisation :

  reg [3:0] a;
  assign result = &a; // AND reduction of all bits

Bases des opérateurs conditionnels

• Exemple d’utilisation:

  assign result = (a > b) ? a : b; // return a if a > b, otherwise b

4. Utilisation des opérateurs et précautions

Opérateurs arithmétiques

Principaux opérateurs et exemples

Précautions d’utilisation

1. Arithmétique uniquement entière : Verilog ne prend pas en charge l’arithmétique à virgule flottante. Tous les calculs sont traités comme des entiers.

   // Floating-point arithmetic is not supported
   real a = 3.5, b = 1.5;
   // assign result = a / b; // Error

2. Limitations de synthèse pour la multiplication et la division : Bien que la multiplication ( * ) et la division ( / ) puissent être utilisées en simulation sans problème, elles consomment des ressources matérielles importantes lors de la synthèse. Il est recommandé d’utiliser explicitement des multiplicateurs ou de les remplacer par des opérations de décalage.

Opérateurs bit à bit

Principaux opérateurs et exemples

Précautions d’utilisation

1. Correspondance de la largeur de bits : Si les opérandes ont des largeurs de bits différentes, le résultat prend la largeur la plus grande. Cela peut entraîner des résultats inattendus si ce n’est pas géré avec soin.

   reg [3:0] a;
   reg [7:0] b;
   assign result = a & b; // result will be 8 bits wide

2. Gestion des valeurs indéfinies : Effectuer des opérations bit à bit sur des signaux contenant des valeurs indéfinies ( X ) ou d’impédance élevée ( Z ) peut entraîner des résultats inattendus.

Opérateurs de réduction

Principaux opérateurs et exemples

Précautions d’utilisation

• Interpréter le résultat : Le résultat d’un opérateur de réduction est un seul bit. Vous devez être conscient de ce que ce bit représente logiquement lors de son utilisation.

  reg [3:0] a = 4'b1101;
  assign result = &a; // Result: 0 (not all bits are 1)

Opérateurs de décalage

Principaux opérateurs et exemples

Précautions d’utilisation

1. Valeurs signées vs non signées : Les décalages arithmétiques sont recommandés lorsqu’on travaille avec des nombres signés.

   reg signed [7:0] a = -8'd4; // Store -4
   assign result = a >>> 1;    // Result: -2

2. Valeurs de décalage hors plage : Si la valeur de décalage dépasse la largeur de bits, le résultat peut devenir 0. Soyez prudent lors de l’application des décalages.

5. Explication détaillée des opérateurs relationnels, conditionnels et de concaténation

Opérateurs relationnels

Principaux opér et exemples

Précautions d’utilisation

1. Comparaison signée vs non signée : Les comparaisons entre valeurs signées et non signées peuvent entraîner des résultats inattendus.

   reg signed [3:0] a = -2;
   reg [3:0] b = 2;
   assign result = (a < b); // Result: 0 (due to signed interpretation)

2. Gestion des valeurs indéfinies : Les comparaisons impliquant X ou Z peuvent produire des résultats indéfinis. Faites attention aux avertissements pendant la simulation.

Opérateur conditionnel

Syntaxe

result = (condition) ? value1 : value2;

Exemple

reg [7:0] a = 8'd10;
reg [7:0] b = 8'd20;
assign result = (a > b) ? a : b; // If a > b, return a, otherwise b

Précautions d’utilisation

1. Éviter l’imbrication : L’imbrication d’opérateurs conditionnels rend le code complexe et réduit la lisibilité. Utilisez des instructions if-else si possible.

   // Example of reduced readability
   assign result = (a > b) ? ((c > d) ? c : d) : e;

2. Simulation vs synthèse : Lors de la synthèse, les expressions conditionnelles sont converties en logique de branchement comme les instructions case. Les opérateurs conditionnels complexes peuvent impacter l’utilisation des ressources.

Opérateur de concaténation

Syntaxe

{bit-sequence1, bit-sequence2, ...}

Exemple

reg [3:0] a = 4'b1101;
reg [3:0] b = 4'b0011;
wire [7:0] result;
assign result = {a, b}; // Result: 8'b11010011

Précautions d’utilisation

1. Confirmation de la largeur de bits : La largeur du résultat est la somme de toutes les séquences concaténées. Si la variable résultat n’a pas une largeur suffisante, une troncature se produit.

   reg [3:0] a = 4'b1101;
   reg [3:0] b = 4'b0011;
   wire [5:0] result;
   assign result = {a, b}; // Insufficient width, truncation occurs

2. Ordre des valeurs : Dans une concaténation, la valeur la plus à gauche est placée dans les bits supérieurs. Un ordre incorrect peut entraîner des résultats inattendus.

6. Priorité et associativité des opérateurs

Priorité des opérateurs

Points clés lors de l’utilisation

1. Utilisez des parenthèses : Même si vous connaissez la priorité des opérateurs, il est recommandé d’utiliser des parenthèses dans les expressions complexes afin de rendre explicite l’ordre d’évaluation.

   // Clear expression
   assign result = (a + b) * c;

2. Priorité de l’opérateur conditionnel : L’opérateur conditionnel ( ? : ) a une priorité inférieure à la plupart des autres opérateurs. Utilisez des parenthèses pour éviter un ordre d’évaluation inattendu.

   // Be careful with precedence of ? :
   assign result = a > b ? a + c : b - c; // Works, but parentheses are safer

Associativité

Exemples d’associativité

1. De gauche à droite : Les opérateurs sont évalués de gauche à droite.

   assign result = a - b - c; // ((a - b) - c)

2. De droite à gauche : Les opérateurs sont évalués de droite à gauche.

   assign result = a ? b : c ? d : e; // (a ? b : (c ? d : e))

Éviter les problèmes de priorité et d’associativité

Étude de cas : mauvaise compréhension de la priorité

assign result = a + b << c; // Which is evaluated first?

• Puisque << a une priorité plus élevée que +, l’expression est évaluée comme :

  assign result = a + (b << c);

Étude de cas : clarification avec des parenthèses

assign result = (a + b) << c; // Clarifies intended behavior

• L’utilisation parenthèses rend l’intention claire, facilitant le débogage et la révision du code.

7. Précautions et erreurs courantes lors de l’utilisation des opérateurs

Précautions

1. Gestion des valeurs indéfinies (X) et à haute impédance (Z)

Précautions

• Si le résultat du calcul devient X, cela peut entraîner un comportement imprévisible.
• Les valeurs Z sont principalement utilisées dans les buffers à trois états et certaines configurations de circuits.

Contremesures

• Initialisez explicitement les signaux qui pourraient autrement devenir indéfinis.
• Pendant la simulation, utilisez $display ou $monitor pour suivre les valeurs des signaux.

Exemple de code

reg [3:0] a = 4'bz; // High impedance
assign result = a + 4'b0011; // Result becomes undefined (X)

2. Arithmétique signée vs non signée

Précautions

• Si des signaux signés et non signés sont mélangés, l’opération est par défaut non signée.
• Pour gérer correctement les nombres signés, effectuez un cast explicite avec $signed ou $unsigned.

Contremesures

• Unifiez les types lors du mélange de signaux signés et non signés.
• Utilisez explicitement des types signés lorsque l’arithmétique signée est requise.

Exemple de code

reg signed [3:0] a = -4;
reg [3:0] b = 3;
assign result = a + b; // Evaluated as unsigned

3. Mismatch de largeur de bits

Précautions

• Une troncature peut se produire si la largeur du résultat est insuffisante.
• Pour les opérations de décalage, une largeur insuffisante du montant de décalage peut résultats incorrects.

Contremesures

• Spécifiez explicitement les largeurs de bits pour éviter la troncature ou le débordement.
• Utilisez le remplissage à zéro lorsque cela est nécessaire.

Exemple de code

reg [3:0] a = 4'b1010;
reg [7:0] b = 8'b00001111;
assign result = a + b; // Result becomes 8-bit wide

Cas d’erreurs courants et solutions

1. Mauvaise compréhension de la priorité de l’opérateur conditionnel

Exemple d’erreur

assign result = a > b ? a + c : b - c > d;

• Un ordre d’évaluation incorrect provoque un comportement inattendu.

Solution

assign result = (a > b) ? (a + c) : ((b - c) > d);

• Utilisez des parenthèses pour clarifier l’ordre d’évaluation.

2. Incohérence dans l’arithmétique signée

Exemple d’erreur

reg signed [7:0] a = -8'd10;
reg [7:0] b = 8'd20;
assign result = a + b; // Evaluated as unsigned

Solution

assign result = $signed(a) + $signed(b); // Explicit signed evaluation

3. Montants de décalage hors plage

Exemple d’erreur

assign result = a << 10; // If a is only 8 bits, this produces an invalid result

Solution

assign result = (10 < $bits(a)) ? (a << 10) : 0; // Limit shift amount

Conseils de dépannage

• Utiliser les journaux de simulation : Suivez les valeurs des signaux pas à pas avec $display ou $monitor.
• Vérifier les formes d’onde de simulation : Identifiez où apparaissent les valeurs indéfinies (X) ou d’impédance élevée (Z).
• Tester de petits blocs : Vérifiez des parties d’un grand design isolément pour repérer plus facilement les problèmes.

8. Résumé

Catégories de base des opérateurs

• Les opérateurs sont principalement classés dans les catégories suivantes :

1. Opérateurs arithmétiques (calculs numériques de base tels que l’addition, la soustraction, la multiplication et la division)
2. Opérateurs bit à bit (manipulations au niveau du bit)
3. Opérateurs de réduction (évaluent des vecteurs de bits entiers)
4. Opérateurs de décalage (décalages de bits à gauche ou à droite)
5. Opérateurs relationnels (comparaisons de valeurs)
6. Opérateurs conditionnels (opérateur ternaire pour le branchement)
7. Opérateurs de concaténation (combinaison de séquences de bits)

Précautions lors de l’utilisation

1. Valeurs indéfinies (X) et d’impédance élevée (Z)

• Elles apparaissent fréquemment en simulation et doivent être correctement initialisées pour éviter leur propagation.

2. Mélange de valeurs signées et non signées

• Le mélange d’opérations signées et non signées peut entraîner des résultats inattendus. Utilisez $signed ou $unsigned explicitement.

3. Gestion de la largeur de bits

• Soyez vigilant quant à la troncature ou au remplissage à zéro lorsque les largeurs diffèrent.

4. Priorité des opérateurs dans les expressions complexes

• Utilisez des parenthèses pour contrôler explicitement l’ordre d’évaluation et éviter les comportements imprévus.

Conseils de dépannage

• Exploitez les journaux de simulation ($display, $monitor) et les visualiseurs de formes d’onde.
• Décomposez les grands designs en modules plus petits et testables.

Note finale

FAQ (Foire aux questions)

Q1. Quels sont les opérateurs en Verilog ?

Q2. Quelle est la différence entre l’opérateur conditionnel (? :) et les instructions if‑else ?

assign result = (a > b) ? a : b;

if (a > b)
    result = a;
else
    result = b;

Q3. Comment gérer les valeurs indéfinies (X) et à haute impédance (Z) ?

1. Initialiser les signaux : attribuer des valeurs initiales appropriées aux signaux non utilisés.
2. Éviter les états Z inutiles : sauf si des buffers tri‑state sont requis, ne pas utiliser Z dans le code de synthèse.

Q4. Comment fonctionnent les opérateurs de décalage (<<, >>) ?

assign result = a << 2; // Shift a left by 2 bits
assign result = a >> 2; // Shift a right by 2 bits

Q5. Comment gérer les nombres signés en Verilog ?

reg signed [7:0] a = -8'd10;
reg [7:0] b = 8'd20;
assign result = $signed(a) + $signed(b);

Q6. À quoi faut‑il faire attention lorsqu’on opère sur des signaux de largeurs de bits ?

reg [3:0] a = 4'b1010;
reg [7:0] b = 8'b00001111;
assign result = {4'b0000, a} + b; // Zero-extend a to 8 bits

Q7. Comment confirmer la priorité des opérateurs ?

assign result = (a + b) * c;

Q8. L’opérateur conditionnel est‑il synthétisable ?

Q. Les opérateurs Verilog peuvent‑ils être utilisés en VHDL ?

Q10. Comment vérifier que les opérateurs sont utilisés correctement ?

1. Exécuter des simulations : vérifier les résultats de calcul avec $display ou $monitor.
2. Créer des bancs de test : valider la logique des opérateurs dans des modules isolés.
3. Utiliser des visualiseurs d’ondes : confirmer visuellement le comportement des signaux dans les outils de simulation.