Instructions if-else en Verilog expliquées : syntaxe, exemples et bonnes pratiques

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

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

1. Introduction

1-1. Qu’est-ce qu’une instruction if-else en Verilog ?

1-2. Problèmes causés par une utilisation incorrecte des instructions if-else

1. Des verrous indésirables sont générés

• Si toutes les conditions ne sont pas explicitement définies dans les branches, l’outil de synthèse peut créer des verrous (éléments de mémoire).
• Cela peut provoquer un comportement de stockage non souhaité et empêcher le circuit de fonctionner comme prévu.

2. Les résultats de simulation diffèrent des résultats de synthèse

• Même si la simulation fonctionne comme prévu, le comportement peut changer lors de l’implémentation sur FPGA ou ASIC.
• Cela se produit parce que certains styles de codage if-else peuvent amener les outils de synthèse à effectuer des optimisations incorrectes.

3. Lisibilité du code réduite

• Les instructions if-else fortement imbriquées rendent le code plus difficile à lire et à maintenir.
• Dans de nombreux cas, l’utilisation d’une instruction case à la place peut rendre le code plus clair.

1-3. Objectif de cet article

• La manière correcte d’utiliser les instructions if-else
• Comment écrire du code Verilog qui évite les verrous non intentionnels
• Quand utiliser if-else vs. case
• Les meilleures pratiques pour la conception Verilog

2. Syntaxe de base des instructions if-else en Verilog

2-1. Comment des instructions if-else

always_comb begin
    if (condition) 
        statement1;
    else 
        statement2;
end

always_comb begin
    if (condition1) 
        statement1;
    else if (condition2) 
        statement2;
    else 
        statement3;
end

2-2. Exemple de code de base pour les instructions if-else

