Verilog blocking vs non-blocking: Wann = und wann <= benutzen

Die zwei Operatoren

Innerhalb von always- und initial-Blöcken hat Verilog zwei Zuweisungsoperatoren:

• = ist eine blocking-Zuweisung. Aktualisiere die LHS sofort, bevor du zur nächsten Anweisung gehst.
• <= ist eine non-blocking-Zuweisung. Werte die RHS jetzt aus, plane die LHS so, dass sie am Ende des aktuellen Zeitschritts aktualisiert wird.

Außerhalb prozeduraler Blöcke (in assign) gibt es nur = - assign a <= b ist ein Syntaxfehler. Innerhalb prozeduraler Blöcke sind beide zulässig, und die Wahl des richtigen Operators ist die einzige wichtigste Entscheidung in Anfänger-Verilog.

Was blocking macht

Blocking ist das, was du von einer Software-Sprache erwartest: Zeile für Zeile, von oben nach unten. Anweisung N läuft fertig, bevor Anweisung N+1 startet:

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

    initial begin
        a = 4'd1;
        b = a + 4'd1;    // b = 1 + 1 = 2 (nutzt den NEUEN Wert von a)
        c = b + 4'd1;    // c = 2 + 1 = 3 (nutzt den NEUEN Wert von b)

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

Das ist rein sequentiell. Jede Anweisung sieht die Auswirkungen der vorhergehenden. Das passt zur Software-Intuition.

Was non-blocking macht

Non-blocking ist hardware-geformt. Alle rechten Seiten werten mit den Werten am Anfang des Zeitschritts aus. Alle linken Seiten aktualisieren sich am Ende des Zeitschritts. Die Reihenfolge der Anweisungen im Quelltext ändert die Abhängigkeiten zwischen Signalen nicht:

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

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

        // Alle drei RHS nutzen die Werte VOR dieser Dreifach-Zuweisung.
        a <= b;          // a wird zu 2 (altes b)
        b <= c;          // b wird zu 3 (altes c)
        c <= a;          // c wird zu 1 (altes a)

        #1;  // einen Zeitschritt warten, damit die Updates wirken
        $display("a=%0d b=%0d c=%0d", a, b, c);
        $finish;
    end
endmodule

Dieser Schnipsel implementiert eine 3-Weg-Rotation a → b → c → a in einem Schritt. Mit blocking bräuchtest du eine temporäre Variable, um keinen der drei zu überschreiben. Mit non-blocking passiert der Tausch atomar, weil jede RHS die _Vor-dem-Schritt-_Werte liest.

Genau so verhalten sich drei Flip-Flops an einer Taktflanke: Sie erfassen alle gleichzeitig ihre Eingänge, unabhängig von den Abhängigkeiten zwischen ihnen.

Die Regel, die dich rettet

Benutze <= in getakteten Blöcken. Benutze = in kombinatorischen Blöcken.

Das ist alles. Lerne es auswendig. Tippe es ohne nachzudenken. Die meisten Race Conditions, Sim/Synthese-Abweichungen und "läuft bei mir, aber nicht in der Synthese"-Bugs kommen daher, diese Regel zu verletzen.

Die Regel hat einen Hardware-Grund: Getaktete Blöcke modellieren Flip-Flops, die alle gleichzeitig ihre Eingänge abtasten. Kombinatorische Blöcke modellieren Logik, die sich so schnell ausbreitet, wie sie kann. Die Operator-Semantik passt zu diesen Verhaltensweisen.

module shift_register(
    input  wire       clk,
    input  wire       in,
    output reg  [3:0] out
);
    // Getakteter Block - verwende <=
    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

Jedes <= liest den aktuellen Wert des Quellregisters und plant das Zielregister so, dass es diesen Wert am Ende des Zeitschritts annimmt. Der Nettoeffekt ist genau das, was ein Hardware-Schieberegister tut: jedes Flip-Flop erfasst den Wert seines Nachbarn, alle an derselben Taktflanke, kein Race.

Überleg jetzt, was mit blocking-Zuweisung passiert wäre:

// FALSCH - das ist kein Schieberegister!
always @(posedge clk) begin
    out[3] = out[2];   // out[3] wird zu out[2]
    out[2] = out[1];   // out[2] wird zu out[1], das wir gerade oben gesetzt haben
    out[1] = out[0];
    out[0] = in;
end

Jede Anweisung überschreibt die Quelle, bevor die nächste sie liest. In einem Taktzyklus würde sich in ganz bis zu out[3] durchpflanzen, weil jede Zeile den frisch geschriebenen Wert der vorigen sieht. Das Verhalten auf echter Hardware (die non-blocking-Semantik hat) wäre völlig anders als das, was der Simulator gezeigt hat.

Kombinatorische Blöcke: Blocking ist richtig

Für always @(*) ist blocking-Zuweisung korrekt. Es gibt keine Flip-Flops, keine Gleichzeitig-Erfassen-Regel und Zwischenvariablen sind nützlich:

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 wird zuerst berechnet, dann nutzt result den eben berechneten Wert. Die kombinatorische Logik flacht auf ein einzelnes Stück Hardware ab: result = ~(a + b). Es entstehen keine Flip-Flops, weil kein Takt vorhanden ist.

Würdest du hier <= benutzen, würde der Simulator sum immer noch aktualisieren, bevor result darauf ausgewertet wird (weil beide Updates am Ende des Schritts passieren), aber die Reihenfolge wäre subtil anders, und viele Synthese-Tools beschweren sich. Misch nicht; wähle den Operator, der zum Blocktyp passt.

Der Fehler, der am meisten weh tut

Hier ist er: ein getakteter Block mit blocking-Zuweisung.

// BUG: Race Condition, die nur darauf wartet, zu passieren
always @(posedge clk) begin
    a = b;
    b = c;
    c = a;
end

In der Simulation gibt der Simulator vielleicht zuerst a, dann b, dann c einen neuen Wert und produziert einen Satz Werte. Die Hardware produziert einen anderen Satz, weil echte Flip-Flops gleichzeitig erfassen. Die beiden weichen leise voneinander ab, und du verlierst einen Tag mit der Fehlersuche. Benutze <= in getakteten Blöcken.

Warum es überhaupt zwei Operatoren gibt

Die Designer von Verilog hätten eine Zuweisungssemantik wählen und dabei bleiben können. Haben sie nicht, weil die Sprache zwei verschiedene Hardware-Verhalten modellieren muss:

• Kombinatorische Logik: Signale propagieren kontinuierlich, Abhängigkeiten zählen, "was berechnet dieses Gatter" macht Sinn.
• Sequentielle Logik: Eine Taktflanke passiert, jedes Flip-Flop erfasst gleichzeitig, Abhängigkeiten zwischen Flip-Flop-Eingängen und -Ausgängen sind entkoppelt.

Blocking ist für das Erste. Non-blocking für das Zweite. Der Operator wählt die Semantik; den Rest macht der Simulator.

Wie es weitergeht

Du hast jetzt die Regeln, um jeden prozeduralen Block korrekt zu schreiben. Das nächste Kapitel geht von einzelnen Blöcken über zu den Kontrollfluss-Konstrukten, die darin sitzen: if/else, case und for-Schleifen. Die Regeln von blocking vs non-blocking gelten innerhalb all dieser Konstrukte weiter.