$display i $monitor w Verilogu: wypisywanie z testbencha

Verilogowa rodzina printf z C

Trzy zadania systemowe pozwalają wypisywać na standardowe wyjście symulatora:

• $display: wypisuje raz i dodaje znak nowej linii.
• $write: wypisuje raz, bez znaku nowej linii.
• $monitor: wypisuje automatycznie za każdym razem, gdy zmieni się obserwowany sygnał.

Wszystkie trzy przyjmują napis formatujący i listę argumentów, tak jak printf. Specyfikatory formatu są podobne, ale specyficzne dla Veriloga.

$display: wybór domyślny

$display to podstawowe narzędzie:

module display_demo;
    reg [7:0] byte_val = 8'hAB;
    reg [3:0] nibble   = 4'b1010;
    integer   count    = 42;

    initial begin
        $display("Hello, world.");
        $display("byte_val  = %h", byte_val);
        $display("byte_val  = %b", byte_val);
        $display("byte_val  = %d", byte_val);
        $display("byte_val  = %0d (no padding)", byte_val);
        $display("multi: nibble=%b count=%0d", nibble, count);
        $finish;
    end
endmodule

Zobaczysz mniej więcej coś takiego:

Hello, world.
byte_val  = ab
byte_val  = 10101011
byte_val  = 171
byte_val  = 171 (no padding)
multi: nibble=1010 count=42

Uwagi:

• %d dopełnia do domyślnej szerokości zależnej od rozmiaru argumentu. Dla 8-bitowego reg to 3 znaki (miejsce na 255). Spacje na początku mogą brzydko wyglądać w wyjściu tabelarycznym, więc użyj %0d, żeby je usunąć.
• %h, %b, %o domyślnie też dopełniają. Większość kodu testbenchy używa wariantów z %0, gdy wyrównanie nie jest przydatne.
• Znak nowej linii na końcu dodawany jest automatycznie. Nie wstawiaj \n na końcu napisu formatującego $display, bo dostaniesz pustą linię.

Specyfikatory formatu

Zestaw obsługiwany przez Veriloga:

%b, %d, %h, %o to cztery specyfikatory, których będziesz używać w 95% przypadków. Następny pod względem popularności jest %t: zawsze wtedy, gdy chcesz linię logu ze znacznikiem czasu.

$write: bez nowej linii

$write działa identycznie jak $display, tylko nie dodaje znaku nowej linii:

module write_demo;
    initial begin
        $write("a");
        $write("b");
        $write("c");
        $display("");           // newline now
        $display("done");
        $finish;
    end
endmodule

Wyjście:

abc
done

Przydaje się do budowania jednej linii w ciele pętli:

$write("[");
for (integer i = 0; i < 8; i = i + 1) $write("%h ", arr[i]);
$display("]");

$monitor: automatyczne wypisywanie przy zmianie

$monitor rejestruje listę obserwowanych sygnałów. Symulator ponownie oblicza i wypisuje komunikat, gdy zmieni się dowolny sygnał wymieniony w napisie formatującym:

module monitor_demo;
    reg [3:0] a, b;
    wire [4:0] sum;
    assign sum = a + b;

    initial begin
        $monitor("t=%0t a=%h b=%h sum=%h", $time, a, b, sum);

        a = 4'd1; b = 4'd2;     // first auto-print
        #5;
        a = 4'd5;                // second auto-print (a changed)
        #5;
        b = 4'd9;                // third auto-print (b changed)
        #5;
        $finish;
    end
endmodule

Zobaczysz trzy linie, po jednej dla każdej zmiany wejść. Nie trzeba ręcznie wywoływać $display po każdej zmianie pobudzenia, bo $monitor robi to za ciebie.

Dwa ograniczenia:

• Aktywny może być tylko jeden $monitor. Ponowne wywołanie zastępuje poprzednią listę. $monitoroff i $monitoron pozwalają tymczasowo go wyłączyć i włączyć z powrotem.
• Zmiany w tym samym kroku czasowym łączą się w jedno wypisanie. Jeśli a i b zmienią się w chwili 5, monitor zadziała raz z obiema nowymi wartościami, a nie dwa razy.

Kiedy używać którego

• $display: większość wyjścia testbencha. Wywołuj go jawnie po pobudzeniu, po ważnych przejściach stanów albo w próbkującym bloku always @(posedge clk).
• $write: gdy chcesz zbudować jedną linię w pętli albo z kilku małych kawałków.
• $monitor: gdy chcesz stale śledzić mały zestaw sygnałów i widzieć wyjście tylko przy ich zmianie. Przydatny przy wstępnym debugowaniu. Trudniej go używać w skryptach regresyjnych, bo łączna liczba linii wyjścia nie jest deterministyczna.

W większości zastosowań $display wystarcza do wszystkiego. Po $monitor sięgaj tylko wtedy, gdy naprawdę chcesz ciągłego wyjścia sterowanego zmianami.

Praca z czasem

$time zwraca bieżący czas symulacji jako 64-bitową liczbę całkowitą. Łącz go z %0t:

$display("at %0t: signal flipped", $time);

Wyjście wygląda jak at 25: signal flipped (jednostka zależy od timescale).

Jeśli potrzebujesz precyzji poniżej jednego tiku (rzadko), użyj zamiast tego $realtime, które zwraca real.

%t automatycznie formatuje czas z domyślną szerokością wybraną przez symulator. %0t usuwa dopełnienie.

Próbkowanie na zboczu zegara

Czysty idiom do obserwowania projektów sekwencyjnych: osobny blok always @(posedge clk), który wypisuje raz na cykl:

module sampler;
    reg clk = 0;
    reg [3:0] counter = 0;

    always #5 clk = ~clk;

    always @(posedge clk) begin
        counter <= counter + 1;
        $display("t=%0t cycle counter=%0d", $time, counter);
    end

    initial #100 $finish;
endmodule

Ten wzorzec próbkowania gwarantuje jedną linię logu na takt zegara, co idealnie pasuje do testów regresyjnych dopasowujących wzorce w wyjściu.

Logowanie do pliku

Otwórz plik przez $fopen i loguj przez $fdisplay (który działa jak $display, ale zapisuje do uchwytu pliku):

integer fd;
initial begin
    fd = $fopen("results.txt", "w");
    $fdisplay(fd, "test=%s status=%s", test_name, status);
    $fclose(fd);
end

$fopen zwraca 32-bitowy uchwyt. Przekaż go jako pierwszy argument do $fdisplay, $fwrite, $fstrobe i innych. Poza tym te funkcje działają identycznie jak ich odpowiedniki wypisujące na konsolę.

Co dalej

$display i spółka dają logi tekstowe. Do debugowania wizualnego, czyli obserwowania sygnałów jako napięć w czasie, potrzebujesz przebiegu VCD. Następny artykuł, Dumpfile i VCD, omawia $dumpfile i $dumpvars, dwa wywołania, które zamieniają symulację w graficzny przebieg, po którym możesz się przewijać.