Wektory i tablice w Verilogu: sygnały wielobitowe

Jeden wire a wiele

Dotąd każdy sygnał, który widzieliśmy, miał szerokość jednego bitu. Prawdziwe projekty prawie nigdy tak nie wyglądają: adresy mają 16 lub 32 bity, magistrale danych 8 lub 64, piksele RGB 24. Verilog daje jeden mechanizm, który zamienia dowolny sygnał w wielobitowy: dodanie zakresu w nawiasach kwadratowych.

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

Liczby w nawiasach to pozycje bitów najbardziej i najmniej znaczącego bitu. [7:0] oznacza "ten sygnał ma bity ponumerowane od 7 w dół do 0", co daje łącznie 8 bitów. Pierwsza liczba to wyższy indeks. Druga to niższy.

Czasem zobaczysz zamiast tego [0:7]: ta sama liczba bitów, ale odwrotna kolejność przy wycinaniu. Forma [high:low] to zdecydowanie dominująca konwencja w branży. Trzymaj się jej, chyba że masz mocny powód, żeby tego nie robić.

Przykład w praktyce: 8-bitowy sumator

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

Każdy + dodaje dwa 8-bitowe wektory i daje 9-bitowy wynik. Literały liczbowe takie jak 8'd10 oznaczają "wartość dziesiętna 10 o szerokości 8 bitów". Omówimy je w części Literały liczbowe.

Wycinanie: wybieranie bitów

Mając wektor, możesz wyciągnąć z niego pojedyncze bity albo ciągłe zakresy:

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

Nie przejmuj się linią force w testbenchu: potrzebujemy po prostu sposobu, żeby wstrzyknąć wartość i pokazać wycinanie. Ciekawe są same wycinki.

Kilka zasad:

• Kierunek wycinka musi zgadzać się z deklaracją. Jeśli zadeklarowano [7:0], wycinasz przez [high:low]. Odwrócenie kierunku to błąd składni.
• Wycinanie poza zakresem daje w symulacji x (wartość nieznaną). Narzędzie do syntezy może zgłosić ostrzeżenie albo błąd.
• Wybór bitu opiera się na indeksie, który napisano w deklaracji: data[0] to bit o numerze 0, który (przy deklaracji [7:0]) jest bitem LSB.

Wycinki o zmiennej bazie: +: i -:

Częsta potrzeba: "daj mi 8 bitów zaczynając od bitu N". Nie możesz napisać wprost data[N+7:N], bo Verilog wymaga, żeby oba końce zakresu były stałymi. Rozwiązuje to taka składnia:

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

Szerokość jest stała (za każdym razem bierzemy 8 bitów), ale baza może być wyrażeniem obliczanym w czasie działania. Dokładnie tego potrzebujesz przy pamięciach adresowanych bajtowo, odczepach rejestrów przesuwnych i tak dalej.

Tablice: krok dalej niż wektory

Wektor to pojedynczy sygnał wielobitowy. Tablica to zbiór wektorów indeksowanych niezależnie:

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

Ta deklaracja ma dwa zakresy i każdy z nich oznacza coś innego:

• [31:0] to wymiar packed: szerokość każdego pojedynczego słowa.
• [0:1023] to wymiar unpacked: liczba słów.

Zatem mem to 1024 osobne 32-bitowe rejestry. Do jednego z nich odwołujesz się jednym indeksem:

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

To malutka pamięć przechowująca kwadraty liczb. Prawdziwe projekty używają tego samego wzorca do plików rejestrów, tablic przeglądowych, kolejek FIFO i każdej innej pamięci na chipie, która jest większa niż pojedynczy wektor.

Packed a unpacked: dlaczego to ważne

Podział na wymiary packed i unpacked pojawia się wszędzie. Wiedza, który jest który, oszczędza sporo debugowania:

• Wektor packed to jeden sygnał. Możesz traktować go w całości jak liczbę: data + 1 działa, data == 32'h0 działa, data[7:0] działa.
• Tablica unpacked to wiele sygnałów. Nie możesz traktować jej w całości jak liczby: mem + 1 to błąd składni. Najpierw musisz wybrać konkretne słowo.

Dozwolonych jest też kilka wymiarów packed:

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

regs[0] to bajt (najniższy bajt). regs jako całość ma 32 bity. SystemVerilog intensywnie z tego korzysta.

Kilka wymiarów unpacked tworzy pamięć dwuwymiarową:

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

Do pojedynczego piksela odwołujesz się przez frame[y][x]. Tak wyglądałby bufor obrazu w HDL.

Co dalej

Potrafisz już deklarować sygnały o dowolnej potrzebnej szerokości i nimi operować. Następna strona, Parametry, pokazuje, jak uczynić te szerokości konfigurowalnymi, żeby ten sam moduł działał z 8 bitami w jednej instancji i z 32 w innej. Potem przejdziemy do zasad zapisywania literałów liczbowych (8'b1010_1100, 32'hDEAD_BEEF) oraz wartości x/z, które pojawiają się zawsze, gdy coś nie jest sterowane.