Assegnazione blocking e non-blocking in Verilog: quando usare = o <=

I due operatori

Dentro i blocchi always e initial, Verilog ha due operatori di assegnazione:

• = è un'assegnazione blocking (bloccante): aggiorna subito il lato sinistro, prima di passare all'istruzione successiva.
• <= è un'assegnazione non-blocking (non bloccante): valuta subito il lato destro e programma l'aggiornamento del lato sinistro alla fine del passo temporale corrente.

Fuori dai blocchi procedurali (in assign) esiste solo =: assign a <= b è un errore di sintassi. Dentro i blocchi procedurali sono validi entrambi, e scegliere quello giusto è la decisione più importante per chi inizia con Verilog.

Cosa fa l'assegnazione blocking

L'assegnazione blocking si comporta come ti aspetteresti da un linguaggio software: riga per riga, dall'alto in basso. L'istruzione N termina prima che inizi l'istruzione 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

È puramente sequenziale. Ogni istruzione vede gli effetti di quelle precedenti, proprio come suggerisce l'intuizione del software.

Cosa fa l'assegnazione non-blocking

L'assegnazione non-blocking ragiona come l'hardware. Tutti i lati destri vengono valutati con i valori all'inizio del passo temporale. Tutti i lati sinistri si aggiornano alla fine del passo. L'ordine delle istruzioni nel sorgente non cambia le dipendenze tra i segnali:

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

Questo frammento implementa in un solo passo una rotazione a tre a → b → c → a. Con l'assegnazione blocking ti servirebbe una variabile temporanea per non sovrascrivere uno dei valori. Con quella non-blocking lo scambio avviene in modo atomico, perché ogni lato destro legge i valori precedenti al passo.

È esattamente il comportamento di tre flip-flop su un fronte di clock: catturano tutti i propri ingressi nello stesso istante, indipendentemente dalle dipendenze tra loro.

La regola che ti salva

Usa <= nei blocchi sincronizzati. Usa = nei blocchi combinatori.

Tutto qui. Memorizzala. Applicala senza pensarci. La maggior parte delle race condition, delle differenze tra simulazione e sintesi e dei bug del tipo "da me funziona ma in sintesi no" nasce dalla violazione di questa regola.

La regola ha una ragione hardware: i blocchi sincronizzati modellano flip-flop che campionano tutti insieme i propri ingressi, mentre i blocchi combinatori modellano logica che si propaga il più velocemente possibile. La semantica degli operatori di assegnazione rispecchia questi due comportamenti.

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

Ogni <= legge il valore attuale del registro sorgente e programma il registro di destinazione perché assuma quel valore alla fine del passo temporale. L'effetto complessivo è esattamente quello di uno shift register hardware: ogni flip-flop cattura il valore del vicino, tutti sullo stesso fronte di clock, senza race.

Ora guarda cosa sarebbe successo con l'assegnazione blocking:

// 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

Ogni istruzione sovrascrive la sorgente prima che l'istruzione successiva la legga. In un solo ciclo di clock, in si propagherebbe fino a out[3], perché ogni riga vede il valore appena scritto dalla riga precedente. Il comportamento dell'hardware reale (che usa la semantica non-blocking) sarebbe completamente diverso da quello mostrato dal simulatore.

Blocchi combinatori: blocking è la scelta giusta

Per always @(*) l'assegnazione blocking è corretta. Non ci sono flip-flop né una regola di cattura simultanea da rispettare, e le variabili intermedie tornano utili:

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

Prima viene calcolato sum, poi result usa il valore appena calcolato. La logica combinatoria si appiattisce in un unico pezzo di hardware: result = ~(a + b). Non compaiono flip-flop perché non c'è clock.

Se qui usassi <=, il simulatore aggiornerebbe comunque sum prima di valutarci sopra result (perché entrambi gli aggiornamenti avvengono a fine passo), ma l'ordine sarebbe sottilmente diverso e molti strumenti di sintesi protestano. Non mescolarli: scegli l'operatore che corrisponde al tipo di blocco.

L'errore che fa più male

Eccolo: un blocco sincronizzato con assegnazione blocking.

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

In simulazione, il simulatore potrebbe assegnare prima a, poi b, poi c, producendo un certo insieme di valori. L'hardware ne produrrà un altro, perché i flip-flop reali catturano simultaneamente. I due risultati divergono in silenzio e perderai una giornata a trovare il bug. Usa <= nei blocchi sincronizzati.

Perché esistono due operatori

I progettisti di Verilog avrebbero potuto scegliere una sola semantica di assegnazione. Non l'hanno fatto perché il linguaggio deve modellare due comportamenti hardware distinti:

• Logica combinatoria: i segnali si propagano di continuo, le dipendenze contano e chiedersi "cosa calcola questa porta" ha senso.
• Logica sequenziale: arriva un fronte di clock, ogni flip-flop cattura simultaneamente e le dipendenze tra ingressi e uscite dei flip-flop sono disaccoppiate.

L'assegnazione blocking serve per il primo caso, quella non-blocking per il secondo. L'operatore sceglie la semantica; al resto pensa il simulatore.

Cosa viene dopo

Ora hai le regole per scrivere correttamente qualsiasi blocco procedurale. Il prossimo capitolo passa dai singoli blocchi ai costrutti di controllo del flusso che vanno al loro interno: if/else, case e i cicli for. Le regole su blocking e non-blocking valgono anche dentro tutti questi costrutti.