Funktionale Merkmale

Die von ACC-Unterprogrammen hauptsächlich ausgeführten Funktionen sind:

  • Lesen von Informationen über bestimmte Objekte aus internen Datenstrukturen
  • Schreiben von Informationen über bestimmte Objekte in interne Datenstrukturen

Die Objekttypen, auf denen ACC-Unterprogramme arbeiten können, sind:

  • Modulinstanzen, Modulports, Modul-End-to-End-Pfade und Pfade zwischen Modulen
  • Top-Level-Module
  • Primitive-Instanzen und Primitive-Ports
  • Variablentypen wie wire, reg, parameter, integer, time, real usw.
  • Timing-Prüfungen
  • Benannte Ereignisse

Die Hauptmerkmale der ACC-Subroutinen sind:

  • Alle haben das Präfix acc_
  • Zu Beginn muss acc_initialize() aufgerufen werden, um die Umgebung zu initialisieren
  • Beim Beenden muss acc_close() aufgerufen werden
  • Bei Verwendung von Funktionen aus der ACC-Bibliothek muss die Header-Datei acc_user.h eingebunden werden
  • Das Konzept der Handles wird verwendet, um auf Objekte zuzugreifen. Ein Handle ist ein vordefinierter Datentyp, der auf ein bestimmtes Objekt im Design zeigt. Sobald ein Handle erhalten wurde, kann auf alle Informationen über das Objekt zugegriffen werden. Dies ähnelt dem Datei-Handle-Konzept in der Sprache C. Handles werden mit dem Schlüsselwort handle deklariert.

Die Haupttypen der ACC-Subroutinen sind:

  • Handle-Subroutinen (handle): geben ein Handle auf ein Objekt im Design zurück, immer mit dem Präfix acc_handle_ versehen.
  • Next-Subroutinen (next): geben ein Handle auf das nächste Objekt in einer bestimmten Menge von Objekten im Design zurück, immer mit dem Präfix acc_next_ versehen, und nehmen das referenzierte Objekt als Parameter.
  • Value-Change-Link-(VCL)-Subroutinen: können Objekte zur Liste der auf Wertänderungen überwachten Objekte hinzufügen und daraus entfernen, immer mit dem Präfix acc_vcl_ versehen, und haben keinen Rückgabewert.
  • Fetch-Subroutinen (fetch): können Attributinformationen wie hierarchische Pfade extrahieren; sie sind immer mit acc_fetch_ präfixiert.
  • Miscellaneous-Subroutinen (miscellaneous): werden verwendet, um verschiedene sonstige Operationen im Zusammenhang mit Access-Subroutinen auszuführen. Beispielsweise sind acc_initialize() und acc_close() beides Miscellaneous-Subroutinen.
  • Modify-Subroutinen (modify): können interne Datenstrukturen ändern.

Eine vollständige Liste der ACC-Subroutinen und kurze Anwendungshinweise finden Sie im nächsten Abschnitt„8.5 ACC-Subroutine-Liste“.。

Beispiele für ACC-Subroutinen

Im Folgenden finden Sie Anwendungsbeispiele für nur einige ACC-Subroutinen; sie veranschaulichen hauptsächlich den grundlegenden Ablauf beim Entwurf von Verilog-System-Tasks mit ACC-Subroutinen.

Entwurfsanforderungen

Diesmal wird eine System-Task entworfen, die einen Zähler überwacht.

Einerseits überwacht die System-Task den Wert eines Zählers in Verilog; andererseits führt sie, nachdem sie den Zähltakt in Verilog erkannt hat, außerdem eine Software-Zählung durch und vergleicht die Software- und Hardware-Zählwerte, um die Korrektheit der Hardware-Logik zu überprüfen. Zugleich gibt sie, wenn der Zähler einen bestimmten Wert erreicht, die Werte einiger Signalvariablen aus.

Diese Entwurfsweise ist auch ein häufiges Szenario für PLI-Schnittstellen. Die Software implementiert eine Logikfunktion namens CModel. Dann implementiert auch die Hardware dieselbe Logikfunktion mit Verilog. Über das PLI-Schnittstellenprogramm können die Software- und Hardwareprogramme gleichzeitig ausgeführt und die Ergebnisse verglichen werden, um die Korrektheit des Hardware-Logikentwurfs zu überprüfen.

Entwurfsanalyse

Im PLI-Schnittstellenteil wird eine Value-Change-Link-Subroutine verwendet, um den Takt zu überwachen. Sobald eine steigende Flanke des Takts eintrifft, wird eine Softwarefunktion aufgerufen, um eine Software-Zählung durchzuführen und die Software- und Hardware-Zählwerte zu vergleichen.

Software-Design

Der Code des Software-Designs ist wie folgt, wobei Details in den Kommentaren erläutert werden. Speichern Sie ihn in der Datei monitor_gyc.c.

Beispiel

#include "acc_user.h"

handle hand_rstn, hand_clk, hand_cnt, hand_cout ;
int cnt_soft  = 0 ;   //Wert des Softwarezählers
int cout_soft = 0 ;   //Überlaufbit des Softwarezählers

