Masquage d'horloge

Typiquement, un arbre d'horloge est composé d'un grand nombre de tampons et d'inverseurs. Comme le signal d'horloge est le signal ayant la fréquence de commutation la plus élevée dans la conception, la consommation d'énergie de l'arbre d'horloge peut atteindre 30% de la consommation d'énergie totale de la conception. L'ajout d'un circuit de masquage d'horloge peut réduire l'activité de commutation de l'arbre d'horloge et économiser l'énergie de commutation. Par ailleurs, l'activité de commutation réduite des broches d'horloge réduit également la consommation d'énergie interne des registres. Par conséquent, adopter le masquage d'horloge peut réduire efficacement la consommation d'énergie.

Principe d'implémentation

En termes simples, la logique qui coupe l'horloge lorsqu'un module ou une bascule ne fonctionne pas, sans affecter le fonctionnement normal, peut être appelée logique de masquage d'horloge. Dans ce cas, l'horloge n'existe pas toujours, ce qui peut être décrit de manière imagée comme une « horloge masquée ».

Il existe principalement trois méthodes pour implémenter le masquage d'horloge.

1. Utilisation d'une logique ET

La méthode la plus simple consiste à effectuer directement une opération ET entre le signal d'activation d'horloge (masquage) et l'horloge.

Par exemple, en effectuant cette opération sur l'horloge d'un bloc RAM, le code est le suivant :

Exemple

// use and-logic
module  clkgate_basic
    (
        input           clk ,
        input           clken ,
        input           rstn ,
        input           wr_en ,
        input [3:0]     addr ,
        input [7:0]     data ,
        output [7:0]    q
     );

   //clk gate
  wire                 clk_gate = clk & clken ;
   ram #(4, 8)
      u1_ram16x8
        (
         .CLK   (clk_gate),
         .A     (addr),
         .D     (data),
         .EN    (clken),
         .WR    (wr_en),
         .Q     (q));

endmodule

Le modèle RAM est le suivant :

Exemple

module  ram
    #(  parameter       AW = 2 ,
        parameter       DW = 3 )
    (
        input                   CLK ,
        input [AW-1:0]          A ,
        input [DW-1:0]          D ,
        input                   EN ,
        input                   WR ,    //1 pour écriture et 0 pour lecture
        output reg [DW-1:0]     Q
     );

   parameter            MASK = 3 ;

   reg [DW-1:0]         mem [0:(1<<AW)-1] ;
   always @(posedge CLK) begin
      if (EN && WR) begin
         mem[A]  <= D ;
      end
      else if (EN && !WR) begin
         Q       <= mem[A] ;
      end
   end

endmodule

Le code du banc de test est le suivant :

Exemple

