Mots-clés : setup hold recovery removal width period

Spécifier les délais de chemin a pour but de rendre le timing de simulation plus proche du timing des circuits numériques réels. L'utilisation de contraintes de timing pour effectuer une simulation temporelle sur des conceptions numériques, vérifier si la conception présente des violations des contraintes de timing, puis la modifier, est également un processus indispensable dans la conception numérique.

Verilog fournit certaines tâches système pour les vérifications de timing. Ces tâches système ne peuvent être appelées qu'à l'intérieur de blocs specify. Ce qui suit présente 6 tâches système couramment utilisées pour les vérifications de timing : $setup, $hold, $recovery, $removal, $width et $period.

$setup, $hold

La tâche système $setup est utilisée pour vérifier la contrainte de temps de setup des composants dans une conception, et $hold est utilisée pour vérifier la contrainte de temps de maintien. Leur format d'utilisation est le suivant :

$setup(data_event, ref_event, setup_limit);
  • data_event : le signal à vérifier, pour déterminer s'il viole la contrainte
  • ref_event : le signal de référence utilisé pour la vérification, généralement le front du signal d'horloge
  • setup_limit : le temps de setup minimum configuré

SiT( ref_event - data_event) < setup_limit, alors un rapport de l'existence deviolationsera imprimé.

$hold(ref_event, data_event, hold_limit);
  • data_event : le signal à vérifier, pour déterminer s'il viole la contrainte
  • ref_event : le signal de référence utilisé pour la vérification, généralement le front du signal d'horloge
  • hold_limit : le temps de maintien minimum configuré

SiT( data_event - ref_event ) < hold_limit, alors un rapport de l'existence d'uneviolationsera imprimé.

Remarque :Les positions des ports d'entrée de $setup et $hold sont différentes.

Verilog fournit des tâches système pour vérifier simultanément le temps de setup et le temps de hold :

$setuphold (ref_event, data_event, setup_limit, hold_limit);

Ce qui suit complète une opération de multiplication d'un nombre par 15 pour illustrer l'utilisation de $setup et $hold.

En Verilog, la multiplication d'une variable par une constante se fait généralement par décalage et addition. Par exemple, la multiplication de la variable num par 15 peut s'exprimer comme :

num x 15 = (num << 3) + (num << 2) + (num << 1) + num

Cette opération nécessite 3 additionneurs. Ci-dessous, l'additionneur est modélisé et les délais de chemin sont spécifiés.

Pour la description fonctionnelle de l'additionneur complet, voirla section 3.1 du tutoriel Verilog。

Exemple

//additionneur complet 1 bit, spécifier les délais de chemin
module full_adder1(
   input   Ai, Bi, Ci,
   output  So, Co);

   assign So = Ai ^ Bi ^ Ci ;
   assign Co = (Ai & Bi) | (Ci & (Ai | Bi));

   spécifier
      (Ai, Bi, Ci *> So) = 1.1 ;
      (Ai, Bi     *> Co) = 1.3 ;
      (Ci         => Co) = 1.2 ;
   endspecify
endmodule

//instanciation d'un additionneur de 8 bits
module full_adder8(
     input [7:0]   a ,   //additionneur1
     input [7:0]   b ,   //additionneur2
     input         c ,   //bit de retenue d'entrée
     output [7:0]  so ,  //résultat de l'addition
     output        co    //bit de retenue de sortie
     );

   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

La bascule de 8 bits de large est décrite comme suit. Les délais de chemin sont spécifiés dans la bascule, et des contrôles de temps d'établissement et de maintien sont ajoutés.

Le temps d'établissement est fixé à 2ns, et le temps de maintien est fixé à 3ns.

Exemple

module D8(
    input       [7:0]   d ,
    input               clk ,
    output reg [7:0]    q);

   always @(posedge clk)
     q <= d ;
   spécifier
      $setup(d, posedge clk, 2);
      $hold(posedge clk, d, 3);
      (d,clk *> q) = 0.3 ;
   endspecify
