Schlüsselwörter: Task

Unterschiede zwischen Tasks und Funktionen

Wie Funktionen können Tasks verwendet werden, um gemeinsame Codeabschnitte zu beschreiben, und sie können an jeder Position innerhalb eines Moduls aufgerufen werden, was den Code intuitiver und lesbarer macht. Funktionen werden im Allgemeinen für verschiedene Konvertierungen und Berechnungen in der kombinatorischen Logik verwendet, während Tasks eher Prozeduren ähneln. Sie können nicht nur die Funktionalität von Funktionen erfüllen, sondern auch Timing-Steuerungslogik enthalten. Die Unterschiede zwischen Tasks und Funktionen sind unten zusammengefasst:

VergleichspunktFunktionAufgabe
EingabeEine Funktion muss mindestens einen Eingang haben, und die Portdeklaration darf keinen inout-Typ enthaltenEin Task kann keinen Eingang oder mehrere Eingänge haben, und die Portdeklaration kann vom Typ inout sein
AusgabeEine Funktion hat keinen AusgangEin Task kann keinen Ausgang oder mehrere Ausgänge haben
RückgabewertEine Funktion hat mindestens einen RückgabewertEin Task hat keinen Rückgabewert
SimulationszeitEine Funktion beginnt immer zur Zeit null mit der AusführungEin Task kann zu Zeiten ungleich null ausgeführt werden
Sequenzielle LogikEine Funktion darf keine Zeitsteuerungslogik enthaltenEin Task darf keine always-Anweisungen enthalten, kann aber andere Zeitsteuerungen wie Verzögerungsanweisungen enthalten
AufrufEine Funktion kann nur Funktionen aufrufen, keine TasksEin Task kann Funktionen und Tasks aufrufen
Coding-StandardsEine Funktion darf nicht als eigenständige Anweisung auftreten; sie kann nur auf der rechten Seite einer Zuweisungsanweisung stehenEin Task kann als eigenständige Anweisung in einem Anweisungsblock auftreten

Aufgabe

Task-Deklaration

Eine Task wird an einer beliebigen Stelle in einem Modul definiert und an einer beliebigen Stelle innerhalb des Moduls referenziert; ihr Gültigkeitsbereich ist ebenfalls auf dieses Modul beschränkt.

Wenn eine Unterroutine in einem Modul eine der folgenden Bedingungen erfüllt, muss anstelle einer Funktion eine Task verwendet werden.

  • 1) Die Unterroutine enthält Zeitsteuerungslogik, wie Verzögerungen, Ereignissteuerung usw.
  • 2) Es gibt keine Eingabevariablen
  • 3) Es gibt keine Ausgabe oder die Anzahl der Ausgaben ist größer als 1

Das Deklarationsformat für Verilog-Tasks ist wie folgt:

task       task_id ;
    port_declaration ;
    procedural_statement ;
endtask

In einer Task werden die Schlüsselwörter input, output und inout verwendet, um Ports zu deklarieren. Ports vom Typ input und inout übergeben Variablen von außerhalb der Task nach innen, während Ports vom Typ output und inout die Ergebnisse nach Abschluss der Task-Ausführung nach außen zurückgeben.

Bei der logischen Entwicklung einer Task können die als input deklarierten Portvariablen als Typ wire betrachtet werden, und die als output deklarierten Portvariablen können als Typ reg betrachtet werden. Es ist jedoch nicht erforderlich, die Ausgangsports erneut als reg zu deklarieren.

Beim Zuweisen von Werten an Ausgangssignale darf das Schlüsselwort assign nicht verwendet werden. Um Zeitsteuerungskonflikte zu vermeiden, wird empfohlen, für Ausgangssignale blockierende Zuweisungen zu verwenden.

Beispielsweise wird eine Task mit einer XOR-Funktion mit Verzögerung wie folgt beschrieben:

Beispiel

task xor_oper_iner;
    input [N-1:0]   numa;
    input [N-1:0]   numb;
    output [N-1:0]  numco ;
    //output reg [N-1:0] numco ; //Der reg-Typ muss nicht erneut angegeben werden, obwohl es auch nicht falsch wäre, ihn anzugeben
    #3  numco = numa ^ numb ;
    //assign #3 numco = numa ^ numb ; //Verwenden Sie kein assign, da die Ausgabe standardmäßig reg ist
endtask

Wenn Sie einen Task deklarieren, können Sie auch nach dem Task-Namen Klammern hinzufügen, um die Portdeklarationen einzuschließen.

Das obige Design kann geändert werden zu:

Beispiel

task xor_oper_iner(
    input [N-1:0]   numa,
    input [N-1:0]   numb,
    output [N-1:0]  numco ) ;
    #3  numco       = numa ^ numb ;
