Principe du diviseur (virgule fixe)

Semblable à la division décimale, le processus de calcul de 27 divisé par 5 est le suivant :

Le processus de l'opération de division est le suivant :

  • (1) Prenez les bits de poids fort du dividende, avec une largeur de bits égale à celle du diviseur (données de 3 bits dans l'exemple).
  • (2) Comparez les données de poids fort du dividende avec le diviseur. Si les premières ne sont pas inférieures au diviseur, le bit de quotient correspondant est 1, et la différence entre les deux donne le reste de la première étape ; sinon, le bit de quotient correspondant est 0, et les premières sont directement utilisées comme reste.
  • (3) Concaténez le reste de l'étape précédente avec les données de 1 bit de poids fort restantes du dividende pour former de nouvelles données, puis comparez-les avec le diviseur. Un nouveau quotient et un nouveau reste peuvent être obtenus.
  • (4) Répétez le processus (3) jusqu'à ce que le bit de poids faible du dividende soit également impliqué dans le calcul.

Il convient de noter que la largeur de bits du quotient doit être cohérente avec celle du dividende, car le diviseur peut être 1.Par conséquent, dans l'exemple de division manuelle ci-dessus, lors de la première comparaison, le bit de poids fort 1 du nombre 27 (3'b001) doit être comparé à 3'b101.Sur la base de ce processus de calcul, concevez un diviseur pipeline à largeur de bits configurable, où le nombre de cycles de retard du pipeline est égal à la largeur de bits du dividende.

Conception du diviseur

Conception de l'opération en une seule étape

Dans la division en une seule étape, la largeur de bits du dividende d'une seule étape (signal dividend) doit être supérieure de 1 bit à celle du diviseur d'origine (signal divisor) pour éviter tout débordement.

Pour faciliter la mise en pipeline, la sortie nécessite des registres pour stocker le diviseur d'origine (signaux divisor et divisor_kp) et les informations sur le dividende (signaux dividend_ci et dividend_kp).

Le résultat de l'opération en une seule étape est un nouveau quotient de 1 bit (signal merchant) et un nouveau reste (signal remainder).

Pour obtenir le résultat final de la division, le nouveau quotient de 1 bit (signal merchant) doit également être décalé et accumulé avec le résultat de quotient du cycle précédent (merchant_ci).

La conception de l'unité d'opération en une seule étape est la suivante (nom de fichier : divider_cell.v) :

Exemple

