Funktionale Merkmale

TF-Subroutinen (Task/Function) werden hauptsächlich für den Datentransfer in zwei Richtungen an der Grenze zwischen Verilog und Benutzer-C-Programmen verwendet.

TF-Subroutinen haben immer das Präfix tf_ und sind in der Header-Datei veriuser.h definiert. Wenn Sie also System-Tasks oder -Funktionen in C schreiben, müssen Sie #include "veriuser.h" in die C-Datei einfügen.

TF-Subroutinen können in die folgenden Verwendungszwecke unterteilt werden:

  • Abrufen von System-Task-Informationen
  • Abrufen von Parameterlisteninformationen
  • Abrufen von Parameterwerten
  • Zurückgeben von Parameterwerten an System-Tasks
  • Überwachen von Änderungen der Parameterwerte
  • Abrufen von Simulationszeit- und geplanten Ereignisinformationen
  • Arithmetische Operationen
  • Anzeigen von Informationen
  • Verwalten und Pflegen von Aufgaben
  • Andere Aufgaben wie Anhalten, Beenden, Speichern und Wiederherstellen

Eine vollständige Liste der TF-Unterprogramme und ihre einfachen Anwendungshinweise finden Sie im nächsten Abschnitt."8.3 TF-Unterprogrammliste"。

Beispiele für TF-Unterprogramme

Die PLI-Unterprogrammbibliothek enthält eine große Anzahl von Funktionen. Sie einzeln zu erklären, würde sehr viel Platz beanspruchen. Daher wird empfohlen, einzelne Unterprogramme nur bei Bedarf sorgfältig zu studieren. Nachfolgend finden Sie Beispiele für einige TF-Unterprogramme, die hauptsächlich den grundlegenden Ablauf beim Entwurf von Verilog-Systemaufgaben mit TF-Unterprogrammen veranschaulichen.

Entwurfsanforderungen

Manchmal verwendet die Druckfunktion in der Software, um die Größe der Objektdatei nach dem Kompilieren der C-Sprachdatei zu reduzieren oder Debug-Informationen in einem bestimmten Format auszugeben, weder die in C integrierte printf-Funktion noch die Funktion io_printf aus den TF-Unterprogrammen. Stattdessen verwendet sie die PLI-Schnittstelle und die Verilog-Systemanzeigefunktionen ($display oder $write), um eine benutzerdefinierte Software-Druckfunktion zu implementieren.

Dieses Design implementiert eine Software-Druckfunktion namens print_my mit einem Ausgabeformat von "Zeichenkette + Ganzzahl".

Entwurfsanalyse

Die benutzerdefinierte Software-Druckfunktion print_my ist nur eine unattraktive Hülle, die verwendet wird, um Druckinformationen an formale Parametervariablen der Software zu übergeben. Um die Druckinformationen in Verilog zu übergeben, wird außerdem eine mit TF-Unterprogrammen erstellte Systemaufgabe benötigt, die $send_my() heißt.

Es ist zu beachten, dass mit TF-Unterprogrammen implementierte Systemaufgaben im Allgemeinen im Verilog-Code aufgerufen werden müssen. Dass die Software diese "Systemaufgabe" direkt aufruft, ist gleichbedeutend mit dem Aufruf einer Softwarefunktion und steht in keinem direkten Zusammenhang mit den Beschreibungen der zugehörigen Variablen im Verilog-Code. Daher ist es sinnlos, die "Softwarefunktion" send_my direkt in der Softwarefunktion print_my aufzurufen. Es ist notwendig, in print_my einige spezifische Softwareverhaltensweisen hinzuzufügen, um zu bewirken, dass die Systemaufgabe $send_my von Verilog aufgerufen wird.

Wenn das digitale System eine CPU enthält, können Sie die Methode verwenden, über Software auf den Bus oder Speicher zu schreiben und dann die relevanten Signalvariablen im Testbench zu überwachen. Dieses Design hat einen relativ kleinen Umfang, daher kann eine andere Methode verwendet werden: Verilog führt kontinuierlich die Systemaufgabe $send_my aus, und in der Softwarefunktion print_my wird eine globale Variable gesetzt, um zu steuern, ob eine Informationsübertragung und -ausgabe erfolgen soll.

Software-Design

Der Software-Designcode ist wie folgt, wobei die Details in den Kommentaren erklärt werden. Speichern Sie ihn in der Datei print_gyc.c.

Beispiel

#include "veriuser.h"

