Giá trị x và z trong Verilog: không xác định và trở kháng cao

Logic hai trạng thái và bốn trạng thái

Trong phần mềm, một bit là 0 hoặc 1. Trong Verilog, một bit có thể mang một trong bốn giá trị:

• 0: dây được kéo xuống mức thấp.
• 1: dây được kéo lên mức cao.
• x: giá trị của dây không xác định. Trình mô phỏng không biết được.
• z: dây ở trạng thái trở kháng cao. Không có gì điều khiển nó.

Mô hình bốn trạng thái này tồn tại vì phần cứng cũng gặp đúng vấn đề đó. Một sợi dây thật có thể được nối xuống thấp, nối lên cao, không xác định (bị hai nguồn kéo ngược nhau), hoặc thả nổi (không có nguồn điều khiển nào). Trình mô phỏng phải mô hình hóa cả bốn thì mới hữu ích.

x xuất hiện như thế nào

Chạy đoạn này và xem đầu ra:

module unknown_demo;
    reg [3:0] a;
    reg [3:0] b;
    wire [3:0] c;

    // `a` is never assigned.
    assign c = a + b;

    initial begin
        b = 4'd5;
        #1 $display("a=%b b=%b c=%b", a, b, c);
        $finish;
    end
endmodule

a được khai báo nhưng chưa bao giờ được ghi, nên nó nằm ở x. Cộng x + 5 cho ra x: mọi phép tính số học với giá trị không xác định đều cho kết quả không xác định. Đầu ra toàn là x, đúng bằng độ rộng của a.

Những nguồn x thường gặp trong thiết kế của bạn:

• Một reg được khai báo nhưng không bao giờ reset (phần lớn Verilog tổng hợp được dùng một tín hiệu reset tường minh để xóa chúng).
• Một câu lệnh case không có default, gặp giá trị đầu vào không khớp nhánh nào.
• Một wire mất nguồn điều khiển duy nhất sau khi refactor.
• Một chuỗi if/else mà một nhánh không gán tín hiệu mà nhánh kia có gán (sinh latch mang x nếu không được phủ hết).
• Đọc vượt quá cuối một vector hoặc mảng.

Lan truyền x: chỉ một chút x cũng làm hỏng tất cả

Điều tàn nhẫn ở x là nó lan truyền. Chỉ một bit x trong một toán hạng là cả kết quả thành x:

module x_propagation;
    initial begin
        $display("0       & 1'bx = %b", 1'b0 & 1'bx);   // 0 - the AND identity wins
        $display("1       & 1'bx = %b", 1'b1 & 1'bx);   // x
        $display("1       | 1'bx = %b", 1'b1 | 1'bx);   // 1 - the OR identity wins
        $display("0       | 1'bx = %b", 1'b0 | 1'bx);   // x
        $display("0       + 1'bx = %b", 1'b0 + 1'bx);   // x - arithmetic always taints
        $display("4'hF    & 4'bxx10 = %b", 4'hF & 4'bxx10);
        $finish;
    end
endmodule

Để ý rằng 0 & x là 0 (AND với 0 luôn ra 0) và 1 | x là 1 (OR với 1 luôn ra 1). Trình mô phỏng bi quan theo từng bit nhưng vẫn tôn trọng các đồng nhất thức. Phép số học và phép so sánh thì không rộng lượng như vậy.

Đây là lý do một thanh ghi chưa khởi tạo duy nhất có thể khiến cả bus đầu ra thành xxxx. Lần ngược từ bất kỳ x nào, bạn sẽ tìm thấy nguồn gốc.

z xuất hiện như thế nào

z là giá trị của một dây không có ai điều khiển:

module z_demo;
    wire [3:0] floating;   // declared, no driver
    reg  enable;
    wire data_out;
    reg  data;

    // A tri-state output: drives `data` when `enable` is high, releases when low.
    assign data_out = enable ? data : 1'bz;

    initial begin
        $display("floating = %b", floating);   // zzzz

        enable = 1; data = 1; #1 $display("driven:  data_out = %b", data_out);
        enable = 0;            #1 $display("released:data_out = %b", data_out);
        $finish;
    end
endmodule

Hai mẫu trong đoạn code trên:

