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
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
//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
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
