Penugasan Blocking vs Non-Blocking di Verilog: Kapan Memakai = vs <=

Dua Operator

Di dalam blok always dan initial, Verilog punya dua operator penugasan:

• = adalah penugasan blocking. Perbarui LHS sekarang, sebelum lanjut ke pernyataan berikutnya.
• <= adalah penugasan non-blocking. Evaluasi RHS sekarang, lalu jadwalkan LHS untuk diperbarui di akhir langkah waktu saat ini.

Di luar blok prosedural (di assign) hanya ada =: assign a <= b adalah syntax error. Di dalam blok prosedural, keduanya sah, dan memilih yang tepat adalah keputusan terpenting bagi pemula Verilog.

Apa yang Dilakukan Blocking

Blocking berperilaku seperti yang kamu harapkan dari bahasa software: baris demi baris, dari atas ke bawah. Pernyataan N selesai sebelum pernyataan N+1 dimulai:

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

Ini murni berurutan. Setiap pernyataan melihat efek dari pernyataan di atasnya. Itu sesuai dengan intuisi software.

Apa yang Dilakukan Non-Blocking

Non-blocking dibentuk mengikuti hardware. Semua sisi kanan dievaluasi memakai nilai di awal langkah waktu. Semua sisi kiri diperbarui di akhir langkah waktu. Urutan pernyataan di kode sumber tidak mengubah ketergantungan antarsinyal:

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

Potongan kode itu menjalankan rotasi tiga arah a → b → c → a dalam satu langkah. Dengan blocking, kamu butuh variabel sementara agar salah satunya tidak tertimpa. Dengan non-blocking, pertukarannya terjadi sekaligus karena setiap RHS membaca nilai sebelum langkah itu.

Persis seperti itulah tiga flip-flop berperilaku di tepi clock: semuanya menangkap input-nya pada saat yang sama, apa pun ketergantungan di antara mereka.

Aturan yang Menyelamatkanmu

Pakai <= di blok yang dikendalikan clock. Pakai = di blok kombinasional.

Itu saja. Hafalkan. Tulis tanpa perlu berpikir. Sebagian besar race condition, ketidakcocokan simulasi dan sintesis, serta bug "di tempatku jalan, tapi tidak setelah sintesis" berasal dari pelanggaran aturan ini.

Aturan ini punya alasan di hardware: blok yang dikendalikan clock memodelkan flip-flop yang semuanya mengambil sampel input-nya bersamaan. Blok kombinasional memodelkan logika yang merambat secepat mungkin. Semantik operator penugasannya sesuai dengan kedua perilaku itu.

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

Setiap <= membaca nilai register sumber saat ini dan menjadwalkan register tujuan untuk menerima nilai itu di akhir langkah waktu. Hasil akhirnya persis seperti yang dilakukan shift register di hardware: setiap flip-flop menangkap nilai tetangganya, semuanya di tepi clock yang sama, tanpa race.

Sekarang bayangkan apa yang terjadi kalau memakai penugasan 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

Setiap pernyataan menimpa sumbernya sebelum pernyataan berikutnya membacanya. Dalam satu siklus clock, in akan merambat sampai ke out[3], karena setiap baris melihat nilai yang baru saja ditulis oleh baris di atasnya. Perilaku di hardware sungguhan (yang memakai semantik non-blocking) akan sangat berbeda dari yang ditunjukkan simulator.

Blok Kombinasional: Blocking Itu Benar

Untuk always @(*), penugasan blocking adalah yang benar. Tidak ada flip-flop, tidak ada aturan penangkapan serentak yang perlu ditegakkan, dan variabel perantara berguna:

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 dihitung lebih dulu, lalu result memakai nilai yang baru saja dihitung. Logika kombinasionalnya menjadi satu potong hardware: result = ~(a + b). Tidak ada flip-flop yang muncul karena tidak ada clock.

Kalau kamu memakai <= di sini, simulator tetap akan memperbarui sum sebelum result dievaluasi terhadapnya (karena kedua pembaruan terjadi di akhir langkah), tapi urutannya akan sedikit berbeda dan banyak tool sintesis akan mengeluh. Jangan dicampur; pilih operator yang sesuai dengan jenis bloknya.

Kesalahan yang Paling Menyakitkan

Ini dia: blok yang dikendalikan clock dengan penugasan blocking.

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

Di simulasi, simulator mungkin memproses a dulu, lalu b, lalu c, dan menghasilkan satu set nilai. Hardware akan menghasilkan set nilai yang lain, karena flip-flop sungguhan menangkap secara bersamaan. Keduanya diam-diam berbeda, dan kamu akan membuang satu hari untuk mencari bug-nya. Pakai <= di blok yang dikendalikan clock.

Kenapa Ada Dua Operator

Para perancang Verilog bisa saja memilih satu semantik penugasan dan memakainya terus. Mereka tidak melakukannya, karena bahasa ini harus memodelkan dua perilaku hardware yang berbeda:

• Logika kombinasional: sinyal merambat terus-menerus, ketergantungan itu penting, pertanyaan "apa yang dihitung gerbang ini" masuk akal.
• Logika sekuensial: tepi clock terjadi, setiap flip-flop menangkap secara bersamaan, ketergantungan antara input dan output flip-flop terlepas satu sama lain.

Blocking untuk yang pertama. Non-blocking untuk yang kedua. Operatornya memilih semantik; simulator mengerjakan sisanya.

Selanjutnya

Sekarang kamu punya aturan untuk menulis blok prosedural apa pun dengan benar. Bab berikutnya naik dari blok-blok tunggal ke konstruksi alur kontrol yang ada di dalamnya: if/else, case, dan loop for. Aturan blocking vs non-blocking tetap berlaku di dalam semuanya.