// zu druckende Zeichenkette, Ganzzahldaten, Startflagge für Software-Ausgabe
char            *str_mes ;  
unsigned int    int_mes ;
int             flags = 0;

//===== print_my() definieren, verwendet in C =====
void print_my(char * str_send, unsigned int int_send){
    str_mes  = str_send ;
    int_mes  = int_send ;
    Flags    = 1 ;
}


// Zeichendaten der ASCII-Codes, die dem auszugebenden String entsprechen, ursprüngliche Zeichenlänge auf 100 begrenzt
// zum Beispiel entspricht das Zeichen "1" dem ASCII-Code 0x31, dessen Zeichendaten 0x33, 0x31 sind
char            str_mes_format[200] ;
// wenn TF-Unterprogramme String-Daten übergeben, können sie Daten nur im entsprechenden Basisformat übergeben
// zum Beispiel kann "0xc0de1234" übergeben werden, aber "www.example.com" nicht
// daher müssen die ursprünglichen String-Daten in Zeichendaten der entsprechenden ASCII-Codes umgewandelt werden
void byte2hexstr(char* str, char* dest, int len)
{
    char tmp;
    int  i ;
    char stb[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    for (i = 0; i < len; i++){
        tmp = str[i];
        dest[i * 2] = stb[tmp >> 4];
        dest[i * 2 + 1] = stb[tmp & 15];
    }
    return;
}

//===== PLI definieren: send_my() =======
void send_my(){
    int i = 0 ;
    // Software-Druckstart-Flag flags erkennen
    // und die Systemaufgabe $send_my wird von Verilog mit 3 übergebenen Parametern aufgerufen
    if (flags && tf_nump()==3) {
        // die zu druckenden String-Daten in den String-Typ, der ASCII entspricht, umwandeln
        byte2hexstr(str_mes, str_mes_format, 100);
        // die hexadezimalen Zeichendaten an den zweiten Parameter in der Systemaufgabe send_my übergeben
        // Länge ist 1600 Bits, entsprechend 100 Zeichen und 200 ASCII-Zeichendaten
        tf_strdelputp(2, 1600, 'H', str_mes_format, 0, 0);
        // die Integer-Daten an den dritten Parameter übergeben
        tf_putp(3, int_mes);
        // das Hardware-Druckstart-Flag an den 1. Parameter übergeben
        tf_putp(1, 1) ;
        Flags = 0 ;
    }
}

Hardware-Entwurf

Laut Simulationstests werden die von der Software an Verilog übergebenen Daten in einem 1600 Bit breiten Register gespeichert, wie in der folgenden Abbildung gezeigt.

Wenn das Register normale Daten enthält, beginnt es, normale Zeichendaten ab dem 799. Bit zu speichern (die Hälfte der Registerbreite). Die verbleibenden niederwertigen Bits speichern "NULL" (entspricht Daten 0) und Systemstandarddaten. Die Längen dieser beiden Datenteile variieren je nach Länge der gespeicherten normalen Daten.

Wenn das Register keine normalen Daten enthält, verwendet es mehr als 800 Bit Registerlänge, um "NULL" (entspricht Daten 0) zu speichern. Die verbleibende Breite speichert Systemstandarddaten.

Basierend auf den oben genannten Eigenschaften können normale Stringdaten erkannt werden, ohne alle Daten im Register auszugeben, wodurch eine große Menge Leerraum in der Druckausgabe vermieden wird, der das Aussehen beeinträchtigen würde.

Das Hardware-Verilog-Codedesign ist wie folgt, wobei spezifische Details in den Kommentaren erläutert werden. Speichern Sie es in der Datei test.v.

Beispiel

`timescale 1ns/1ps
module test ;
   reg [1599:0]         str_my ;
   reg [31:0]           int_my ;
   reg                  flag_my ;

   // kontinuierlich das Hardware-Druckflag flagh prüfen, um zu entscheiden, ob gedruckt werden soll
   integer              i = 1599;
   integer              j = 1599;
   reg [7:0]            str_tmp ; // Speicherregister für Stringdaten
   initial begin
      flagh = 0 ;
      forever begin
         #20 ;
         // Systemtask aufrufen und Daten von Software an Hardware übergeben (Verilog)
         $send_my(flagh, str_my, int_my);
         if (flagh) begin  // Ausgabe von Informationen starten
            #1 ;
            // Die Registerbreite weist Redundanz auf; alles auszugeben würde viele Leerzeichen erzeugen
            // hier werden ungenutzte Registerbits erkannt und bei der Ausgabe unterdrückt
            for(i=1599; i>=0; i= i-8) begin
               if (str_my[i -: 8] != 0)
                 break ;
            end
            // Im Allgemeinen wird die Hälfte der Registerbreite verwendet, um Stringdaten zu speichern
            // Wenn die Stringübertragung korrekt ist, beginnen die Daten bei str_my
            $display("--DEBUG--- Anzahl gültiger Daten: %d", i);

            // Wenn keine Stringdaten vorhanden sind, wird str_my auch nicht vollständig leer sein
            // aber str_my[799 -: 8] wird keine Daten enthalten
            if (i<=791) begin
               $display("--ERR--- BITTE GÜLTIGE STRING-INFORMATIONEN EINGEBEN!!!");
               $display("--ERR--- Standard-Datennummer: %d", i);
               $display("--ERR--- String-Datenstruktur: %h", str_my);
            end
            else begin
               $write("---YYY---");
               for(j=i; j>=0; j= j-8) begin
                  str_tmp = str_my[j -: 8] ;
                  // Ausgabe stoppen, wenn erneut ein Nullzeichen erkannt wird
                  if (str_tmp == "") begin  
                     break ;
                  end
                  // Zeichen für Zeichen ausgeben
                  else begin
                     $write("%s", str_tmp);
                  end
               end
               // Integer-Daten ausgeben
               $write("%h \n", int_my);
            end

            /* $display unterstützt keinen variablen Zugriff in Teilauswahlen von Registervektoren
// daher ist die folgende Beschreibung falsch; man kann nur $write wiederholt zum Ausgeben verwenden
            else begin
               $display("--YYY--- %s%h", str_my[i : j], int_my);
            end
             */


            flagh = 0 ;
         end
      end
   end

   // Simulation beenden
   initial begin
      forever begin
         #10000;
         if ($time >= 300)  $finish ;
      end
   end
endmodule

Software-Aufruf

Da der Softwareteil dieses Designs nicht aktiv ausgeführt werden kann, wird eine zusätzliche Verilog-Systemaufgabe hinzugefügt, die mit TF-Unterprogrammen entworfen wurde. Wenn diese Systemaufgabe im Testbench ausgeführt wird, kann sie die Funktion print_my im Softwareprogramm aufrufen.

Fügen Sie den folgenden C-Code zur Datei print_gyc.c hinzu:

void call_c_print(){
    if (tf_getp(1) == 1)   // wenn der Wert des ersten Parameters der Systemfunktion 1 ist
        print_my("Es ist die erste erfolgreiche Ausgabe: ", 0x20170714);
    else if (tf_getp(1) == 2) // wenn der Wert des zweiten Parameters der Systemfunktion 2 ist
        print_my("2nd: ", 0x09070602);
    else
        print_my("", 0x1); // wenn String-Daten nicht übertragen werden, einen Fehler melden
}

Fügen Sie den folgenden Verilog-Code zur Datei test.v hinzu:

   //c print
   initial begin
      #100 ;
      $call_c_print(1);
      #100 ;
      $call_c_print(2);
      #100 ;
      $call_c_print(3);
   end

Kompilierung und Simulation

Verwenden Sie unter Linux den folgenden Befehl, um print_gyc.c zu kompilieren und die Datei print_gyc.o auszugeben. Achten Sie auf relative Pfade.

gcc -I ${VCS_HOME}/include -c ../tb/print_gyc.c

Beim Kompilieren mit VCS müssen Sie eine Link-Tabellendatei erstellen, die VCS erkennen kann, namens pli_gyc.tab, mit dem folgenden Inhalt.

$send_my und $call_c_print sind die Namen der von Verilog aufgerufenen Systemaufgaben;

call=my_monitor, call=call_c_print usw. bezeichnen Aufrufe von Funktionen im Software-C-Programm;

$send_my call=send_my
$call_c_print call=call_c_print

Fügen Sie beim Kompilieren mit VCS die folgende Parameterzeile hinzu.

-P ../tb/pli_gyc.tab

Die Simulationsergebnisse sind wie folgt.

Wie aus der Abbildung ersichtlich ist, ist die gedruckte Ausgabe normal, ohne zusätzliche Leerzeichen.

Wenn keine String-Daten in den gedruckten Informationen vorhanden sind, wird ein Fehler gemeldet, zusammen mit der Ausgabe einiger Debug-Informationen.

Sie können einige Parameter in der Testbench ändern, um zu debuggen und etwas über Datenspeicherformate zu lernen.

Kapitel-Quellcode herunterladen

Herunterladen