module if_else_example(input logic a, b, output logic y);
    always_comb begin
        if (a == 1'b1) 
            y = b;
        else 
            y = ~b;
    end
endmodule

• Lorsque a vaut 1, y produit la même valeur que b.
• Lorsque a vaut 0, y produit la valeur inversée de b.

2-3. Fonctionnement des instructions if-else

1. Circuits combinatoires (en utilisant always_comb)

• Les sorties changent immédiatement en fonction des signaux d’entrée.
• Aucun latch n’est généré, ce qui aide à éviter un comportement inattendu.
• Il est recommandé d’utiliser always_comb au lieu de always @(*) .

1. Circuits séquentiels (utilisant always_ff)

• Les données sont mises à jour en synchronisation avec le signal d’horloge.
• Utilisé pour des comportements tels que les bascules D.

2-4. If-else dans les circuits combinatoires

module combination_logic(input logic a, b, output logic y);
    always_comb begin
        if (a == 1'b1) 
            y = b;
        else 
            y = ~b;
    end
endmodule

• Lorsque a == 1 : y = b
• Lorsque a == 0 : y = ~b

• L’utilisation de always_comb garantit qu’aucun latch n’est généré.
• Vous devez assigner des valeurs pour toutes les conditions (si vous omettez else, un latch peut être inféré).

2-5. If-else dans les circuits séquentiels

module d_flipflop(input logic clk, reset, d, output logic q);
    always_ff @(posedge clk or posedge reset) begin
        if (reset) 
            q <= 1'b0;
        else 
            q <= d;
    end
endmodule

• Lorsque reset vaut 1, la sortie q est remise à 0.
• Lorsque reset vaut 0 et que le montant de clk se produit, d est stocké dans q.

• Pour les circuits séquentiels, utilisez always_ff (et nonalways @(*)`).
• Utilisez <= (assignation non bloquante) pour éviter des conditions de course non intentionnelles.

2-6. Cas d’utilisation pratiques des instructions if-else

1. Contrôle des LED

• Allumer/éteindre les LED en fonction de l’état d’un interrupteur.

1. ALU (Unité Arithmétique et Logique)

• Contrôler des opérations telles que l’addition, la soustraction et les opérations logiques.

1. Transitions d’états

• Concevoir des machines à états finis (expliquées en détail dans la section suivante).

Résumé

• Les instructions if-else sont utilisées en Verilog pour implémenter des branchements conditionnels.
• Elles doivent être correctement appliquées aux circuits combinatoires (always_comb) et aux circuits séquentiels (always_ff).
• Si toutes les conditions ne sont pas explicitement assignées, des latches non intentionnels peuvent être générés.
• Dans la conception réelle de circuits, if-else est souvent utilisé pour contrôler les états.

3. Applications des instructions if-else

3-1. Conception de circuits combinatoires

Exemple 1 : additionneur 4 bits

module adder(
    input logic [3:0] a, b,
    input logic cin,
    output logic [3:0] sum,
    output logic cout
);
    always_comb begin
        if (cin == 1'b0)
            {cout, sum} = a + b; // no carry
        else
            {cout, sum} = a + b + 1; // with carry
    end
endmodule

Explication

• Si cin vaut 0, il effectue a + b.
• Si cin vaut 1, il effectue a + b + 1 (retenue incluse).
• L’utilisation de always_comb garantit qu’il s’agit d’un circuit combinatoire sans inférence de latch.

3-2. Utilisation de if-else dans les circuits séquentiels (registres)

Exemple 2 : bascule D

module d_flipflop(
    input logic clk, reset, d,
    output logic q
);
    always_ff @(posedge clk or posedge reset) begin
        if (reset)
            q <= 1'b0; // reset output to 0
        else
            q <= d;    // store d on clock edge
    end
endmodule

Explication

• Si reset vaut 1, q est réinitialisé à 0.
• Au front montant de clk, d est stocké dans q.
• L’utilisation de always_ff fait que cela se comporte comme un registre bascule.

3-3. Utilisation des instructions if-else dans les transitions d’état (FSM)

Exemple 3 : circuit de transition d’état simple

module fsm_toggle(
    input logic clk, reset, btn,
    output logic led_state
);
    typedef enum logic {OFF, ON} state_t;
    state_t state, next_state;

    always_ff @(posedge clk or posedge reset) begin
        if (reset)
            state <= OFF; // initial state
        else
            state <= next_state;
    end

    always_comb begin
        case (state)
            OFF: if (btn) next_state = ON;
                 else next_state = OFF;
            ON:  if (btn) next_state = OFF;
                 else next_state = ON;
            default: next_state = OFF;
        endcase
    end

    assign led_state = (state == ON);
endmodule

Explication

• La variable state contient l’état de la LED (ALLUMÉE ou ÉTEINTE).
• Lorsque reset vaut 1, la LED est ÉTEINTE (état initial).
• Lorsque le btn est pressé, la LED bascule entre ALLUMÉE ⇔ ÉTEINTE.
• Utiliser une instruction case pour les transitions d’état améliore la lisibilité.

3-4. Techniques avancées pour les instructions if-else

① Éviter l’imbrication profonde des instructions if-else

always_comb begin
    if (a == 1) begin
        if (b == 1) begin
            if (c == 1) begin
                y = 1;
            end else begin
                y = 0;
            end
        end else begin
            y = 0;
        end
    end else begin
        y = 0;
    end
end

always_comb begin
    case ({a, b, c})
        3'b111: y = 1;
        default: y = 0;
    endcase
end

• En exprimant les conditions sous forme de vecteur de bits et en utilisant une instruction case, l’imbrication est réduite et la lisibilité est améliorée.

Résumé

• Les instructions if-else peuvent être utilisées à la fois dans les circuits combinatoires et séquentiels.
• Utilisez always_comb pour la logique combinatoire et always_ff pour la logique séquentielle.
• Les FSM (machines à états finis) combinent souvent les instructions if-else et case pour gérer les états.
• Évitez l’imbrication profonde des if-else en exploitant les instructions case ou les conditions sous forme de vecteur de bits.

4. Différence entre les instructions if-else et case

4-1. Qu’est-ce qu’une instruction case ?

Syntaxe de base d’une case

always_comb begin
    case (condition_variable)
        value1: statement1;
        value2: statement2;
        value3: statement3;
        default: statement4; // if none match
    endcase
end

Exemple de case

module case_example(input logic [1:0] sel, input logic a, b, c, d, output logic y);
    always_comb begin
        case (sel)
            2'b00: y = a;
            2'b01: y = b;
            2'b10: y = c;
            2'b11: y = d;
            default: y = 0; // fallback
        endcase
    end
endmodule

Explication

• En fonction de la valeur de sel, y reçoit a, b, c ou d.
• Lorsqu’on branche sur plusieurs valeurs fixes, l’utilisation de case rend le code plus concis.
• L’inclusion de default empêche un comportement indéfini lorsque des valeurs inattendues apparaissent.

4-2. Principales différences entre if-else et case

4-3. Quand utiliser if-else vs. case

① Quand utiliser if-else

always_comb begin
    if (value >= 10 && value <= 20)
        output_signal = 1;
    else
        output_signal = 0;
end

• if-else est préférable lorsqu’on traite des intervalles (p. ex., 10~20).
• case ne peut pas gérer directement les conditions d’intervalle.

always_comb begin
    if (x == 1)
        y = 10;
    else if (x == 2)
        y = 20;
    else if (x == 3)
        y = 30;
    else
        y = 40;
end

• ifelse est le meilleur choix lorsque des conditions supérieures doivent écraser les suivantes.
• Utile pour la logique de priorité.

② Quand utiliser case

always_comb begin
    case (state)
        2'b00: next_state = 2'b01;
        2'b01: next_state = 2'b10;
        2'b10: next_state = 2'b00;
        default: next_state = 2'b00;
    endcase
end

• case est standard pour les transitions d’états d’une FSM.

always_comb begin
    case (opcode)
        4'b0000: instruction = ADD;
        4'b0001: instruction = SUB;
        4'b0010: instruction = AND;
        4'b0011: instruction = OR;
        default: instruction = NOP;
    endcase
end

• Pour les décodeurs d’instructions avec de nombreuses valeurs, case offre une lisibilité bien supérieure.

Résumé

5. Bonnes pratiques pour les instructions if-else en Verilog

5-1. Comment éviter l’inférence de latch

① Mauvais exemple (causant l’inférence de latch)

always_comb begin
    if (a == 1'b1)
        y = b; // when a == 0, y holds its previous value
end

Pourquoi cela crée-t-il un latch ?

• Si a == 1'b1, alors y = b.
• Si a == 0, y n’est pas réassigné, donc il conserve sa valeur précédente (comportement de latch).
• Ce stockage non intentionnel peut entraîner des bugs de conception.

② Exemple correct (éviter le latch)

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0; // explicitly assign y
end

③ Utilisation d’une assignation par défaut

always_comb begin
    y = 1'b0; // default assignment
    if (a == 1'b1)
        y = b;
end

5-2. Utilisation de always_comb et always_ff

① Logique combinatoire (always_comb)

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0;
end

• always_combtermine automatiquement la liste de sensibilité ((*)), n’avez donc pas besoin de l’écrire manuellement.
• Cela rend l’intention de votre conception plus claire et aide les outils à optimiser correctement.

② Logique séquentielle (always_ff)

always_ff @(posedge clk or posedge reset) begin
    if (reset)
        q <= 1'b0;
    else
        q <= d;
end

• always_ff indique explicitement que ce bloc décrit un flip‑flop piloté par l’horloge.
• Comparé à always @ (posedge clk or posedge reset), il améliore la lisibilité et réduit les erreurs.

5-3. Améliorer la lisibilité des instructions if‑else

① Réduire l’imbrication avec des instructions case

always_comb begin
    if (mode == 2'b00) begin
        if (enable) begin
            y = a;
        end else begin
            y = b;
        end
    end else begin
        y = c;
    end
end

always_comb begin
    case (mode)
        2'b00: y = enable ? a : b;
        default: y = c;
    endcase
end

• L’utilisation de case rend les branches plus propres et plus faciles à suivre.
• L’opérateur ternaire (?) peut raccourcir les expressions if‑else simples.

Résumé

6. Questions fréquentes (FAQ)

Q1 : Pourquoi les instructions if‑else génèrent‑elles parfois des latches en Verilog ? Comment les éviter ?

R1 : Cause de l’inférence de latch

Mauvais exemple (génère un latch)

always_comb begin
    if (a == 1'b1)
        y = b;  // when a == 0, y retains its value
end

Comment éviter l’inférence de latch

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0; // explicitly assign a value
end

always_comb begin
    y = 1'b0; // default assignment
    if (a == 1'b1)
        y = b;
end

Q2 : Quelle est la différence entre les instructions if‑else et case ? Laquelle devrais‑je utiliser ?

R2 : Directives d’utilisation

Q3 : Les instructions if‑else affectent‑elles la vitesse de traitement en Verilog ?

R3 : La performance dépend de la synthèse du circuit.

• Verilog est un langage de description matériel ; la vitesse d’exécution dépend de la structure matérielle synthétisée, pas du code lui‑même.
• Les instructions if‑else profondément imbriquées peuvent entraîner des chemins logiques plus longs et augmenter le délai de propagation.
• Cependant, les outils de synthèse effectuent des optimisations, de sorte que les circuits logiquement équivalents ont généralement des différences de performance minimes.

always_comb begin
    case (a)
        1: y = 10;
        2: y = 20;
        default: y = 30;
    endcase
end

Q4 : Dois‑je utiliser = ou <= dans les affectations if‑else ?

R4 : Bloquant (=) vs. non bloquant (<=)

always_comb begin
    if (a == 1)
        y = b; // blocking assignment
end

always_ff @(posedge clk) begin
    if (reset)
        y <= 0; // non-blocking assignment
    else
        y <= d;
end

Q5 : Comment puis‑je réduire l’imbrication profonde des instructions if‑else ?

R5 : Utilisez les instructions case ou les opérateurs ternaires

always_comb begin
    if (mode == 2'b00) begin
        if (enable) begin
            y = a;
        end else begin
            y = b;
        end
    end else begin
        y = c;
    end
end

always_comb begin
    case (mode)
        2'b00: y = enable ? a : b;
        default: y = c;
    endcase
end

Résumé

7. Conclusion

7-1. Points clés du if‑else en Verilog

✅ Syntaxe de base

• if‑else est le construct de base pour le branchement conditionnel.
• Dans les circuits combinatoires, utilisez always_comb et assurez‑vous que toutes les conditions assignent des valeurs.

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0; // prevent latches with default assignment
end

• Dans les circuits séquentiels (pilotés par l’horloge), utilisez always_ff avec des affectations non bloquantes ( <= ).

always_ff @(posedge clk or posedge reset) begin
    if (reset)
        q <= 1'b0;
    else
        q <= d;
end

7-2. Utilisation correcte du if‑else

• Utilisez always_comb et assignez des valeurs dans toutes les conditions pour éviter l’inférence de latch.
• Définissez des valeurs par défaut pour prévenir un comportement indéfini.

• Utilisez always_ff avec if‑else pour mettre à jour l’état aux fronts d’horloge.
• Utilisez <= (affectation non bloquante) pour garder la cohérence entre la simulation et le comportement matériel.

7-3. Quand utiliser case à la place

7-4. Bonnes pratiques

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0; // always assign explicitly
end

always_comb begin // combinational
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0;
end

always_ff @(posedge clk) begin // sequential
    if (reset)
        y <= 0;
    else
        y <= d;
end

always_comb begin
    case (sel)
        2'b00: y = a;
        2'b01: y = b;
        2'b10: y = c;
        default: y = d;
    endcase
end

7-5. Erreurs courantes et corrections

7-6. Résumé final

7-7. Prochaines étapes