• floating chỉ được khai báo và không bao giờ được điều khiển. Nó mặc định là z.
• data_out là một đầu ra ba trạng thái có chủ đích. Khi enable ở mức thấp, đầu ra chủ động nhả về z. Đó là cách một bộ điều khiển bus "buông tay" để bộ khác tiếp quản.

Trên logic nội bộ, z gần như luôn sai. Trên chân hai chiều hoặc bus dùng chung, z lại hoàn toàn đúng.

So sánh bằng == và ===

Toán tử so sánh bằng thông thường == trả về x khi một trong hai toán hạng có bit x hoặc z:

module compare_demo;
    initial begin
        $display("1'b1 == 1'b1 = %b", 1'b1 == 1'b1);     // 1
        $display("1'b1 == 1'bx = %b", 1'b1 == 1'bx);     // x  - not useful
        $display("1'bx == 1'bx = %b", 1'bx == 1'bx);     // x  - also not useful

        $display("1'b1 === 1'b1 = %b", 1'b1 === 1'b1);   // 1
        $display("1'b1 === 1'bx = %b", 1'b1 === 1'bx);   // 0
        $display("1'bx === 1'bx = %b", 1'bx === 1'bx);   // 1

        $display("$isunknown(1'bx) = %b", $isunknown(1'bx));   // 1
        $finish;
    end
endmodule

=== (và bạn đồng hành !==) so sánh nghiêm ngặt từng bit, kể cả x và z. Dùng nó mỗi khi cần kiểm tra có phải x/z hay không trong testbench. === không tổng hợp được, nhưng bên trong khối initial của testbench thì điều đó không quan trọng.

Hàm hệ thống $isunknown(expr) là cách gọn nhất để hỏi "biểu thức này có bit x hoặc z nào không?": trả về 1 nếu có, 0 nếu không.

Dùng x làm giá trị "không quan tâm" có chủ đích

Một mẫu gây tranh cãi nhưng hợp lệ: 'x trong nhánh default của một máy trạng thái báo cho công cụ tổng hợp rằng "trạng thái này không thể tới được, cứ tối ưu thoải mái":

case (state)
    IDLE:    next_state = go ? RUNNING : IDLE;
    RUNNING: next_state = done ? IDLE : RUNNING;
    default: next_state = 'x;   // unreachable
endcase

Công cụ tổng hợp có thể dùng x để gộp trạng thái và giảm số cổng logic. Khi mô phỏng, nếu lập luận của bạn sai và nhánh default thực sự được chạy tới, bạn sẽ thấy x lan ra từ next_state và bug lộ ra ngay lập tức.

Chỉ dùng cách này khi bạn đã suy nghĩ kỹ xem nhánh default có thật sự không thể tới được hay không. Nếu chưa, hãy đặt default về một trạng thái an toàn.

Quy trình gỡ lỗi thường dùng

Bạn đang nhìn một dạng sóng đầy x. Quy trình như sau:

1. Tìm x sớm nhất. Lần ngược dạng sóng theo thời gian. Tín hiệu thành x sớm nhất là tín hiệu gần nguồn gốc nhất.
2. Tìm nguồn điều khiển của nó. Mở mã nguồn. Cái gì gán cho tín hiệu này? Một assign? Một khối always?
3. Kiểm tra đầu vào của nguồn điều khiển. Nếu vế phải có bất kỳ x nào, sự lan truyền đang làm đúng việc của nó: bug nằm ở phía trước.
4. Nếu đầu vào sạch mà nguồn điều khiển vẫn tạo ra x, nguồn điều khiển đó chưa đầy đủ. Một case thiếu default, một if thiếu else, một thanh ghi thiếu reset.

Hầu hết các bug "bão x" quy về một trong ba nguyên nhân: thiếu reset, thiếu default, hoặc một module con chưa được nối.

Tiếp theo

Giờ bạn đã có trọn bộ câu chuyện về kiểu dữ liệu: wire/reg, vector, tham số, hằng số dạng số và mô hình logic bốn trạng thái. Chương tiếp theo bắt đầu dùng tất cả những thứ đó để xây dựng biểu thức: đủ loại toán tử, kể cả các toán tử mức bit vốn chẳng có ý nghĩa gì trong phần mềm.