Testbench & Verification cơ bản

Mở đầu: "Nhìn waveform thấy đẹp" không phải là bằng chứng mạch đúng

Bạn vừa viết xong bộ cộng 4-bit, mô phỏng với vài giá trị a=0, b=5 — sóng ra 5, đúng. Thử thêm a=1, b=0 — ra 1, vẫn đúng. Bạn tự tin gõ "done", commit, chuyển sang việc tiếp theo. Ba tuần sau, mạch chạy trên board thật cho kết quả sai lệch ngẫu nhiên. Hoá ra bộ cộng của bạn có lỗi chỉ lộ ra khi 2 bit cùng vị trí của a và b đều bằng 1 (cần cộng có nhớ/carry) — mọi test case bạn thử đều tình cờ né đúng trường hợp đó. Đây không phải chuyện hiếm: phần lớn bug HDL nghiêm trọng nhất đều "trốn" trong đúng những case bạn không nghĩ tới thử.

Bài này chuyển trọng tâm từ "viết mạch" sang "chứng minh mạch đúng" — kỹ năng chiếm đến ~70% công sức của một dự án chip thực tế. Bạn sẽ học cấu trúc testbench cơ bản, vì sao self-checking testbench (máy tự chấm) thay thế được thói quen "nhìn waveform bằng mắt", khái niệm SVA (SystemVerilog Assertions) để viết "hợp đồng hành vi", và coverage — thước đo trả lời câu hỏi "test bao nhiêu là đủ". Cuối bài, bạn tự tay săn 2 con bug được cài sẵn trong 1 bộ cộng bằng chính testbench tự động, y hệt tình huống mở đầu.

1. Vì sao verification chiếm 70% công sức dự án chip?

Chi phí sửa 1 bug tăng theo cấp số nhân tuỳ giai đoạn phát hiện ra nó:

Khác với phần mềm (có thể vá lỗi bằng bản cập nhật), 1 con chip đã in ra silicon không sửa được nữa. Đây là lý do các công ty thiết kế chip dành đội ngũ verification đông đảo, đôi khi đông hơn cả đội thiết kế RTL — phát hiện bug càng sớm, chi phí càng thấp.

2. Cấu trúc testbench cơ bản

Testbench là 1 module SystemVerilog không tổng hợp thành phần cứng — nó chỉ tồn tại trong mô phỏng, với vai trò: khởi tạo DUT (Design Under Test), sinh tín hiệu clock/reset, đưa vào các giá trị đầu vào (stimulus), và quan sát đầu ra.

module adder_tb;
  reg [3:0] a, b;
  wire [3:0] sum;
  wire cout;

  // 1. Instance DUT (Design Under Test)
  adder4 dut (.a(a), .b(b), .sum(sum), .cout(cout));

  // 2. Stimulus: đưa giá trị vào, quan sát bằng $display
  initial begin
    a = 4'd3; b = 4'd1;
    #10; // chờ 10 đơn vị thời gian để tín hiệu ổn định
    $display("a=%d b=%d sum=%d cout=%b", a, b, sum, cout);

    a = 4'd7; b = 4'd9;
    #10;
    $display("a=%d b=%d sum=%d cout=%b", a, b, sum, cout);

    $finish; // kết thúc mô phỏng
  end
endmodule

$display in ra giá trị tại 1 thời điểm; $monitor (biến thể liên quan) tự động in lại mỗi khi bất kỳ tín hiệu trong danh sách theo dõi thay đổi — hữu ích để quan sát liên tục mà không cần gọi lại nhiều lần.

3. Self-checking testbench & Golden Model

Testbench ở Mục 2 chỉ in ra giá trị — bạn vẫn phải tự đọc và so sánh bằng mắt. Đây chính là thói quen nguy hiểm ở phần mở đầu bài. Giải pháp: golden model — 1 đoạn code tính kết quả "đúng tuyệt đối" bằng công thức độc lập (thường đơn giản hơn nhiều so với RTL), rồi để testbench tự so sánh và báo PASS/FAIL, không cần con người nhìn từng dòng số.

