Schlüsselwörter: setup hold recovery removal width period
Die Angabe von Pfadverzögerungen soll das Timing der Simulation näher an das Timing tatsächlicher digitaler Schaltungen bringen. Timing-Constraints zu verwenden, um Timing-Simulationen an digitalen Designs durchzuführen, zu prüfen, ob das Design Verletzungen von Timing-Constraints aufweist, und es dann zu modifizieren, ist ebenfalls ein unverzichtbarer Prozess im digitalen Design.
Verilog stellt einige Systemaufgaben für Timing-Checks bereit. Diese Systemaufgaben können nur innerhalb von specify-Blöcken aufgerufen werden. Im Folgenden werden 6 häufig verwendete Systemaufgaben für Timing-Checks vorgestellt: $setup, $hold, $recovery, $removal, $width und $period.
$setup, $hold
Die Systemaufgabe $setup wird verwendet, um die Setup-Zeit-Beschränkung von Komponenten in einem Design zu prüfen, und $hold wird verwendet, um die Hold-Zeit-Beschränkung zu prüfen. Ihr Verwendungsformat ist wie folgt:
$setup(data_event, ref_event, setup_limit);
- data_event: das zu prüfende Signal, um festzustellen, ob es die Beschränkung verletzt
- ref_event: das zum Prüfen verwendete Referenzsignal, normalerweise die Flanke des Taktsignals
- setup_limit: die konfigurierte minimale Setup-Zeit
WennT( ref_event - data_event) < setup_limit, dann wird ein Bericht über das Vorliegen einerVerletzunggedruckt.
$hold(ref_event, data_event, hold_limit);
- data_event: das zu prüfende Signal, um festzustellen, ob es die Beschränkung verletzt
- ref_event: das zum Prüfen verwendete Referenzsignal, normalerweise die Flanke des Taktsignals
- hold_limit: die konfigurierte minimale Hold-Zeit
T( data_event - ref_event ) < hold_limit, dann wird ein Bericht über das Vorliegen einerVerletzungausgegeben.will be printed.
Hinweis:Die Positionen der Eingangsports von $setup und $hold sind unterschiedlich.
Verilog bietet Systemaufgaben zum gleichzeitigen Prüfen von Setup-Zeit und Hold-Zeit:
$setuphold (ref_event, data_event, setup_limit, hold_limit);
Das Folgende vervollständigt eine Operation zum Multiplizieren einer Zahl mit 15, um die Verwendung von $setup und $hold zu veranschaulichen.
In Verilog erfolgt das Multiplizieren einer Variablen mit einer Konstanten üblicherweise durch Verschieben und Addieren. Zum Beispiel kann das Multiplizieren der Variablen num mit 15 ausgedrückt werden als:
num x 15 = (num << 3) + (num << 2) + (num << 1) + num
Diese Operation erfordert 3 Addierer. Im Folgenden wird der Addierer modelliert und Pfadverzögerungen werden angegeben.
Für die funktionale Beschreibung des Volladdierers sieheAbschnitt 3.1 des Verilog-Tutorials。
Beispiel
module full_adder1(
input Ai, Bi, Ci,
output So, Co);
assign So = Ai ^ Bi ^ Ci ;
assign Co = (Ai & Bi) | (Ci & (Ai | Bi));
angeben
(Ai, Bi, Ci *> So) = 1.1 ;
(Ai, Bi *> Co) = 1.3 ;
(Ci => Co) = 1.2 ;
endspecify
endmodule
//Instanziierung eines 8-Bit-breiten Addierers
module full_adder8(
input [7:0] a , //Addierer1
input [7:0] b , //Addierer2
input c , //Eingangs-Carry-Bit
output [7:0] so , //Additionsergebnis
output co //Ausgangs-Carry-Bit
);
wire [7:0] co_temp ;
full_adder1 u_adder0(
.Ai (a[0]),
.Bi (b[0]),
.Ci (c==1'b1 ? 1'b1 : 1'b0),
.So (so[0]),
.Co (co_temp[0]));
genvar i ;
generate
for(i=1; i<=7; i=i+1) begin: adder_gen
full_adder1 u_adder(
.Ai (a[i]),
.Bi (b[i]),
.Ci (co_temp[i-1]),
.So (so[i]),
.Co (co_temp[i]));
end
endgenerate
assign co = co_temp[7] ;
endmodule
Das 8-Bit-breite Flip-Flop wird wie folgt beschrieben. Pfadverzögerungen werden im Flip-Flop angegeben, und Setup- und Hold-Zeit-Timingprüfungen werden hinzugefügt.
Die Setup-Zeit wird auf 2ns gesetzt, und die Hold-Zeit wird auf 3ns gesetzt.
Beispiel
input [7:0] d ,
input clk ,
output reg [7:0] q);
always @(posedge clk)
q <= d ;
angeben
$setup(d, posedge clk, 2);
$hold(posedge clk, d, 3);
(d,clk *> q) = 0.3 ;
endspecify
endmodule
In der Testbench führen Sie die Multiplikation mit 15 aus und geben das Ergebnis innerhalb eines Zyklus an das Register der nächsten Stufe aus.
Beispiel
module test ;
reg [3:0] a ;
reg [3:0] b ;
wire [3:0] so ;
wire co ;
parameter CYCLE_10NS = 10ns;
reg clk ;
initial begin
clk = 0 ;
# 111 ;
forever begin
#(CYCLE_10NS/2) clk = ~clk ;
end
end
//Zahl, die mit 15 multipliziert werden soll
reg [7:0] num = 0 ;
always @(posedge clk) begin
num[3:0] <= num[3:0] + 1 ;
end
// num * 8 + num * 4
wire [7:0] adder1 ;
full_adder8 u1_adder8(
.a (num<<2),
.b (num<<3),
.c (1'b0),
.so (adder1),
.co ());
//num * 2 + num
wire [7:0] adder2 ;
full_adder8 u2_adder8(
.a (num<<1),
.b (num),
.c (1'b0),
.so (adder2),
.co ());
//num x 15
wire [7:0] adder3 ;
full_adder8 u3_adder8(
.a (adder1),
.b (adder2),
.c (1'b0),
.so (adder3),
.co ());
//Ergebnis speichern
wire [7:0] res_mul15 ;
D8 data_store(
.d (adder3),
.clk (clk),
.q (res_mul15));
initial begin
forever begin
#100;
if ($time >= 1000) $finish ;
end
end
endmodule // test
Der Simulationsbericht zeigt dann ausgegebene Meldungen mit setup/hold-Verletzungen. Einige Screenshots sind wie folgt.

Die Wellenform zum Zeitpunkt der Verletzung wird wie unten dargestellt aufgezeichnet.

Die Analyse sieht wie folgt aus:
- (1) Sowohl die Setup-Zeit als auch die Hold-Zeit weisen Verletzungen auf. Obwohl das Ausgabeergebnis, das nach der Multiplikation der Variable num mit 15 in der Simulation um einen Taktzyklus verzögert wird, korrekt ist, ist die tatsächliche Schaltung sehr gefährlich.
- (2) Die Setup-Zeit des Signals in der Wellenform beträgt 166-164.4 = 1.6 ns, was weniger als die konfigurierten 2ns ist, daher wird eine Verletzung gemeldet.
- (3) Die Haltezeit des Signals in der Wellenform beträgt 168.2-166 = 2.2 ns, was weniger als die konfigurierten 3ns ist, daher wird ein Verstoß gemeldet.
- (4) Der rote Teil in der Abbildung ist der Zwischenprozess der Änderung des Signals d. Da unterschiedliche Bits des Signals unterschiedliche Verzögerungen haben, können in der Mitte mehrere unterschiedliche Ergebnisse auftreten.
Timing-Optimierung
Die Optimierung des Haltezeit-Timings ist auf der RTL-Ebene im Allgemeinen nicht leicht zu kontrollieren; sie gehört zum Arbeitsbereich der Backend-Design-Ingenieure und wird daher hier nicht behandelt.
Dieses Mal diskutieren wir hauptsächlich kurz das Optimierungsproblem, wenn die Setup-Zeit die Randbedingungen nicht erfüllt. Aus dem vorherigen Abschnitt '3.3 Setup-Zeit und Haltezeit' wissen wir, dass der Ausdruck für die Setup-Zeit-Bedingung lautet:
Tcq + Tcomb + Tsu <= Tclk + Tskew (1)
- Tcq: Verzögerung vom Taktanschluss des Registers zum Q-Anschluss;
- Tcomb: Verzögerung der kombinatorischen Logik im Datenpfad;
- Tsu: Setup-Zeit;
- Tclk: Taktperiode;
- Tskew: Taktversatz.
Die Optimierung dieser Ungleichung kann aus den folgenden Aspekten betrachtet werden:
- (1) Wählen Sie Prozesskomponenten mit guten Timing-Eigenschaften; je kleiner die Werte von Tcq und Tsu, desto besser;
- (2) Optimieren Sie die kombinatorische Logik, sodass die Verzögerung der kombinatorischen Logik Tcomb so klein wie möglich ist;
- (3) Reduzieren Sie die Betriebstaktfrequenz und erhöhen Sie die Taktperiode Tclk;
- (4) Erhöhen Sie den Clock-Skew Tskew. Ein übermäßiger Clock-Skew kann jedoch andere Probleme verursachen, wie z. B. Haltezeitverletzungen oder funktionale Logikfehler.
Bei der Timing-Optimierung auf RTL-Ebene können nur die Methoden (2) und (3) berücksichtigt werden.
Beispielsweise wird durch Ändern der Betriebstaktperiode von 10ns auf 20ns in der obigen Simulation die Setup-Verletzung vermieden.
Alternativ kann die Logik so angepasst werden, dass die drei Additionsoperationen, die ursprünglich in einem Taktzyklus abgeschlossen wurden, auf zwei Taktzyklen verteilt werden, wobei dazwischen eine zusätzliche Registerstufe zur Pufferung eingefügt wird, um den Timing-Druck zu verringern. Gleichzeitig sollte die Änderungsperiode der Variable num ebenfalls doppelt so lang wie ursprünglich werden.
Die Testbench wird wie folgt geändert:
Beispiel
`define LOGIC_BUF
module test ;
parameter CYCLE_10NS = 10ns;
reg clk ;
initial begin
clk = 0 ;
# 111 ;
forever begin
#(CYCLE_10NS/2) clk = ~clk ;
end
end
reg slow_flag = 0 ;
always @(posedge clk) begin
`ifdef LOGIC_BUF
slow_flag <= ~slow_flag ;
`else
slow_flag <= 1'b1 ;
`endif
end
reg [7:0] num = 0 ;
always @(posedge clk) begin
if(slow_flag)
num[3:0] <= num[3:0] + 1 ;
end
wire [7:0] adder1 ;
full_adder8 u1_adder8(
.a (num<<2),
.b (num<<3),
.c (1'b0),
.so (adder1),
.co ());
wire [7:0] adder2 ;
full_adder8 u2_adder8(
.a (num<<1),
.b (num),
.c (1'b0),
.so (adder2),
.co ());
//====== für besseres Timing=========
//Puffer hinzufügen
wire [7:0] adder1_r, adder2_r ;
D8 adder1_buf(
.d (adder1),
.clk (clk),
.q (adder1_r));
D8 adder2_buf(
.d (adder2),
.clk (clk),
.q (adder2_r));
`ifdef LOGIC_BUF
wire [7:0] adder1_t = adder1_r ;
wire [7:0] adder2_t = adder2_r ;
`else
wire [7:0] adder1_t = adder1 ;
wire [7:0] adder2_t = adder2 ;
`endif
wire [7:0] adder3 ;
full_adder8 u3_adder8(
.a (adder1_t),
.b (adder2_t),
.c (1'b0),
.so (adder3),
.co ());
wire [7:0] res_mul15 ;
D8 data_store(
.d (adder3),
.clk (clk),
.q (res_mul15));
initial begin
forever begin
#100;
if ($time >= 1000) $finish ;
end
end
endmodule // test
Zu diesem Zeitpunkt gibt es keine weiteren Verstöße im Simulationsbericht. Der Simulations-Screenshot sieht wie folgt aus.
Wie aus der Abbildung ersichtlich ist, kann die Zeit, in der das Signal früh eintrifft und stabil bleibt, 8.6 ns erreichen und erfüllt damit vollständig die Timing-Anforderung an die Setup-Zeit.
Das Grundprinzip dieser Methode besteht darin, die Zeitpunkte mehrerer Signalübergänge über mehrere Zyklen zu verteilen, um Timing-Constraint-Anforderungen zu erfüllen. Darüber hinaus können auch Pipeline-Design, paralleles Design usw. das Timing optimieren.

$recovery, $removal
Die Konzepte der Setup-Zeit und der Hold-Zeit treten beide beim Entwurf synchroner Schaltungen auf.
Bei Flip-Flops mit asynchronem Reset muss das asynchrone Reset-Signal auch die Recovery-Zeit und die Removal-Zeit einhalten, um den Reset effektiv zurückzusetzen und freizugeben und Metastabilität zu verhindern.
Beim Freigeben des Resets muss das Reset-Signal eine Zeitspanne vor dem Eintreffen der aktiven Taktflanke in den Nicht-Reset-Zustand zurückkehren. Diese Zeitspanne ist die Recovery-Zeit. Sie ähnelt der Setup-Zeit eines Flip-Flops bei einem synchronen Takt.
Beim Zurücksetzen muss das Reset-Signal eine Zeitspanne nach dem Eintreffen der aktiven Taktflanke unverändert bleiben. Diese Zeitspanne ist die Removal-Zeit. Sie ähnelt der Hold-Zeit eines Flip-Flops bei einem synchronen Takt.
Das schematische Diagramm der Recovery- und Removal-Zeit ist wie folgt.

Die Systemaufgaben $recovery und $removal werden verwendet, um die Recovery- bzw. Removal-Zeit zu prüfen. Ihre Verwendung ist wie folgt:
$recovery (ref_event, data_event, recovery_limit) ;
- ref_event: das Referenzsignal, das zur Prüfung verwendet wird, normalerweise die Flanke eines Clear- oder Reset-Signals;
- data_event: das zu prüfende Signal, normalerweise die Taktflanke.
- recovery_limit: die konfigurierte minimale Recovery-Zeit.
Wenn ref_event (Reset) < data_event (Takt) und T(data_event - ref_event) < recovery_limit, d. h., wenn das Reset-Signal die Recovery-Zeit vor dem Eintreffen des Taktsignals nicht einhält, wird eine Verletzung im Bericht ausgegeben.
$removal (ref_event, data_event, removal_limit) ;
- ref_event: das Referenzsignal, das zur Prüfung verwendet wird, normalerweise die Flanke eines Clear- oder Reset-Signals;
- data_event: das zu prüfende Signal, normalerweise die Taktflanke.
- removal_limit: die konfigurierte minimale Removal-Zeit.
Wenn ref_event (Reset) > data_event (Clock) und T(ref_event - data_event) > removal_limit, d. h., wenn das Reset-Signal die Removal-Zeit nach dem Eintreffen des Clock-Signals nicht einhält, wird eine Verletzung im Bericht ausgegeben.
Verilog bietet System-Tasks, die sowohl Removal- als auch Recovery-Prüfungen durchführen:
$recrem (ref_event, data_event, recovery_limit, removal_limit);
$width, $period
Einige digitale Designs, wie z. B. Flash-Speicher, müssen auch die Pulsbreite oder Periode prüfen. Dafür bietet Verilog die System-Tasks $width bzw. $period. Die Verwendung ist wie folgt:
$width(ref_event, time_limit) ;
- ref_event: flankengetriggertes Ereignis
- time_limit: minimale Pulsbreite
$width wird verwendet, um die Zeit vom flankengetriggerten Ereignis ref_event bis zur nächsten entgegengesetzten Übergangsflanke zu prüfen, üblicherweise zur Pulsbreitenprüfung. Wenn die Zeit zwischen zwei entgegengesetzten Übergangsflanken kleiner als time_limit ist, wird eine Verletzung gemeldet.
$period(ref_event, time_limit) ;
$period wird verwendet, um die Zeit vom flankengetriggerten Ereignis ref_event bis zur nächsten gleichsinnigen Übergangsflanke zu prüfen, üblicherweise zur Taktperiodenprüfung. Wenn die Zeit zwischen zwei gleichsinnigen Übergangsflanken kleiner als time_limit ist, gibt der Bericht eine Verletzung aus.

Der Specify-Block zur Prüfung der Breite und Periode des Signals CLK wird wie folgt beschrieben:
Beispiel
$width(posedge CLK, 10);
$period(posedge CLK, 20);
endspecify
Quellcode-Download dieses Kapitels
Herunterladen