//Softwarezähl- und Vergleichsfunktion
void act_monitor(){
    p_acc_value value ; //Deklariere die in ACC definierte Strukturvariable
    //Wert einer Signalvariablen in Verilog lesen, Typ String
    char *rstn_rtl_str = acc_fetch_value(hand_rstn, "%d", value);
    char *clk_rtl_str  = acc_fetch_value(hand_clk, "%d", value);
    char *cnt_rtl_str  = acc_fetch_value(hand_cnt, "%d", value);
    char *cout_rtl_str = acc_fetch_value(hand_cout, "%d", value);

    //String in Ganzzahl umwandeln
    int rstn_rtl       = atoi(rstn_rtl_str) ;
    int clk_rtl        = atoi(clk_rtl_str) ;
    int cnt_rtl        = atoi(cnt_rtl_str) ;
    int cout_rtl       = atoi(cout_rtl_str) ;

    //Softwarezähler
    //Zurücksetzen
    if (!rstn_rtl) {
        cnt_soft    = 0 ;
        cout_soft   = 0 ;
        io_printf("---iii--- Reset-Zustand! \n");
    }
    //Normalbetrieb
    else if (rstn_rtl && clk_rtl) {
        if (cnt_soft == 9) {
            cnt_soft    = 0 ;    //Zähle 10
        }
        else {
            cnt_soft    = cnt_soft + 1 ; //Zählen
        }
    }
    cout_soft = cnt_soft == 9 ? 1 : 0 ; //Übertrag

    //Vergleiche Software- und Hardware-Zählerstände, wenn der Takt niedrig ist; dies ist ein relativ sicherer Zeitpunkt
    if (!clk_rtl && rstn_rtl) {
        if ((cnt_soft != cnt_rtl) || (cout_soft != cout_rtl)) {
            io_printf("--Fehler--- RTL-Zähler: %d, und Software-Zähler: %d\n", cnt_rtl, cnt_soft);
            io_printf("--Fehler--- rtl cout: %d, und soft cout: %d\n", cout_rtl, cout_soft);
        }
        //Wenn beim Vergleich der Software- und Hardware-Zählung kein Fehler auftritt, werden die Zustandswerte der Signale ausgegeben, wenn ein Zählzyklus abgeschlossen ist
        else if (cnt_soft == 9)  {
            io_printf("--Monitor--- rtl und soft cnt: %d\n", cnt_soft);
            io_printf("--Monitor--- rtl und soft cout: %d\n", cout_soft);
        }
    }
}

//PLI-Schnittstelle, Überwachung von Taktänderungen
void my_monitor() {
    acc_initialize(); //Initialisierung ist erforderlich
    //Handle-Variable des ersten Parameters der Systemtask my_monitor abrufen
    hand_rstn   = acc_handle_tfarg(1);
    hand_clk    = acc_handle_tfarg(2);
    hand_cnt    = acc_handle_tfarg(3);
    hand_cout   = acc_handle_tfarg(4);
    //"#define VCL_VERILOG_LOGIC 2" in acc_user.h
    //Gibt an, dass der VCL-Callback-Mechanismus melden soll
    //Sobald sich hand_clk ändert, rufe die Funktion act_monitor auf
    acc_vcl_add(hand_clk, act_monitor, null, vcl_verilog_logic);
    acc_close(); //Task schließen
}

Hardware-Entwurf

Die Verilog-Beschreibung eines Dezimalzählers lautet wie folgt. Speichern Sie sie in der Datei counter10.v.

Beispiel

module counter10(
   input                rstn,
   input                clk,
   output [3:0]         cnt,
   output               cout);

   reg [3:0]            cnt_temp ;
   always@(posedge clk or negedge rstn) begin
      if (! rstn) begin
         cnt_temp        <= 4'b0 ;
      end
      else if (cnt_temp==4'd9) begin
         cnt_temp        <=4'b000;
      end
      else begin
         cnt_temp        <= cnt_temp + 1'b1 ;
      end
   end

   assign  cout = (cnt_temp==4'd9) ;
   assign  cnt  = cnt_temp ;

endmodule

testbench

Die Testbench-Beschreibung lautet wie folgt. Speichern Sie sie in der Datei test.v.

Beispiel

`timescale 1ns/1ps
module test ;
   reg          rstn, clk ;
   wire [3:0]   cnt ;
   wire         cout ;

   initial begin
      rstn      = 0 ;
      clk       = 0 ;
      #19.8;
      rstn      = 1 ;
   end
   always #5 clk = ~clk ;

   counter10 u_cnt(
     .rstn      (rstn),
     .clk       (clk),
     .cnt       (cnt),
     .cout      (cout));

   initial begin
      $my_monitor(test.rstn, test.clk, test.cnt, test.cout);
   end

   initial begin
      forever begin
         #100;
         if ($time >= 300)  $finish ;
      end
   end
endmodule

Kompilierung und Simulation

Unter Linux verwenden Sie den folgenden Befehl, um monitor_gyc.c zu kompilieren und die Datei monitor_gyc.o auszugeben. Achten Sie auf den relativen Pfad.

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

Beim Kompilieren mit VCS müssen Sie eine Linkdatei erstellen, die VCS erkennen kann. Benennen Sie die Datei pli_gyc.tab mit folgendem Inhalt.

$my_monitor ist der Name der in Verilog aufgerufenen Systemaufgabe;

call=my_monitor bedeutet, die Funktion my_monitor() im Software-C-Programm aufzurufen;

acc=rw:* legt die Attribute der Systemaufgabe fest. rw gibt an, dass interne Daten gelesen und geschrieben werden können. Nach dem Doppelpunkt kann der Modul- oder Signalbereich deklariert werden, auf den die Systemaufgabe wirkt. ":*" bedeutet, dass sie auf alle Module wirken kann.

$my_monitor call=my_monitor acc=rw:*

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

-P ../tb/pli_gyc.tab

Das Simulationsergebnis-Log ist wie folgt.

Aus dem Log ist ersichtlich, dass der Vergleich der Software- und Hardware-Zählwerte korrekt ist und der Status, nachdem der Zähler einen Zyklus der Zählung abgeschlossen hat, ebenfalls normal ist.

Kapitel-Quellcode herunterladen

Herunterladen