Przypisania blokujące i nieblokujące w Verilogu: kiedy = a kiedy <=

Dwa operatory

W blokach always i initial Verilog ma dwa operatory przypisania:

• = to przypisanie blokujące. Aktualizuje lewą stronę od razu, przed przejściem do następnej instrukcji.
• <= to przypisanie nieblokujące. Oblicza prawą stronę teraz, a aktualizację lewej strony planuje na koniec bieżącego kroku czasowego.

Poza blokami proceduralnymi (w assign) istnieje tylko =, a assign a <= b to błąd składni. W blokach proceduralnych oba są dozwolone, a wybór właściwego to najważniejsza decyzja dla początkujących w Verilogu.

Jak działa przypisanie blokujące

Przypisanie blokujące działa tak, jak w językach programowania: linia po linii, od góry do dołu. Instrukcja N kończy się, zanim zacznie się instrukcja N+1:

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

    initial begin
        a = 4'd1;
        b = a + 4'd1;    // b = 1 + 1 = 2 (uses the NEW value of a)
        c = b + 4'd1;    // c = 2 + 1 = 3 (uses the NEW value of b)

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

To wykonanie czysto sekwencyjne. Każda instrukcja widzi efekty tych nad nią. Zgadza się to z intuicją z programowania.

Jak działa przypisanie nieblokujące

Przypisanie nieblokujące ma kształt sprzętu. Wszystkie prawe strony są obliczane na podstawie wartości z początku kroku czasowego. Wszystkie lewe strony są aktualizowane na końcu kroku czasowego. Kolejność instrukcji w kodzie nie zmienia zależności między sygnałami:

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

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

        // All three RHS use the values from BEFORE this triple-assignment.
        a <= b;          // a will become 2 (old b)
        b <= c;          // b will become 3 (old c)
        c <= a;          // c will become 1 (old a)

        #1;  // wait one time step so the updates take effect
        $display("a=%0d b=%0d c=%0d", a, b, c);
        $finish;
    end
endmodule

Ten fragment realizuje obrót trzech wartości a → b → c → a w jednym kroku. Z przypisaniem blokującym potrzebna byłaby zmienna tymczasowa, żeby nie nadpisać jednej z nich. Z nieblokującym zamiana jest atomowa, bo każda prawa strona odczytuje wartości sprzed kroku.

Dokładnie tak zachowują się trzy przerzutniki na zboczu zegara: wszystkie zapamiętują swoje wejścia w tej samej chwili, niezależnie od zależności między nimi.

Reguła, która cię ratuje

W blokach taktowanych używaj <=. W blokach kombinacyjnych używaj =.

To wszystko. Zapamiętaj to i stosuj bez zastanowienia. Większość wyścigów, rozbieżności między symulacją a syntezą i błędów typu "u mnie działa, a po syntezie nie" bierze się z łamania tej reguły.

Reguła ma uzasadnienie sprzętowe: bloki taktowane modelują przerzutniki, które próbkują wejścia jednocześnie. Bloki kombinacyjne modelują logikę, przez którą sygnał propaguje się tak szybko, jak może. Semantyka operatorów przypisania odpowiada tym zachowaniom.

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

Każde <= odczytuje bieżącą wartość rejestru źródłowego i planuje, że rejestr docelowy przyjmie tę wartość na końcu kroku czasowego. Efekt jest dokładnie taki, jak w sprzętowym rejestrze przesuwnym: każdy przerzutnik zapamiętuje wartość sąsiada, wszystkie na tym samym zboczu zegara, bez wyścigu.

A teraz zobacz, co stałoby się z przypisaniem blokującym:

// WRONG - this is not a shift register!
always @(posedge clk) begin
    out[3] = out[2];   // out[3] becomes out[2]
    out[2] = out[1];   // out[2] becomes out[1], which we just set above
    out[1] = out[0];
    out[0] = in;
end

Każda instrukcja nadpisuje źródło, zanim następna je odczyta. W jednym cyklu zegara in przeszłoby aż do out[3], bo każda linia widzi świeżo zapisaną wartość linii nad nią. Zachowanie prawdziwego sprzętu (który działa według semantyki nieblokującej) byłoby zupełnie inne niż to, co pokazał symulator.

Bloki kombinacyjne: tu właściwe jest blokujące

W always @(*) poprawne jest przypisanie blokujące. Nie ma przerzutników ani reguły jednoczesnego zapamiętywania, a zmienne pośrednie są przydatne:

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

Najpierw obliczane jest sum, a potem result korzysta z właśnie obliczonej wartości. Logika kombinacyjna spłaszcza się do jednego układu: result = ~(a + b). Nie pojawiają się żadne przerzutniki, bo nie ma zegara.

Gdyby użyć tu <=, symulator i tak zaktualizowałby sum, zanim result zostałby na jego podstawie obliczony (bo obie aktualizacje dzieją się na końcu kroku), ale kolejność byłaby subtelnie inna i wiele narzędzi do syntezy by protestowało. Nie mieszaj. Wybierz operator pasujący do typu bloku.

Błąd, który boli najbardziej

Oto on: blok taktowany z przypisaniem blokującym.

// BUG: race condition waiting to happen
always @(posedge clk) begin
    a = b;
    b = c;
    c = a;
end

Symulator może najpierw obsłużyć a, potem b, potem c i dać jeden zestaw wartości. Sprzęt da inny zestaw, bo prawdziwe przerzutniki zapamiętują jednocześnie. Oba wyniki rozjeżdżają się po cichu, a szukanie tego błędu zajmie ci cały dzień. W blokach taktowanych używaj <=.

Po co w ogóle dwa operatory

Twórcy Veriloga mogli wybrać jedną semantykę przypisania i się jej trzymać. Nie zrobili tego, bo język musi modelować dwa różne zachowania sprzętu:

• Logika kombinacyjna: sygnały propagują się ciągle, zależności mają znaczenie, pytanie "co oblicza ta bramka" ma sens.
• Logika sekwencyjna: przychodzi zbocze zegara, każdy przerzutnik zapamiętuje wartość jednocześnie, a zależności między wejściami i wyjściami przerzutników są rozdzielone.

Przypisanie blokujące służy do pierwszej, nieblokujące do drugiej. Operator wybiera semantykę, a symulator robi resztę.

Co dalej

Znasz już reguły, które pozwalają poprawnie napisać każdy blok proceduralny. Następny rozdział przechodzi od pojedynczych bloków do konstrukcji sterujących, które się w nich umieszcza: if/else, case i pętli for. Reguły przypisań blokujących i nieblokujących obowiązują w każdej z nich.