Wire vs Reg di Verilog: Kapan Memakai Masing-Masing (dengan Contoh)

Dua Nama, Satu Tugas

Setiap sinyal di Verilog punya tipe. Dua tipe yang pertama kali akan kamu temui adalah wire dan reg. Keduanya bisa menyimpan nilai. Keduanya bisa satu bit atau banyak bit. Perbedaannya bukan soal apa sinyal itu, melainkan soal siapa yang menggerakkannya.

• Sinyal wire digerakkan di luar blok prosedural: oleh pernyataan assign, oleh output sub-module, atau oleh port input module.
• Sinyal reg digerakkan di dalam blok prosedural, yaitu initial atau always.

Itulah seluruh aturannya. Nama kata kuncinya terasa janggal karena lebih tua daripada cara menulis Verilog modern. reg tidak selalu menjadi register di hardware. Baca terus untuk tahu alasannya.

Wire: Koneksi Kontinu

wire adalah kabel listrik. Ia membawa apa pun yang dihasilkan penggeraknya, terus-menerus. Ada dua cara sebuah wire digerakkan:

module wires(input wire a, input wire b, output wire y, output wire z);
    // Driven by a continuous assignment.
    assign y = a & b;

    // Driven by a sub-module output - shown for completeness.
    // (the actual sub-module is omitted here)
    assign z = a | b;
endmodule

module test;
    reg a, b;
    wire y, z;

    wires dut(.a(a), .b(b), .y(y), .z(z));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            {a, b} = i[1:0];
            #1 $display("a=%b b=%b y=%b z=%b", a, b, y, z);
        end
        $finish;
    end
endmodule

Tiga hal yang perlu diperhatikan:

• y dan z dideklarasikan sebagai wire di module dan sebagai wire lagi di testbench.
• Keduanya digerakkan oleh assign, yaitu bentuk penugasan kontinu. Sisi kanan = dihitung ulang setiap kali ada sinyal di dalamnya yang berubah.
• Kita tidak bisa menulis y = a & b di dalam blok always selama y tetap bertipe wire. Compiler akan menolaknya.

Kalau kamu lupa kata kunci wire, Verilog akan secara implisit mendeklarasikan sinyal itu sebagai wire satu bit untukmu. Kadang ini praktis, kadang menjadi bug yang diam-diam. Kebanyakan tim mengaktifkan opsi tool yang memunculkan error untuk wire implisit. Tulis secara eksplisit dan hindari jebakan ini.

Reg: Penyimpanan di Dalam Blok Prosedural

reg adalah sinyal yang kamu beri nilai di dalam initial atau always. Namanya adalah peninggalan masa awal bahasa ini, saat "reg" terdengar seperti "register"; dalam pemakaian modern, reg hanyalah tipe dari sinyal apa pun yang ditulis oleh kode prosedural.

module regs(input wire clk, input wire reset, output reg [3:0] count);
    always @(posedge clk) begin
        if (reset) count <= 0;
        else       count <= count + 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [3:0] count;

    regs dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #80 $finish;
    end

    always @(posedge clk) $display("t=%0t count=%0d", $time, count);
endmodule

count bertipe reg di dalam module (karena blok always menulis ke sana) dan wire di testbench (karena port output DUT yang menggerakkannya). Sinyal yang sama, peran berbeda, tipe berbeda di setiap scope.

Kenapa "Reg" Tidak Selalu Berarti "Register"

Inilah jebakan pemula yang paling umum. Module ini mendeklarasikan y sebagai reg, tapi hardware hasil sintesisnya tidak berisi flip-flop:

module not_a_register(input wire a, input wire b, output reg y);
    always @(*) begin
        y = a & b;
    end
endmodule

module test;
    reg a, b;
    wire y;

    not_a_register dut(.a(a), .b(b), .y(y));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            {a, b} = i[1:0];
            #1 $display("a=%b b=%b y=%b", a, b, y);
        end
        $finish;
    end
endmodule

Blok always @(*) peka terhadap perubahan input apa pun. Blok ini kombinasional. Tool sintesis mengenali pola itu dan menghasilkan sebuah gerbang AND: tanpa flip-flop, tanpa clock, hanya logika. Kata kunci reg murni syarat sintaks, karena y diberi nilai di dalam always.

Untuk mendapatkan flip-flop sungguhan, blok always harus peka terhadap tepi clock:

always @(posedge clk) begin
    q <= d;
end

Itulah pola "tolong buatkan flip-flop" untuk tool sintesis: sensitivity list dengan clock, penugasan non-blocking. Kata kunci reg yang sama, hardware yang sama sekali berbeda. Kita membahas perbedaannya di Blok Always dan Blocking vs Non-blocking.

Keputusannya dalam Praktik

Setiap kali kamu mendeklarasikan sinyal, tanyakan: bagaimana aku akan menggerakkannya?

• Digerakkan dengan assign? → wire.
• Dihubungkan ke port output sub-module? → wire.
• Port input module? → wire. (Input selalu wire.)
• Digerakkan dari initial atau always? → reg.
• Port output module yang digerakkan kode prosedural? → output reg.
• Port output module yang digerakkan assign? → output wire. (Atau cukup output, karena arah saja sudah membuat default-nya wire.)

Pohon keputusan itu mencakup setiap situasi yang akan kamu temui di Verilog biasa.

Konflik Penggerak

Secara teori, sinyal wire bisa punya banyak penggerak. Begitulah cara kerja bus tri-state, di mana beberapa module bisa menggerakkan kabel yang sama dan yang tidak aktif beralih ke impedansi tinggi (z). Untuk logika biasa, dua pernyataan assign yang menulis ke wire yang sama menghasilkan perilaku yang tidak terdefinisi:

assign y = a;
assign y = b;   // BAD - y has two drivers

Simulator mungkin memilih salah satu, mungkin membuat sinyalnya menjadi X, tergantung tool-nya. Bagaimanapun juga, itu bug. Satu penggerak untuk setiap wire, kecuali kamu memang sengaja membangun bus.

Sinyal reg hanya bisa digerakkan dari satu blok prosedural. Dua blok always yang sama-sama memberi nilai ke reg yang sama adalah error sintesis dan berperilaku aneh di simulasi. Aturannya sama: satu penggerak.

Pembaruan SystemVerilog: logic

SystemVerilog (superset yang menjadi kelanjutan Verilog) menambahkan satu kata kunci yang menggantikan keduanya: logic. Sinyal logic bisa digerakkan oleh assign atau oleh blok prosedural (tapi tidak keduanya), dan compiler mencegahmu tanpa sengaja membuat bug banyak penggerak.

module modern(input logic a, input logic b, output logic y);
    assign y = a ^ b;
endmodule

Kalau kamu memulai proyek dari nol dan tool-mu mendukung SystemVerilog (editor di halaman ini mendukungnya, dengan -g2012), memakai logic di mana-mana menyederhanakan aturannya. File .v biasa tetap butuh pemisahan wire/reg, dan kamu akan terus melihat kedua gaya itu di luar sana.

Selanjutnya

Dokumen berikutnya, Vektor dan Array, memakai dua tipe yang sama dan menunjukkan cara membuatnya menjadi banyak bit. Lebar bus, rentang, dimensi packed, perbedaan antara vektor bit dan array berisi vektor. Semua hal yang kamu butuhkan sebelum bisa membangun sesuatu yang lebih besar dari adder satu bit.