Assignation blocking vs non-blocking en Verilog : quand utiliser = vs <=

Les deux opérateurs

À l'intérieur des blocs always et initial, Verilog a deux opérateurs d'assignation :

• = est une assignation blocking. Met à jour le LHS maintenant, avant de passer à l'instruction suivante.
• <= est une assignation non-blocking. Évalue le RHS maintenant, planifie la mise à jour du LHS à la fin du pas de temps courant.

En dehors des blocs procéduraux (dans assign) seul = existe - assign a <= b est une erreur de syntaxe. À l'intérieur des blocs procéduraux, les deux sont légaux, et choisir le bon est la décision la plus importante pour un débutant en Verilog.

Ce que blocking fait

Blocking est ce à quoi tu t'attendrais d'un langage logiciel : ligne par ligne, du haut vers le bas. L'instruction N termine avant que N+1 ne démarre :

module blocking_demo;
    reg [3:0] a, b, c;

    initial begin
        a = 4'd1;
        b = a + 4'd1;    // b = 1 + 1 = 2 (utilise la NOUVELLE valeur de a)
        c = b + 4'd1;    // c = 2 + 1 = 3 (utilise la NOUVELLE valeur de b)

        $display("a=%0d b=%0d c=%0d", a, b, c);
        $finish;
    end
endmodule

C'est purement séquentiel. Chaque instruction voit les effets de celles au-dessus. Ça correspond à l'intuition logicielle.

Ce que non-blocking fait

Non-blocking est en forme de matériel. Tous les côtés droits s'évaluent avec les valeurs au début du pas de temps. Tous les côtés gauches se mettent à jour à la fin du pas de temps. L'ordre des instructions dans le source ne change pas les dépendances entre signaux :

module nonblocking_demo;
    reg [3:0] a, b, c;

    initial begin
        a = 4'd1;
        b = 4'd2;
        c = 4'd3;

        // Les trois RHS utilisent les valeurs d'AVANT cette triple-assignation.
        a <= b;          // a deviendra 2 (ancien b)
        b <= c;          // b deviendra 3 (ancien c)
        c <= a;          // c deviendra 1 (ancien a)

        #1;  // attends un pas de temps pour que les mises à jour prennent effet
        $display("a=%0d b=%0d c=%0d", a, b, c);
        $finish;
    end
endmodule

Ce snippet implémente une rotation à 3 voies a → b → c → a en un seul pas. Avec blocking, il te faudrait une variable temporaire pour éviter d'en écraser une. Avec non-blocking, l'échange arrive atomiquement parce que chaque RHS lit les valeurs pré-pas.

C'est exactement comme ça que trois flip-flops se comportent sur un front d'horloge : ils capturent tous leurs entrées au même instant, indépendamment des dépendances entre eux.

La règle qui te sauve

Utilise <= dans les blocs cadencés. Utilise = dans les blocs combinatoires.

C'est tout. Mémorise-la. Code-la sans réfléchir. La plupart des race conditions, mismatches simulation/synthèse, et bugs « ça marche chez moi mais pas en synthèse » viennent de la violation de cette règle.

La règle a une raison matérielle : les blocs cadencés modélisent des flip-flops qui échantillonnent tous leurs entrées simultanément. Les blocs combinatoires modélisent de la logique qui se propage aussi vite qu'elle peut. La sémantique d'opérateur d'assignation correspond à ces comportements.

module shift_register(
    input  wire       clk,
    input  wire       in,
    output reg  [3:0] out
);
    // Bloc cadencé - utilise <=
    always @(posedge clk) begin
        out[3] <= out[2];
        out[2] <= out[1];
        out[1] <= out[0];
        out[0] <= in;
    end
endmodule

module test;
    reg clk = 0;
    reg in = 0;
    wire [3:0] out;

    shift_register dut(.clk(clk), .in(in), .out(out));

    always #5 clk = ~clk;

    initial begin
        #2  in = 1; #10 in = 0;
        #10 in = 1; #10 in = 1;
        #50 $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%b out=%b", $time, in, out);
endmodule

Chaque <= lit la valeur courante du registre source et planifie le registre destination pour prendre cette valeur à la fin du pas de temps. L'effet net est exactement ce que fait un registre à décalage matériel : chaque flip-flop capture la valeur de son voisin, tous sur le même front d'horloge, pas de race.

Considère maintenant ce qui serait arrivé avec une assignation blocking :

// FAUX - ce n'est pas un registre à décalage !
always @(posedge clk) begin
    out[3] = out[2];   // out[3] devient out[2]
    out[2] = out[1];   // out[2] devient out[1], qu'on vient de fixer au-dessus
    out[1] = out[0];
    out[0] = in;
end

Chaque instruction écrase la source avant que l'instruction suivante ne la lise. En un seul cycle d'horloge, in se propagerait tout du long jusqu'à out[3], parce que chaque ligne voit la valeur fraîchement écrite de celle au-dessus. Le comportement sur le vrai matériel (qui utilise la sémantique non-blocking) serait complètement différent de ce que le simulateur a montré.

Blocs combinatoires : blocking est bon

Pour always @(*), l'assignation blocking est correcte. Pas de flip-flops, pas de règle de capture simultanée à imposer, et les variables intermédiaires sont utiles :

module add_and_invert(
    input  wire [7:0] a,
    input  wire [7:0] b,
    output reg  [7:0] result
);
    reg [7:0] sum;

    always @(*) begin
        sum    = a + b;
        result = ~sum;
    end
endmodule

sum est calculé en premier, puis result utilise la valeur fraîchement calculée. La logique combinatoire s'aplatit en un seul morceau de matériel : result = ~(a + b). Aucun flip-flop n'apparaît parce qu'il n'y a pas d'horloge.

Si tu utilisais <= ici, le simulateur mettrait quand même à jour sum avant que result soit évalué contre lui (parce que les deux mises à jour arrivent en fin de pas), mais l'ordre serait subtilement différent et beaucoup d'outils de synthèse se plaignent. Ne mélange pas ; choisis l'opérateur qui correspond au type de bloc.

L'erreur qui fait le plus mal

La voici : un bloc cadencé avec assignation blocking.

// BUG : race condition qui n'attend que d'arriver
always @(posedge clk) begin
    a = b;
    b = c;
    c = a;
end

En simulation, le simulateur peut donner a d'abord, puis b, puis c, produisant un ensemble de valeurs. Le matériel produira un autre ensemble, parce que les vrais flip-flops capturent simultanément. Les deux divergent silencieusement et tu perdras une journée à trouver le bug. Utilise <= dans les blocs cadencés.

Pourquoi deux opérateurs existent du tout

Les concepteurs de Verilog auraient pu choisir une seule sémantique d'assignation et s'y tenir. Ils ne l'ont pas fait, parce que le langage doit modéliser deux comportements matériels distincts :

• Logique combinatoire : les signaux se propagent en continu, les dépendances comptent, « que calcule cette porte » a du sens.
• Logique séquentielle : un front d'horloge arrive, chaque flip-flop capture simultanément, les dépendances entre entrées et sorties de flip-flop sont découplées.

Blocking est pour le premier. Non-blocking est pour le second. L'opérateur choisit la sémantique ; le simulateur fait le reste.

La suite

Tu as maintenant les règles pour écrire n'importe quel bloc procédural correctement. Le prochain chapitre passe des blocs individuels aux constructions de control-flow qui vont à l'intérieur : if/else, case et boucles for. Les règles de blocking vs non-blocking s'appliquent toujours à l'intérieur d'eux.