endtask

Task-Aufruf

Ein Task kann als eigenständige Anweisung in einem initial- oder always-Block auftreten, und das Aufrufformat ist wie folgt:

task_id(input1, input2, …,outpu1, output2, …);

Beim Aufruf einer Task müssen die Ports in der Reihenfolge übereinstimmen.

Die Signale im Modul, die mit den Eingangsports verbunden sind, können vom Typ wire oder reg sein. Die Signale im Modul, die mit den Ausgangsports verbunden sind, müssen vom Typ reg sein; darauf ist zu achten.

Rufen Sie die obige XOR-Funktionstask auf, um die Pufferung des XOR-Ergebnisses abzuschließen.

Beispiel

module xor_oper
    #(Parameter         N = 4)
     (
      input             clk ,
      input             rstn ,
      input [N-1:0]     a ,
      input [N-1:0]     b ,
      output [N-1:0]    co  );
 
    reg [N-1:0]          co_t ;
    always @(*) begin          //Task-Aufruf
        xor_oper_iner(a, b, co_t);
    end
 
    reg [N-1:0]          co_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            co_r   <= 'b0 ;
        end
        else begin
            co_r   <= co_t ;         //Datenpufferung
        end
    end
    assign       co = co_r ;
 
   /*------------ Task -------*/
    task xor_oper_iner;
        input [N-1:0]   numa;
        input [N-1:0]   numb;
        output [N-1:0]  numco ;
        #3  numco       = numa ^ numb ;   //Blockierende Zuweisung, einfache Zeitsteuerung
    endtask
 
endmodule

Führen Sie eine einfache Simulation des obigen XOR-Funktionsdesigns durch; die Testbench wird wie folgt beschrieben.

Für den Stimulus-Teil verwenden wir einen einfachen Task, um ihn zu beschreiben, wodurch der Stimulus klarer und prägnanter aussieht.

Tatsächlich ist das häufigste Anwendungsszenario für Tasks in Testbenches für die Simulation. Tasks werden auch in einigen Compilern nicht für die Synthese unterstützt.

Beispiel