module adder_tb_self_checking;
  reg [3:0] a, b;
  wire [3:0] sum;
  wire cout;
  integer errors = 0;

  adder4 dut (.a(a), .b(b), .sum(sum), .cout(cout));

  initial begin
    for (integer i = 0; i < 16; i = i + 1) begin
      for (integer j = 0; j < 16; j = j + 1) begin
        a = i; b = j;
        #10;
        // Golden model: công thức cộng số học thuần, độc lập với RTL
        if (sum !== ((i + j) & 4'hF) || cout !== ((i + j) > 15)) begin
          $display("FAIL: a=%d b=%d sum=%d cout=%b", a, b, sum, cout);
          errors = errors + 1;
        end
      end
    end
    if (errors == 0)
      $display("TAT CA 256 TO HOP DEU DUNG.");
    else
      $display("%0d loi duoc phat hien.", errors);
    $finish;
  end
endmodule

4. SVA — SystemVerilog Assertions cơ bản

Ngoài testbench kiểm tra đầu ra cuối cùng, SystemVerilog còn cho phép viết trực tiếp "hợp đồng hành vi" (behavioral contract) ngay trong code — những điều kiện phải luôn đúng tại mọi thời điểm mô phỏng, gọi là SVA. Đây là điểm mạnh riêng của SystemVerilog so với Verilog cũ.

// Immediate assertion: kiểm tra ngay tại 1 thời điểm, giống if() báo lỗi
always_comb begin
  assert (sum < 5'd16) else $error("sum tràn quá 4-bit!");
end

// Concurrent assertion: kiểm tra 1 QUY LUẬT theo thời gian, đồng bộ với clock
// "Nếu req lên 1, thì trong vòng tối đa 3 chu kỳ clock, ack phải lên 1"
property req_then_ack;
  @(posedge clk) req |-> ##[1:3] ack;
endproperty
assert property (req_then_ack) else $error("Vi pham hop dong req/ack!");

Lưu ý: cú pháp assert property với toán tử thời gian (##[1:3], |->) nằm ngoài tập con VeriLite mà engine của trang này mô phỏng được — đây là code minh hoạ khái niệm, không chạy được trên demo tương tác. Trong công nghiệp thật, các công cụ như Verilator, VCS, hay Questa hiểu đầy đủ cú pháp này.

5. Coverage — Test bao nhiêu là đủ?

Testbench chạy xong, không báo lỗi nào — nhưng liệu bạn đã test đủ chưa, hay chỉ mới chạm một góc nhỏ của không gian trạng thái? Coverage trả lời câu hỏi này bằng số liệu cụ thể:

100% code coverage không đảm bảo hết bug — code có thể chạy qua mọi dòng nhưng vẫn sai logic ở 1 tổ hợp cụ thể (chính là tình huống mở đầu bài: dòng assign sum = ... luôn được "chạy qua" trong mọi test case, chỉ có KẾT QUẢ là sai). Functional coverage bổ sung góc nhìn "kịch bản nào quan trọng cần test", không chỉ "dòng nào đã chạy qua".

6. Demo tương tác: Săn bug trong bộ cộng 4-bit

Bộ cộng dưới đây cài sẵn 2 bug khác nhau (chọn qua nút bên dưới). Bạn có thể test thủ công từng tổ hợp a/b, hoặc bấm "Chạy toàn bộ 256 tổ hợp" để xem self-checking testbench tự phát hiện bug — đúng kỹ thuật vừa học ở Mục 3.

// ✅ Đúng
module adder4_correct (
  input logic [3:0] a, b,
  output logic [3:0] sum,
  output logic cout
);
  assign sum = a + b;
  assign cout = (a + b) > 15;
endmodule

// 🐛 Bug 1: quên cộng có nhớ giữa các bit — chỉ XOR đơn thuần
module adder4_bug1 (
  input logic [3:0] a, b,
  output logic [3:0] sum,
  output logic cout
);
  assign sum = a ^ b;             // SAI: thiếu lan truyền carry giữa các bit
  assign cout = (a + b) > 15;
endmodule

// 🐛 Bug 2: logic tính cờ nhớ (carry-out) sai hoàn toàn
module adder4_bug2 (
  input logic [3:0] a, b,
  output logic [3:0] sum,
  output logic cout
);
  assign sum = a + b;
  assign cout = a > b;            // SAI: không liên quan gì tới tràn số
endmodule

Tóm lược

Bài này chuyển trọng tâm từ "viết mạch" sang "chứng minh mạch đúng":

• ✅ Verification chiếm ~70% công sức dự án — bug phát hiện càng muộn, chi phí sửa càng cao theo cấp số nhân.
• ✅ Testbench: instance DUT, sinh stimulus, quan sát bằng $display/$monitor.
• ✅ Self-checking testbench + golden model thay thế "nhìn waveform bằng mắt" — máy tự so sánh, quét hết mọi tổ hợp không mệt mỏi.
• ✅ SVA viết "hợp đồng hành vi" trực tiếp trong code — immediate và concurrent assertion.
• ✅ Coverage (code + functional) trả lời "test bao nhiêu là đủ", không chỉ "có lỗi hay không".

Bài tiếp theo đi sâu vào số học phần cứng — cách các bộ cộng thật (ripple-carry, carry-lookahead) được xây dựng, và đánh đổi tốc độ/diện tích giữa chúng.

Trắc nghiệm ôn tập