`timescale 1ns/1ns
module test ;
   //déclaration des signaux
   reg          rstn ;
   reg          clk ;
   reg          clken ;
   reg          wr_en ;
   reg [3:0]    addr ;
   reg [7:0]    data ;
   wire [7:0]   q ;

   initial begin
      rstn      = 0 ;
      #7 rstn   = 0 ;
   end

   always begin
      #50 clk = 0 ;
      #50 clk = 1 ;
   end

   //logique de données
   initial begin
      clken     = 0 ;
      wr_en     = 0 ;
      addr      = 4'h3 ;
      data      = 8'h31 ;
      # 53 ;
      //(1) écriture et lecture normales
      clken     = 1 ;
      wr_en     = 1 ;
      repeat(9) begin
         @(negedge clk) ;
         data   = data + 1 ;
         addr   = addr + 1 ;
      end
      @(negedge clk) ;
      clken     = 0 ;
      wr_en     = 0 ;

      //lecture
      #211;
      addr      = 4'h3 ;
      clken     = 1 ;
      repeat(9) begin
         @(negedge clk) ;
         addr   = addr + 1 ;
      end
      @(negedge clk) ;
      //fin
      clken     = 0 ;
   end // initial begin

   clkgate_basic u_ram_clkgate
    (
        .clk    (clk),
        .clken  (clken),
        .rstn   (rstn),
        .wr_en  (wr_en),
        .addr   (addr),
        .data   (data),
        .q      (q)
     );

   //fin de simulation
   always begin
      #100;
      if ($time >= 10000)  begin
         #1 ;
         $finish ;
      end
   end

endmodule

Capturez les signaux du port RAM ; les résultats de test sont les suivants.

Comme le montre la figure, pendant l'intervalle entre les opérations de lecture et d'écriture, l'horloge de la RAM a une période où elle reste à 0. L'horloge ne bascule pas lorsque la RAM ne fonctionne pas, ce qui en pratique réduit également considérablement la consommation d'énergie.

Les inconvénients de cette méthode sont également évidents. En raison de problèmes de timing ou de gigue, après avoir effectué une opération ET entre le signal d'activation de l'horloge et l'horloge, des parasites sont facilement générés, ce qui peut gravement affecter les circuits numériques.

Dans le testbench, effectuez une simulation non idéale du signal d'activation de l'horloge en ajoutant le code de simulation suivant :

Exemple

      //(2) gigue en fin de lecture
      #985;
      addr      = 4'h3 ;
      clken     = 1 ;
      repeat(9) begin
         @(negedge clk) ;
         addr   = addr + 1 ;
      end
      @(negedge clk) ;
      clken     = 0 ;
      #20 clken = 1 ;
      #21 clken = 0 ;
      #31 clken = 1 ;
      #13 clken = 0 ;

Les résultats de simulation de la lecture de la RAM sont les suivants.

On peut voir sur la figure qu'en raison de l'asynchronisme ou de la gigue du signal clken, des glitches sont apparus dans l'entrée d'horloge de la RAM. La donnée à l'adresse 0x3 est manquée (en lien avec le timing du signal de validation), et la donnée à l'adresse 0xC est lue deux fois. De toute évidence, la conception logique de ce masquage d'horloge est très dangereuse.

Pour résoudre de tels problèmes, une structure à latch est nécessaire pour éliminer les glitches.

2. Utilisation d'un latch

Dans le chapitre du tutoriel Verilog« 6.5 Verilog : éviter les latches », il est mentionné que la génération de latches doit être évitée dans la conception numérique, mais le masquage d'horloge est une exception. Par conséquent, lors de l'analyse temporelle, il n'est pas nécessaire de s'inquiéter des latches générés par la partie de masquage d'horloge.

Le schéma de circuit pour utiliser un latch afin d'éliminer les glitches de masquage d'horloge est présenté ci-dessous.

Le signal de validation d'horloge est verrouillé sur le front descendant de l'horloge et maintenu inchangé pendant un cycle d'horloge. Le signal verrouillé est ensuite mis en AND avec l'horloge, ce qui peut éliminer les glitches dans l'horloge masquée.

Réécrivez la partie logique de masquage d'horloge de l'exemple de simulation qui utilise directement l'opération AND pour utiliser une logique à latch, avec les modifications comme suit :

Exemple

   //(2) utilisation d'un latch
   reg                  en_latch ;
   always @(*) begin
      if (!clk) begin
         en_latch       = clken ;
      end
   end
   wire clk_gate = clk & en_latch ;

Les résultats de la simulation sont les suivants.

Bien que les données à l'adresse 0x3 soient encore manquées (lié au timing du signal d'activation), l'horloge de la RAM est maintenant une horloge normale et aucun glitch n'apparaît (le signal CLK surligné en jaune).

3. Utilisation d'une bibliothèque de cellules standard

Bien que l'utilisation d'un verrou puisse résoudre l'apparition de glitches dans le masquage d'horloge, le timing nécessite également des contraintes strictes.

Dans la conception FPGA ou CI, la bibliothèque de synthèse contient souvent des cellules logiques de masquage intégrées. De telles cellules logiques de masquage ont subi de nombreuses itérations et vérifications, ce qui les rend plus pratiques et plus sûres à utiliser.

Par conséquent, en général, les conceptions de masquage d'horloge instancient directement des cellules logiques de masquage intégrées dédiées. La méthode d'instanciation est similaire à celle des cellules de base telles que les portes ET et les tampons ; il suffit de les instancier directement.

Utilisation

Une utilisation correcte de la logique de masquage d'horloge pour contrôler l'horloge du circuit peut également réduire efficacement la consommation d'énergie.

1. Masquage manuel

Ajouter un signal d'activation d'horloge pour contrôler manuellement la présence de l'horloge de fonctionnement du module.

Lorsque le module fonctionne, le signal d'activation est mis à l'état actif et l'horloge est activée ; lorsque le module est inactif, le signal d'activation est mis à l'état inactif et l'horloge est coupée, ce qui permet d'économiser de l'énergie.

La conception de simulation de la section précédente peut être considérée comme un exemple de masquage manuel. Pendant la lecture/écriture de la RAM, le signal d'activation est haut, l'horloge de la RAM est activée et la RAM commence à fonctionner ; lorsque le signal d'activation est bas, la RAM ne fonctionne pas et il n'y a pas d'horloge d'entrée à ce moment-là.

2. Gating automatique

Pendant son fonctionnement, un module peut détecter automatiquement son propre état de fonctionnement et émettre un signal d'occupation. En externe, ce signal indicateur peut être utilisé pour appliquer un gating d'horloge à une partie de la logique interne du module, réduisant ainsi les basculements d'horloge et permettant un contrôle automatique du gating.

Contrairement au gating manuel, ces modules ont de brefs états d'inactivité pendant leur fonctionnement. Le gating automatique consiste à couper les horloges inutilisées pendant ces brefs états d'inactivité, plutôt que de couper directement l'horloge de tout le module comme le gating manuel ; sinon, le module ne fonctionnerait plus normalement.

Par exemple, un UART présente un état d'inactivité après avoir terminé une transmission de données. À ce moment-là, les horloges de modules tels que la logique FIFO et la logique de génération de débit en bauds peuvent être automatiquement coupées.

Par exemple, dans une conception contenant un CPU, une logique peut être ajoutée pour détecter l'état d'inactivité du bus et contrôler automatiquement la commutation de l'horloge du bus afin de réduire la consommation d'énergie.

En raison de contraintes de place, aucun exemple de simulation n'est fourni ici.

3. Insertion automatique de gating

Lorsque la synthèse logique est effectuée après la conception RTL, le compilateur optimisera également automatiquement la logique du code, ce qui inclut le gating des entrées d'horloge de certaines bascules. Par exemple, la description RTL d'une bascule D synchrone avec une entrée de validation est la suivante :

Exemple

   //(2) Bascule avec port d'activation
   always @(posedge CLK) begin
      if (EN) begin
         Q       = D ;
      end
   end

Sa forme d'onde de simulation RTL avant synthèse est présentée ci-dessous :

La forme d'onde de simulation après synthèse se présente souvent comme ci-dessous :

D'après la comparaison, on peut voir qu'après la synthèse le signal EN n'existe plus, et que l'horloge (borne CP) n'est plus présente en continu après le clock gating. Cela garantit non seulement la justesse logique, mais réduit également le basculement d'horloge et la consommation d'énergie.

Téléchargement du code source de ce chapitre

Téléchargement