endmodule

Dans le banc de test, effectuez l'opération de multiplication par 15 et envoyez le résultat au registre de l'étage suivant en un cycle.

Exemple

`timescale 1ns/1ns
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

   //nombre à multiplier par 15
   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     ());
   
   //stocker le résultat
   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

Le rapport de simulation affiche ensuite les messages imprimés avec les violations de setup/hold. Quelques captures d'écran sont les suivantes.

La forme d'onde au moment de la violation est capturée comme illustré ci-dessous.

L'analyse est la suivante :

  • (1) Le temps de setup et le temps de hold présentent tous deux des violations. Bien que le résultat de sortie, qui est retardé d'un cycle d'horloge après que la variable num a été multipliée par 15 dans la simulation, soit correct, le circuit réel est très dangereux.
  • (2) Le temps de setup du signal dans la forme d'onde est de 166-164.4 = 1.6 ns, ce qui est inférieur au 2ns configuré, donc une violation est signalée.
  • (3) Le temps de maintien du signal dans la forme d'onde est de 168.2-166 = 2.2 ns, ce qui est inférieur à la valeur configurée de 3ns, donc une violation est signalée.
  • (4) La partie rouge de la figure est le processus intermédiaire de changement du signal d. Comme différents bits du signal ont des délais différents, plusieurs résultats différents peuvent apparaître au milieu.

Optimisation temporelle

L'optimisation temporelle du temps de maintien n'est généralement pas facile à contrôler au niveau de la description RTL ; elle relève du périmètre de travail des ingénieurs de conception backend, elle ne sera donc pas abordée ici.

Cette fois, nous abordons principalement et brièvement le problème d'optimisation lorsque le temps de setup ne satisfait pas les conditions de contrainte. D'après la section précédente « 3.3 Temps de setup et temps de maintien », nous savons que l'expression de contrainte du temps de setup est :

Tcq + Tcomb + Tsu <= Tclk + Tskew (1)
  • Tcq : délai de la borne d'horloge du registre à la borne Q ;
  • Tcomb : délai de la logique combinatoire dans le chemin de données ;
  • Tsu : temps d'établissement ;
  • Tclk : période d'horloge ;
  • Tskew : décalage d'horloge.

L'optimisation de cette inégalité peut être envisagée sous les aspects suivants :

  • (1) Sélectionner des composants de procédé présentant de bonnes caractéristiques temporelles ; plus les valeurs de Tcq et Tsu sont petites, mieux c'est ;
  • (2) Optimiser la logique combinatoire afin que le délai de la logique combinatoire Tcomb soit aussi petit que possible ;
  • (3) Réduire la fréquence d'horloge de fonctionnement et augmenter la période d'horloge Tclk ;
  • (4) Augmenter le décalage d'horloge (clock skew) Tskew. Cependant, un décalage d'horloge excessif peut causer d'autres problèmes, tels que des violations de temps de maintien ou des erreurs de logique fonctionnelle.

Lors de l'optimisation temporelle au niveau RTL, seules les méthodes (2) et (3) peuvent être envisagées.

Par exemple, faire passer la période d'horloge de fonctionnement de 10ns à 20ns dans la simulation ci-dessus permettra d'éviter la violation de setup.

Alternativement, ajustez la logique de sorte que les 3 opérations d'addition initialement effectuées en un cycle soient réparties sur deux cycles, avec un étage de registre supplémentaire ajouté entre les deux pour la mise en tampon, afin de réduire la pression temporelle. En même temps, la période de changement de la variable num doit également devenir le double de la durée d'origine.

Le banc de test est modifié comme suit :

Exemple

`timescale 1ns/1ns
`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     ());

   //====== pour un meilleur timing=========
   //ajout de tampon
   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

À ce moment, il n'y a plus de violations dans le rapport de simulation. La capture d'écran de la simulation est la suivante.

Comme on peut le voir sur la figure, la durée pendant laquelle le signal arrive en avance et reste stable peut atteindre 8.6 ns, ce qui satisfait pleinement à l'exigence de temps d'établissement.

Le principe fondamental de cette méthode est de répartir le timing de multiples transitions de signal sur plusieurs cycles afin de satisfaire aux exigences de contrainte de timing. De plus, la conception pipeline, la conception parallèle, etc., peuvent également optimiser le timing.

$recovery, $removal

Les notions de temps de setup et de temps de maintien interviennent toutes deux dans la conception des circuits synchrones.

Pour les bascules à réinitialisation asynchrone, le signal de réinitialisation asynchrone doit également satisfaire le temps de récupération et le temps de retrait afin de réinitialiser et de relâcher efficacement la réinitialisation, en évitant la métastabilité.

Lors de la libération de la réinitialisation, le signal de réinitialisation doit revenir à l'état non actif de réinitialisation un certain temps avant l'arrivée du front d'horloge actif. Cette durée est le temps de récupération. Elle est similaire au temps de setup d'une bascule avec une horloge synchrone.

Lors de la réinitialisation, le signal de réinitialisation doit rester inchangé pendant un certain temps après l'arrivée du front d'horloge actif. Cette durée est le temps de retrait. Elle est similaire au temps de maintien d'une bascule avec une horloge synchrone.

Le schéma du temps de récupération et du temps de retrait est le suivant.

Les tâches système $recovery et $removal sont utilisées pour vérifier respectivement le temps de récupération et le temps de retrait. Leur utilisation est la suivante :

$recovery (ref_event, data_event, recovery_limit) ;
  • ref_event : le signal de référence utilisé pour la vérification, généralement le front d'un signal clear ou reset ;
  • data_event : le signal vérifié, généralement le front du signal d'horloge.
  • recovery_limit : le temps de récupération minimum configuré.

Lorsque ref_event (réinitialisation) < data_event (horloge) et T(data_event - ref_event) < recovery_limit, c'est-à-dire si le signal de réinitialisation ne satisfait pas le temps de récupération avant l'arrivée du signal d'horloge, une violation sera imprimée dans le rapport.

$removal (ref_event, data_event, removal_limit) ;
  • ref_event : le signal de référence utilisé pour la vérification, généralement le front d'un signal clear ou reset ;
  • data_event : le signal vérifié, généralement le front du signal d'horloge.
  • removal_limit : le temps de retrait minimum configuré.

Lorsque ref_event (reset) > data_event (horloge) et T(ref_event - data_event) > removal_limit, c'est-à-dire si le signal de réinitialisation ne satisfait pas le temps de retrait après l'arrivée du signal d'horloge, une violation sera imprimée dans le rapport.

Verilog fournit des tâches système qui vérifient à la fois le retrait et le rétablissement :

$recrem (ref_event, data_event, recovery_limit, removal_limit);

$width, $period

Certaines conceptions numériques, telles que la mémoire flash, doivent également vérifier la largeur d'impulsion ou la période. Pour cela, Verilog fournit respectivement les tâches système $width et $period. L'utilisation est la suivante :

$width(ref_event, time_limit) ;
  • ref_event : événement déclenché sur front
  • time_limit : largeur d'impulsion minimale

$width est utilisé pour vérifier le temps entre l'événement déclenché sur front ref_event et le prochain front de transition opposé, couramment utilisé pour la vérification de la largeur d'impulsion. Si le temps entre deux fronts de transition opposés est inférieur à time_limit, une violation est signalée.

$period(ref_event, time_limit) ;

$period est utilisé pour vérifier le temps entre l'événement déclenché sur front ref_event et le prochain front de transition de même sens, couramment utilisé pour la vérification de la période d'horloge. Si le temps entre deux fronts de transition de même sens est inférieur à time_limit, le rapport imprimera une violation.

Le bloc specify pour vérifier la largeur et la période du signal CLK est décrit comme suit :

Exemple

   spécifier
      $width(posedge CLK, 10);  
      $period(posedge CLK, 20);
   endspecify

Téléchargement du code source de ce chapitre

Téléchargement