$display e $monitor in Verilog: stampare da un testbench

La famiglia printf di Verilog

Tre system task ti permettono di stampare sullo stdout del simulatore:

• $display: stampa una volta e aggiunge un a capo.
• $write: stampa una volta, senza a capo.
• $monitor: stampa automaticamente ogni volta che cambia un segnale osservato.

Tutti e tre accettano una stringa di formato e un elenco di argomenti, proprio come printf. Gli specificatori di formato sono simili, ma specifici di Verilog.

$display: la scelta predefinita

$display è il cavallo da tiro:

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

Vedrai qualcosa del genere:

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

Note:

• %d riempie fino a una larghezza predefinita che dipende dalla dimensione dell'operando. Per un reg a 8 bit sono 3 caratteri (lo spazio per 255). Gli spazi iniziali possono risultare brutti in un output tabellare: usa %0d per eliminarli.
• Anche %h, %b, %o hanno un riempimento simile per default. La maggior parte del codice dei testbench usa le varianti %0 quando l'allineamento non serve.
• L'a capo finale è automatico. Non mettere \n alla fine della stringa di formato di un $display: otterresti una riga vuota.

Specificatori di formato

Quelli supportati da Verilog:

%b, %d, %h, %o sono i quattro che userai il 95% delle volte. Subito dopo viene %t, ogni volta che vuoi una riga di log con il timestamp.

$write: senza a capo

$write è identico a $display, ma non aggiunge un a capo:

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

Output:

abc
done

È utile per costruire una sola riga dal corpo di un ciclo:

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

$monitor: stampa automatica a ogni cambiamento

$monitor registra una lista di osservazione. Il simulatore rivaluta e stampa ogni volta che cambia uno qualsiasi dei segnali citati nella stringa di formato:

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

Vedrai tre righe, una per ogni cambiamento degli ingressi. Non serve chiamare a mano $display dopo ogni variazione dello stimolo: ci pensa $monitor.

Due limitazioni:

• Può essere attivo un solo $monitor. Richiamarlo sostituisce la lista di osservazione precedente. Usa $monitoroff e $monitoron per sospenderlo temporaneamente e riattivarlo.
• I cambiamenti nello stesso passo temporale producono una sola stampa. Se a e b cambiano entrambi al tempo 5, il monitor scatta una volta con entrambi i nuovi valori, non due.

Quando usare ciascuno

• $display: la maggior parte dell'output dei testbench. Chiamalo esplicitamente dopo uno stimolo, dopo transizioni di stato importanti o dentro un blocco di campionamento always @(posedge clk).
• $write: quando vuoi costruire una sola riga da un ciclo o da diversi piccoli pezzi.
• $monitor: quando vuoi seguire di continuo un piccolo insieme di segnali e vedere output solo quando cambiano. È utile nel primo debug; è più scomodo negli script di regressione, perché l'output non è deterministico nel numero totale di righe.

Nella maggior parte dei casi $display basta per tutto. Passa a $monitor solo quando ti serve davvero un output continuo guidato dai cambiamenti.

Lavorare con il tempo

$time restituisce il tempo di simulazione corrente come intero a 64 bit. Abbinalo a %0t:

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

L'output è del tipo at 25: signal flipped (l'unità dipende dal tuo timescale).

Se ti serve una precisione inferiore al tick (raro), usa invece $realtime, che restituisce un real.

%t formatta automaticamente il tempo con una larghezza predefinita scelta dal simulatore. %0t elimina il riempimento.

Campionare sul fronte di clock

Un idioma pulito per osservare progetti sequenziali: un blocco always @(posedge clk) separato che stampa una volta per ciclo:

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

Questo pattern di campionamento garantisce una riga di log per clock: perfetto per i test di regressione che confrontano l'output con dei pattern.

Scrivere il log su file

Apri un file con $fopen e scrivi con $fdisplay (che funziona come $display ma scrive su un handle di file):

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

$fopen restituisce un handle a 32 bit; passalo come primo argomento a $fdisplay, $fwrite, $fstrobe e così via. Per il resto queste funzioni sono identiche alle loro sorelle che stampano sulla console.

Cosa viene dopo

$display e compagni ti danno log testuali. Per il debug visivo, cioè guardare i segnali come tensioni nel tempo, ti serve una forma d'onda VCD. La prossima pagina, Dumpfile and VCD, tratta $dumpfile e $dumpvars, le due chiamate che trasformano la simulazione in una forma d'onda grafica da scorrere.