Blok initial w Verilogu: kod startowy na początku symulacji

Jednorazowy blok proceduralny

initial begin ... end to rodzeństwo always. Różnica: initial wykonuje się dokładnie raz, zaczynając w chwili 0, a potem się kończy. Nie ma listy czułości ani zapętlenia.

Istnieje z jednego powodu: przygotowania testbencha. Ustawianie wartości początkowych, uruchamianie pobudzenia, otwieranie plików logów, wywołanie $finish po ustalonym czasie symulacji, czyli wszystko, co ma się wydarzyć raz na początku przebiegu w znanej kolejności.

module simple_init;
    reg [7:0] data;

    initial begin
        $display("hello at time %0t", $time);
        data = 8'hA5;
        #10;
        $display("after 10 time units, data = %h", data);
        $finish;
    end
endmodule

Prześledź, co robi symulator:

1. Czas przechodzi do 0.
2. Blok initial startuje. Pierwszy $display wypisuje tekst.
3. data przyjmuje wartość 8'hA5.
4. #10 przesuwa czas symulacji o 10 jednostek.
5. Drugi $display wypisuje tekst.
6. $finish kończy symulację.

Blok wykonał się raz. Nie ma drugiego przebiegu.

Kanoniczny szkielet testbencha

Prawie każdy testbench, jaki napiszesz, używa takiego bloku initial:

module dut(
    input  wire        clk,
    input  wire        reset,
    input  wire [3:0]  in,
    output reg  [3:0]  out
);
    always @(posedge clk) begin
        if (reset) out <= 4'd0;
        else       out <= in;
    end
endmodule

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

    dut u_dut(.clk(clk), .reset(reset), .in(in), .out(out));

    // Clock generator - separate initial/always to keep clean.
    always #5 clk = ~clk;

    // Stimulus and lifecycle.
    initial begin
        $dumpfile("dump.vcd");
        $dumpvars(0, test);

        // Apply reset for 2 cycles.
        in = 4'd0;
        #20 reset = 0;

        // Drive stimulus.
        in = 4'd1; #10;
        in = 4'd5; #10;
        in = 4'd9; #10;
        in = 4'hF; #10;

        $display("done at %0t", $time);
        $finish;
    end
endmodule

Przyjrzyj się kształtowi, bo to szablon testbencha, po który będziesz sięgać za każdym razem:

1. Otwórz plik zapisu VCD ($dumpfile, $dumpvars), omówiony w artykule Dumpfile i VCD.
2. Ustaw wartości początkowe i trzymaj reset przez kilka cykli.
3. Podawaj pobudzenie jako serię zmian przeplatanych opóźnieniami #.
4. $finish, żeby czysto zakończyć symulację.

To wszystko. Każdy test w Verilogu, jaki zobaczysz, łącznie z przykładami od producentów, stosuje ten wzorzec.

Kilka bloków initial działa równolegle

Kilka bloków initial w tym samym module startuje w chwili 0 jednocześnie. Każdy wykonuje własne instrukcje we własnym przedziale czasu:

module parallel_init;
    initial begin
        #5  $display("[A] at time %0t", $time);
        #10 $display("[A] at time %0t", $time);
    end

    initial begin
        $display("[B] at time %0t", $time);   // prints first
        #2  $display("[B] at time %0t", $time);
        #20 $finish;
    end
endmodule

Symulator uruchamia oba bloki w chwili 0. Pierwszy $display bloku B wykonuje się od razu. Blok A czeka 5 jednostek przed wypisaniem. Blok B wypisuje ponownie w chwili 2. Drugie wypisanie bloku A następuje w chwili 15. $finish bloku B kończy symulację w chwili 22.

Rozdzielanie przygotowań, generowania zegara i pobudzenia na osobne bloki initial to częsty styl: każdy blok jest krótki i robi jedną rzecz.

Inicjalizacja w deklaracji

Popularna zwarta forma: inicjalizacja reg od razu w deklaracji. Większość symulatorów traktuje to tak samo jak initial:

reg clk = 0;
reg reset = 1;
reg [7:0] count = 0;

To odpowiednik:

reg clk;
reg reset;
reg [7:0] count;

initial begin
    clk = 0;
    reset = 1;
    count = 0;
end

Zwartą formę zobaczysz w testbenchach: umieszcza wartość początkową tuż obok deklaracji, gdzie łatwo ją wyłapać wzrokiem.

initial działa tylko w symulacji

Narzędzia do syntezy ignorują bloki initial. Prawdziwy sprzęt nie ma "chwili zero", w której wykonuje się kod startowy: ma włączenie zasilania, sygnały resetu i konfigurację wynikającą z tych zdarzeń. Jeśli rejestr ma zaczynać w znanym stanie w prawdziwym sprzęcie, steruj nim sygnałem resetu wewnątrz always @(posedge clk):

always @(posedge clk) begin
    if (reset) state <= IDLE;
    else       state <= next_state;
end

Gałąź if (reset) to syntezowalny odpowiednik initial state = IDLE. Reset to odpowiedź na pytanie "jak zainicjalizować rejestr w prawdziwym sprzęcie?".

Niektóre przepływy FPGA akceptują ograniczone initial do ustawiania wartości początkowych rejestrów (na przykład narzędzia Xilinx), ale to rozszerzenie konkretnego producenta. Nie polegaj na nim w przenośnym kodzie.

Co zobaczysz wewnątrz initial

Kilka typowych wzorców poza standardowym szkieletem testbencha:

Zakończenie po czasie

initial begin
    #1000 $finish;   // safety net: kill the sim after 1000 time units
end

Osobny initial, którego jedynym zadaniem jest narzucenie twardego limitu czasu symulacji. Nawet jeśli główny blok pobudzenia zablokuje się, czekając na sygnał, który nigdy nie nadejdzie, ten blok zadziała i zakończy przebieg.

Konfiguracja przebiegów

initial begin
    $dumpfile("dump.vcd");
    $dumpvars(0, test);   // dump everything under the `test` scope
end

Te dwie linie każą symulatorowi zapisać plik VCD z każdym sygnałem w zakresie testu. Bez nich nie dostaniesz przebiegów.

Początkowa zawartość pamięci

reg [7:0] memory [0:255];

initial begin
    $readmemh("image.hex", memory);
end

$readmemh wczytuje plik w formacie szesnastkowym do tablicy. Używa się go w testbenchach procesorów do wstępnego załadowania pamięci instrukcji. Tylko w symulacji.

Typowe błędy

Używanie initial w logice syntezowalnej. To się nie zsyntezuje. Zamiast tego używaj sygnałów resetu.

Brak $finish. Bez niego symulator działa, dopóki coś innego go nie zatrzyma (domyślny limit czasu, ręczne przerwanie itp.). W szybkim teście to nie problem, ale w skrypcie regresyjnym zawsze używaj $finish.

Brak #delay między przypisaniami pobudzenia. Jeśli napiszesz a = 0; b = 1; bez opóźnienia, oba przypisania zajdą w tym samym czasie symulacji i testowany układ może zobaczyć je jednocześnie, a nie jako osobne zdarzenia. Między odrębnymi zdarzeniami pobudzenia wstawiaj #1 albo dłuższe opóźnienie.

Próba sterowania wire z initial. Ta sama reguła co dla always: jedynym dozwolonym celem jest reg.

Co dalej

Znasz już oba rodzaje bloków proceduralnych. Następny artykuł omawia temat, który początkującym w Verilogu myli się najczęściej: Przypisania blokujące i nieblokujące. Wiedza o tym, kiedy użyć =, a kiedy <=, to różnica między działającym przerzutnikiem a bałaganem pełnym wyścigów.