Vector và mảng trong Verilog: giải thích tín hiệu nhiều bit

Một dây hay nhiều dây

Đến giờ mọi tín hiệu chúng ta thấy đều rộng 1 bit. Thiết kế thật gần như không bao giờ như vậy: địa chỉ là 16 hoặc 32 bit, bus dữ liệu là 8 hoặc 64 bit, điểm ảnh RGB là 24 bit. Verilog cho bạn một cơ chế duy nhất để biến bất kỳ tín hiệu nào thành nhiều bit: thêm một khoảng trong ngoặc vuông.

wire [7:0] data;       // 8-bit wire, bit 7 is MSB, bit 0 is LSB
reg  [15:0] address;   // 16-bit reg
output reg [31:0] result; // 32-bit module output

Các số trong ngoặc vuông là vị trí bit của bit có trọng số cao nhất và thấp nhất. [7:0] nghĩa là "tín hiệu này có các bit đánh số từ 7 xuống 0", tổng cộng là 8 bit. Số thứ nhất là chỉ số cao. Số thứ hai là chỉ số thấp.

Thỉnh thoảng bạn sẽ thấy [0:7]: cùng số bit, nhưng thứ tự ngược lại khi cắt lát. Dạng [high:low] là quy ước áp đảo trong ngành; hãy dùng nó trừ khi bạn có lý do thật thuyết phục.

Ví dụ minh họa: bộ cộng 8 bit

module adder8(
    input  wire [7:0] a,
    input  wire [7:0] b,
    output wire [8:0] sum
);
    // 8 bits + 8 bits can produce a 9-bit result (a carry out).
    assign sum = a + b;
endmodule

module test;
    reg  [7:0] a, b;
    wire [8:0] sum;

    adder8 dut(.a(a), .b(b), .sum(sum));

    initial begin
        a = 8'd10;  b = 8'd20;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd200; b = 8'd100;  #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'hFF;  b = 8'h01;   #1 $display("%h + %h = %h",   a, b, sum);
        $finish;
    end
endmodule

Mỗi phép + cộng hai vector 8 bit và cho kết quả 9 bit. Các hằng số như 8'd10 có nghĩa là "giá trị thập phân 10 rộng 8 bit": chúng ta sẽ nói về chúng trong bài Hằng số dạng số.

Cắt lát: lấy ra từng bit

Khi đã có một vector, bạn có thể lấy ra từng bit hoặc một khoảng liên tiếp:

module slicing(input wire [15:0] data);
    initial begin
        $display("full data   = %b", data);
        $display("low byte    = %b", data[7:0]);
        $display("high byte   = %b", data[15:8]);
        $display("nibble[3:1] = %b", data[3:1]);
        $display("bit 9       = %b", data[9]);
    end
endmodule

module test;
    initial begin
        force test.dut.data = 16'b1010_1100_0011_0101;
        #1 $finish;
    end

    slicing dut();
endmodule

Đừng bận tâm đến dòng force trong testbench: chúng ta chỉ cần một cách đưa giá trị vào để minh họa việc cắt lát. Phần thú vị là chính các lát cắt.

Vài quy tắc:

• Chiều của lát cắt phải khớp với khai báo. Nếu bạn khai báo [7:0], hãy cắt theo [high:low]. Đảo chiều là lỗi cú pháp.
• Cắt ra ngoài khoảng sẽ cho x (không xác định) khi mô phỏng. Công cụ tổng hợp có thể cảnh báo hoặc báo lỗi.
• Việc chọn bit dựa trên chỉ số bạn đã viết: data[0] là bit mang số 0, mà (với khai báo [7:0]) chính là LSB.

Lát cắt với điểm bắt đầu thay đổi: +: và -:

Một nhu cầu phổ biến: "lấy 8 bit bắt đầu từ bit N". Bạn không thể viết trực tiếp data[N+7:N] vì Verilog yêu cầu cả hai đầu khoảng phải là hằng số. Cú pháp giải quyết việc này:

data[base +: width]   // width bits starting at `base`, going UP
data[base -: width]   // width bits starting at `base`, going DOWN

module variable_slice;
    reg [31:0] word = 32'hDEAD_BEEF;

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            $display("byte %0d = %h", i, word[i*8 +: 8]);
        end
        $finish;
    end
endmodule

Độ rộng là hằng số (chúng ta lấy 8 bit mỗi lần), nhưng điểm bắt đầu có thể là một biểu thức lúc chạy. Đó chính là thứ bạn cần cho bộ nhớ đánh địa chỉ theo byte, các điểm lấy tín hiệu của thanh ghi dịch, v.v.

Mảng: một bước xa hơn vector

Vector là một tín hiệu nhiều bit. Mảng là tập hợp các vector, được đánh chỉ số độc lập:

reg [31:0] mem [0:1023];

Khai báo đó có hai khoảng, và hai khoảng này mang ý nghĩa khác nhau:

• [31:0] là chiều packed: độ rộng của mỗi word.
• [0:1023] là chiều unpacked: có bao nhiêu word.

Vậy mem là 1024 thanh ghi 32 bit riêng biệt. Bạn truy cập một thanh ghi bằng một chỉ số:

mem[5] = 32'hCAFE_BABE;       // write word 5
data   = mem[address];        // read the word at `address`

module memory_demo;
    reg [7:0] mem [0:7];   // 8 bytes
    integer i;

    initial begin
        for (i = 0; i < 8; i = i + 1) mem[i] = i * i;

        for (i = 0; i < 8; i = i + 1)
            $display("mem[%0d] = %0d", i, mem[i]);

        $finish;
    end
endmodule

Đó là một bộ nhớ nhỏ chứa các số chính phương. Thiết kế thật dùng cùng mẫu này để chứa tệp thanh ghi, bảng tra cứu, FIFO và mọi loại bộ nhớ trên chip lớn hơn một vector.

Packed và unpacked: vì sao quan trọng

Sự phân chia giữa chiều packed và unpacked xuất hiện ở khắp nơi. Biết rõ cái nào là cái nào giúp bạn đỡ mất rất nhiều thời gian gỡ lỗi:

• Vector packed là một tín hiệu. Bạn có thể coi toàn bộ nó là một số: data + 1 chạy được, data == 32'h0 chạy được, data[7:0] chạy được.
• Mảng unpacked là nhiều tín hiệu. Bạn không thể coi toàn bộ nó là một số: mem + 1 là lỗi cú pháp. Bạn phải chọn ra một word cụ thể trước.

Nhiều chiều packed cũng hợp lệ:

reg [3:0][7:0] regs;   // 4 bytes packed together into a 32-bit signal

regs[0] là một byte (byte thấp). Toàn bộ regs là 32 bit. SystemVerilog dùng cách này rất nhiều.

Nhiều chiều unpacked tạo ra bộ nhớ 2 chiều:

reg [31:0] frame [0:479][0:639];  // 480x640 of 32-bit pixels

Bạn truy cập một điểm ảnh bằng frame[y][x]. Bộ đệm ảnh trong HDL sẽ trông như vậy.

Tiếp theo là gì

Giờ bạn đã có thể khai báo và thao tác với tín hiệu có độ rộng bất kỳ. Bài tiếp theo, Tham số, cho bạn thấy cách làm các độ rộng đó có thể cấu hình, để cùng một module chạy với 8 bit ở instance này và 32 bit ở instance khác. Sau đó chúng ta sẽ chuyển sang quy tắc viết hằng số (8'b1010_1100, 32'hDEAD_BEEF) và các giá trị x/z xuất hiện mỗi khi có thứ gì đó không được điều khiển.