`timescale 1ns/1ns
 
module test ;
    reg          clk, rstn ;
 
    initial begin
        rstn      = 0 ;
        #8 rstn   = 1 ;
        forever begin
            clk = 0 ; # 5;
            clk = 1 ; # 5;
        end
    end
 
    reg  [3:0]   a, b;
    wire [3:0]   co ;
    initial begin
        a         = 0 ;
        b         = 0 ;
        sig_input(4'b1111, 4'b1001, a, b);
        sig_input(4'b0110, 4'b1001, a, b);
        sig_input(4'b1000, 4'b1001, a, b);
    end
 
    task sig_input ;
        input [3:0]       a ;
        input [3:0]       b ;
        output [3:0]      ao ;
        output [3:0]      bo ;
        @(posedge clk) ;
        ao = a ;
        bo = b ;
    endtask ; // sig_input
 
    xor_oper         u_xor_oper
    (
      .clk              (clk  ),
      .rstn             (rstn ),
      .a                (a    ),
      .b                (b    ),
      .co               (co   ));
 
    initial begin
        forever begin
            #100;
            if ($time >= 1000)  $finish ;
        end
    end
 
endmodule // test

Die Simulationsergebnisse sind wie folgt.

Aus der Abbildung ist ersichtlich, dass das logische Ergebnis des XOR-Ausgangs korrekt ist, mit einer Verzögerung von 3ns relativ zum Eingang.

Darüber hinaus stimmen die verbundenen Signale a, b, co_t mit den Zuständen der in der Task definierten Signale numa, numb, numco überein.

Task, der mit globalen Variablen arbeitet

Da eine Task als prozedurale Zuweisung betrachtet werden kann, liegt der Rückgabezeitpunkt der Signale des Ausgangsports nach der Ausführung aller Anweisungen in der Task.

Variablen innerhalb der Task sind nur innerhalb der Task sichtbar. Wenn Sie den Operationsprozess für Variablen in der Task gezielt beobachten möchten, müssen Sie die beobachteten Variablen innerhalb des Moduls, aber außerhalb der Task deklarieren; diese können als "globale Variablen" bezeichnet werden.

Zum Beispiel gibt es die folgenden zwei Beschreibungen, die versuchen, mit einer Task einen Takt zu erzeugen.

Beispiel

//way1 zur Beschreibung der clk-Erzeugung, funktioniert nicht
task clk_rvs_iner ;
        output    clk_no_rvs ;
        # 5 ;     clk_no_rvs = 0 ;
        # 5 ;     clk_no_rvs = 1 ;
endtask
reg          clk_test1 ;
always clk_rvs_iner(clk_test1);

//Weg2: task verwenden, um globale Variablen zu bearbeiten, um clk zu erzeugen
reg          clk_test2 ;
task clk_rvs_global ;
        # 5 ;     clk_test2 = 0 ;
        # 5 ;     clk_test2 = 1 ;
endtask // clk_rvs_iner
always clk_rvs_global;

Die Simulationsergebnisse sind wie folgt.

In der ersten Beschreibung haben die internen Variablen der Task zwar Prozessoperationen zum Zuweisen von 0 und Zuweisen von 1, aber der Zwischenänderungsprozess ist nicht sichtbar. Die endgültige Ausgabe kann nur der Endwert des Ausgangsportsignals sein, nachdem alle Anweisungen in der Task ausgeführt wurden. Daher ist das Signal clk_test1 immer 1, und diese Methode kann keinen Takt erzeugen.

In der zweiten Beschreibung sind zwar keine Portsignale vorhanden, aber sie führt direkt prozedurale Operationen auf der "globalen Variablen" aus. Da die globale Variable für das Modul sichtbar ist, spiegelt sich der Signalwechselvorgang innerhalb der Task im Signal clk_test2 wider.

Automatische Task

Wie bei Funktionen sind die lokalen Variablen in einem Task-Aufruf in Verilog statisch. Das Schlüsselwort automatic kann verwendet werden, um eine Task zu deklarieren, sodass jeder Speicherplatz beim Aufruf der Task dynamisch zugewiesen werden kann. Jede aufgerufene Task arbeitet unabhängig in ihrem eigenen eindeutigen Adressraum, ohne die nebenläufige Ausführung mehrerer Aufrufe derselben Task zu beeinträchtigen.

Wenn ein Task-Codesegment an 2 oder mehr Stellen aufgerufen wird, muss es mit dem Schlüsselwort automatic deklariert werden.

Wenn die Task nicht mit automatic deklariert wird und die Task zweimal aufgerufen wird, kann es zu Signalinterferenzen kommen, beispielsweise wie im folgenden Code beschrieben:

Beispiel

task test_flag ;
        input [3:0]       cnti ;
        input             en ;
        output [3:0]      cnto ;
        if (en) cnto = cnti ;
endtask

reg          en_cnt ;
reg [3:0]    cnt_temp ;
initial begin
        en_cnt    = 1 ;
        cnt_temp  = 0 ;
        #25 ;     en_cnt = 0 ;
end
always #10 cnt_temp = cnt_temp + 1 ;

reg [3:0]             cnt1, cnt2 ;
always @(posedge clk) test_flag(2, en_cnt, cnt1);       //task(1)
always @(posedge clk) test_flag(cnt_temp, !en_cnt, cnt2);//task(2)

Die Simulationsergebnisse sind wie folgt.

Wenn en_cnt high ist, ist das Signal en in task (1) aktiv, und cnt1 kann den korrekten Logikwert ausgeben;

Zu diesem Zeitpunkt ist das Signal en in task (2) nicht aktiviert, daher wird der Wert von cnt2 durch die von task (1) angesteuerte gemeinsam genutzte Variable cnt_temp überschrieben.

Wenn en_cnt low ist, ist das Signal en in task (2) aktiv, sodass das Signal cnt2 in task (2) den korrekten Logikwert ausgeben kann; zu diesem Zeitpunkt wird unter der Taktansteuerung der Wert des Signals cnt1 wiederholt durch die von task (2) angesteuerte gemeinsam genutzte Variable cnt_temp überschrieben.

Es ist ersichtlich, dass bei den zwei gleichzeitigen Aufrufen die task gemeinsam genutzten Speicherplatz verwendet, wodurch sich die Signale gegenseitig beeinflussen.

Die anderen Beschreibungen bleiben unverändert; nur das Schlüsselwort automatic wird der obigen task-Deklaration hinzugefügt, wie folgt.

task automatic test_flag ;

Die Simulationsergebnisse zu diesem Zeitpunkt sind wie folgt.

  • Wenn en_cnt high ist, kann das Signal cnt1 in task (1) den korrekten Logikwert ausgeben, und der Wert des Signals cnt2 in task (2) ist X;
  • Wenn en_cnt low ist, kann das Signal cnt2 in task (2) den korrekten Logikwert ausgeben, und der Wert des Signals cnt1 in task (1) ist X;

Es ist ersichtlich, dass bei den zwei gleichzeitigen Aufrufen die Signale sich nicht gegenseitig beeinflussen, weil die Speicherbereiche voneinander unabhängig sind.

Quellcode-Download

Herunterladen