// le paramètre M signifie la largeur réelle du diviseur
module    divider_cell
    #(paramètre N=5,
      paramètre M=3)
    (
      input                     clk,
      input                     rstn,
      input                     en,

      input [M:0]               dividend,
      input [M-1:0]             divisor,
      input [N-M:0]             merchant_ci , //Sortie du quotient de l'étage précédent
      input [N-M-1:0]           dividend_ci , //Diviseur d'origine

      output reg [N-M-1:0]      dividend_kp,  //Informations sur le dividende d'origine
      output reg [M-1:0]        divisor_kp,   //Informations sur le diviseur d'origine
      output reg                rdy ,
      output reg [N-M:0]        merchant ,  //Sortie de quotient de l'unité d'opération
      output reg [M-1:0]        remainder   //Sortie de reste de l'unité d'opération
    );

    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            rdy            <= 'b0 ;
            merchant       <= 'b0 ;
            remainder      <= 'b0 ;
            divisor_kp     <= 'b0 ;
            dividend_kp    <= 'b0 ;
        end
        else if (en) begin
            rdy            <= 1'b1 ;
            divisor_kp     <= divisor ;  //Le diviseur d'origine reste inchangé
            dividend_kp    <= dividend_ci ;  //Le dividende d'origine est transmis tel quel
            if (dividend >= {1'b0, divisor}) begin
                merchant    <= (merchant_ci<<1) + 1'b1 ; //Le quotient est 1
                remainder   <= dividend - {1'b0, divisor} ; //Calculer le reste
            end
            else begin
                merchant    <= merchant_ci<<1 ;  //Le quotient est 0
                remainder   <= dividend ;        //Reste inchangé
            end
        end // si (en)
        else begin
            rdy            <= 'b0 ;
            merchant       <= 'b0 ;
            remainder      <= 'b0 ;
            divisor_kp     <= 'b0 ;
            dividend_kp    <= 'b0 ;
        end
    end

endmodule

Instanciation d'étage de pipeline

Concaténez le reste (signal remainder) issu du calcul à une étape avec les données de 1 bit correspondantes du dividende d'origine (signal dividend), et utilisez-le comme nouvelle entrée de dividende à une étape pour l'unité de division à une étape suivante.

Parmi eux, les informations de données de dividende, de diviseur et de quotient doivent également être transmises à l'unité d'opération suivante.

La conception du diviseur réalisée en instanciant des modules d'étage de pipeline est la suivante (nom de fichier : divider_man.v) :

Exemple

//parameter N désigne la largeur réelle du dividende
//en utilisant 29/5=5...4
module    divider_man
    #(paramètre N=5,
      paramètre M=3,
      parameter N_ACT = M+N-1)
    (
      input                     clk,
      input                     rstn,

      input                     data_rdy ,  //Validation des données
      input [N-1:0]             dividend,   //Dividende
      input [M-1:0]             divisor,    //Diviseur

      output                    res_rdy ,
      output [N_ACT-M:0]        merchant ,  //Largeur en bits du quotient : N
      output [M-1:0]            remainder ); //Reste final

    wire [N_ACT-M-1:0]   dividend_t [N_ACT-M:0] ;
    wire [M-1:0]         divisor_t [N_ACT-M:0] ;
    wire [M-1:0]         remainder_t [N_ACT-M:0];
    wire [N_ACT-M:0]     rdy_t ;
    wire [N_ACT-M:0]     merchant_t [N_ACT-M:0] ;

    //Initialiser la première unité d'opération
    divider_cell      #(.N(N_ACT), .M(M))
       u_divider_step0
    ( .clk              (clk),
      .rstn             (rstn),
      .en               (data_rdy),
      //Utiliser la donnée de 1 bit la plus significative du dividende comme dividende pour la première opération en une seule étape, avec les bits de poids fort complétés par 0
      .dividend         ({{(M){1'b0}}, dividend[N-1]}),
      .divisor          (divisor),                  
      .merchant_ci      ({(N_ACT-M+1){1'b0}}),   //Quotient initialement à 0
      .dividend_ci      (dividend[N_ACT-M-1:0]), //Dividende d'origine
      //sortie
      .dividend_kp      (dividend_t[N_ACT-M]),   //Informations sur le dividende d'origine transmises
      .divisor_kp       (divisor_t[N_ACT-M]),    //Informations sur le diviseur d'origine transmises
      .rdy              (rdy_t[N_ACT-M]),
      .merchant         (merchant_t[N_ACT-M]),   //Résultat du premier quotient
      .remainder        (remainder_t[N_ACT-M])   //Premier reste
      );

    genvar               i ;
    generate
        for(i=1; i<=N_ACT-M; i=i+1) begin: sqrt_stepx
            divider_cell      #(.N(N_ACT), .M(M))
              u_divider_step
              (.clk              (clk),
               .rstn             (rstn),
               .en               (rdy_t[N_ACT-M-i+1]),
               .dividend         ({remainder_t[N_ACT-M-i+1], dividend_t[N_ACT-M-i+1][N_ACT-M-i]}),   //Concaténer le reste avec les données d'un seul bit du dividende d'origine
               .divisor          (divisor_t[N_ACT-M-i+1]),
               .merchant_ci      (merchant_t[N_ACT-M-i+1]),
               .dividend_ci      (dividend_t[N_ACT-M-i+1]),
               //sortie
               .divisor_kp       (divisor_t[N_ACT-M-i]),
               .dividend_kp      (dividend_t[N_ACT-M-i]),
               .rdy              (rdy_t[N_ACT-M-i]),
               .merchant         (merchant_t[N_ACT-M-i]),
               .remainder        (remainder_t[N_ACT-M-i])
              );
        end // bloc : sqrt_stepx
    endgenerate

    assign res_rdy       = rdy_t[0];
    assign merchant      = merchant_t[0];  //Dernier résultat de quotient comme quotient final
    assign remainder     = remainder_t[0]; //Dernier reste comme reste final

endmodule

testbench

Régler la largeur de bits du dividende à 5 et la largeur de bits du diviseur à 3, et ajouter une auto-vérification dans le banc de test, décrite comme suit :

Exemple

`timescale 1ns/1ns

module test ;
    paramètre    N = 5 ;
    paramètre    M = 3 ;
    reg          clk;
    reg          rstn ;
    reg          data_rdy ;
    reg [N-1:0]  dividend ;
    reg [M-1:0]  divisor ;

    wire         res_rdy ;
    wire [N-1:0] merchant ;
    wire [M-1:0] remainder ;

    //horloge
    always begin
        clk = 0 ; #5 ;
        clk = 1 ; #5 ;
    end

    //pilote
    initial begin
        rstn      = 1'b0 ;
        #8 ;
        rstn      = 1'b1 ;

        #55 ;
        @(negedge clk ) ;
        data_rdy  = 1'b1 ;
                dividend  = 25;      divisor      = 5;
        #10 ;   dividend  = 16;      divisor      = 3;
        #10 ;   dividend  = 10;      divisor      = 4;
        #10 ;   dividend  = 15;      divisor      = 1;
        repeat(32)    #10   dividend   = dividend + 1 ;
        divisor      = 7;
        repeat(32)    #10   dividend   = dividend + 1 ;
        divisor      = 5;
        repeat(32)    #10   dividend   = dividend + 1 ;
        divisor      = 4;
        repeat(32)    #10   dividend   = dividend + 1 ;
        divisor      = 6;
        repeat(32)    #10   dividend   = dividend + 1 ;
    end

    //Retarder l'entrée afin que les résultats de données puissent être comparés dans le même cycle pour effectuer l'autocontrôle
    reg  [N-1:0]   dividend_ref [N-1:0];
    reg  [M-1:0]   divisor_ref [N-1:0];
    always @(posedge clk) begin
        dividend_ref[0] <= dividend ;
        divisor_ref[0]  <= divisor ;
    end

    genvar         i ;
    generate
        for(i=1; i<=N-1; i=i+1) begin
            always @(posedge clk) begin
                dividend_ref[i] <= dividend_ref[i-1];
                divisor_ref[i]  <= divisor_ref[i-1];
            end
        end
    endgenerate

    //Autocontrôle
    reg  error_flag ;
    always @(posedge clk) begin
    # 1 ;
        if (merchant * divisor_ref[N-1] + remainder != dividend_ref[N-1] && res_rdy) beginb      //Dans le banc de test, le signe de multiplication peut être utilisé directement sans tenir compte des cycles d'opération
            error_flag <= 1'b1 ;
        end
        else begin
            error_flag <= 1'b0 ;
        end
    end

    //instanciation de module
    divider_man  #(.N(N), .M(M))
    u_divider
     (
      .clk              (clk),
      .rstn             (rstn),
      .data_rdy         (data_rdy),
      .dividend         (dividend),
      .divisor          (divisor),
      .res_rdy          (res_rdy),
      .merchant         (merchant),
      .remainder        (remainder));

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

endmodule // test

Résultats de simulation

Comme le montre la figure, les deux données d'entrée produisent des résultats de division corrects après un délai égal au nombre de cycles de la largeur en bits du dividende. De plus, une sortie en pipeline sans délai supplémentaire est obtenue, ce qui répond à la conception.

Téléchargement du code source

Téléchargement