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:
| Vergleichspunkt | Funktion | Aufgabe |
|---|---|---|
| Eingabe | Eine Funktion muss mindestens einen Eingang haben, und die Portdeklaration darf keinen inout-Typ enthalten | Ein Task kann keinen Eingang oder mehrere Eingänge haben, und die Portdeklaration kann vom Typ inout sein |
| Ausgabe | Eine Funktion hat keinen Ausgang | Ein Task kann keinen Ausgang oder mehrere Ausgänge haben |
| Rückgabewert | Eine Funktion hat mindestens einen Rückgabewert | Ein Task hat keinen Rückgabewert |
| Simulationszeit | Eine Funktion beginnt immer zur Zeit null mit der Ausführung | Ein Task kann zu Zeiten ungleich null ausgeführt werden |
| Sequenzielle Logik | Eine Funktion darf keine Zeitsteuerungslogik enthalten | Ein Task darf keine always-Anweisungen enthalten, kann aber andere Zeitsteuerungen wie Verzögerungsanweisungen enthalten |
| Aufruf | Eine Funktion kann nur Funktionen aufrufen, keine Tasks | Ein Task kann Funktionen und Tasks aufrufen |
| Coding-Standards | Eine Funktion darf nicht als eigenständige Anweisung auftreten; sie kann nur auf der rechten Seite einer Zuweisungsanweisung stehen | Ein 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
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
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
#(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
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
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
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