Fréquence du multiplicateur

Question

J'ai conçu un multiplicateur 16 * 16. (fonctionnant à la fréquence de 1550 MHz) J'utilise alors le même multiplicateur pour effectuer trois multiplications en série en mettant des registres en entrée qui servent à modifier les opérandes d'entrée. Le résultat des multiplications est stocké dans les registres. Lorsque trois multiplications sont effectuées en série, la fréquence se réduit à 500 MHz. Je veux éviter la diminution de la fréquence et vouloir la faire fonctionner à la fréquence du multiplicateur unique. Comme le multiplicateur unique nécessite certains cycles d'horloge pour terminer l'opération, nous attendons donc quelques cycles d'horloge avant de multiplier les nouveaux opérandes. Un compteur est utilisé à cette fin. Le compteur compte les cycles d'horloge et fournit le délai nécessaire pour terminer la multiplication. Le processus est complété comme suit: La première multiplication est démarrée, puis nous attendons quelques cycles d'horloge pour calculer le résultat, le résultat est ensuite stocké dans le registre et le multiplicateur est fourni avec de nouveaux opérandes, encore une fois le multiplicateur a besoin de cycles d'horloge, ce processus se poursuit trois fois. Je veux juste que tout ce code fonctionne à la fréquence du multiplicateur unique qui est presque 1500 MHz.

Le code est donné ci-dessous

////3 multiplications are carried out in this module 

`define m 11 
`define mbar 245 
module test_mul(a,b,clk,reg2,reset); 
input [15:0] a,b; 
input clk,reset; 
output reg [31:0] reg2; 

reg [15:0] x,y; 
reg [31:0] reg0,reg1; 
reg [5:0] count; 

wire [31:0]p; 

    test_mul16 a1 (x,y,clk, p); 

always @ (posedge clk) 
begin 
if (reset) 
begin x <= a; y <= b; count= 6'd0; end  // first operands given 
else begin         // and counter started 

if (count == 11)      // first multiplication completed 
reg2 <= p;        // result moved to register 
if (count == 12) 
begin x <= reg0[15:0]; y <=`mbar; end // new operands 
if (count == 27)      // second multiplication completed 
reg1 <= p;       // second result to register 
else if (count == 28) 
begin        // new operands for 3rd multiplication 
x <= reg1[15:0]; 
y <= `m; 
end 
else if (count == 39)   // multiplication completed 
begin 
reg2 <= p;      // result moved to register 
end 
count = count+1;     // counter incremented 
end 
end 
endmodule 


//// this multiplier operates at a frequency of 1550 MHz 
//// This is then called in the upper module 

module test_mul16(a,b,clk,reg2); 
input [15:0] a,b; 
input clk; 
output reg [31:0] reg2; 
reg [31:0] reg0, reg1; 
always @ (posedge clk) 
begin 
reg0<= a*b; 
reg1<=reg0; 
reg2<=reg1;   // just to increase some clock cycles- nothing else 
end 
endmodule 

Answer 1

Il y a quelques inconnues dans votre question, j'ai donc fait quelques hypothèses pour combler les lacunes. N'hésitez pas à corriger les hypothèses incorrectes que j'ai faites.

Dans la première partie de la question, vous dites:

Lorsque trois multiplications sont réalisées en série ...

Je pensais que vous étiez d'abord essayé d'effectuer trois multiplications, de manière séquentielle, d'une manière d'alimentation (c'est-à-dire d'alimenter la sortie d'un multiplicateur dans l'entrée de la suivante, d'une certaine manière, en gardant à l'esprit que la taille du résultat est plus grande que les opérandes d'entrée). Puisque le multiplicateur simple nécessite certains cycles d'horloge pour terminer l'opération, nous attendons donc quelques cycles d'horloge avant de donner le multiplicateur des nouveaux opérandes. Il semble que vous vouliez juste donner plusieurs valeurs (dans ce cas, trois) dans un multiplicateur et obtenir les résultats. Si c'est le cas, vous pouvez simplement les introduire dans le module test_mul16, à chaque cycle d'horloge. Si le module de niveau inférieur est déduit comme un DSP (hypothèse, même si ce n'est pas le suivant qui sera vrai s'il est conçu correctement), il sera capable de prendre un nouvel ensemble d'opérandes chaque cycle d'horloge. Le nombre de cycles requis pour générer le résultat initial dépendra du nombre de registres que vous indiquez autour du bloc DSP, ainsi que du nombre d'étapes dans le bloc lui-même (cela peut varier selon le fournisseur et la manière dont il est configuré). Une fois que vous obtenez ce résultat initial, vous pouvez commencer à faire des choses avec lui, ainsi que les valeurs suivantes (qui seront produites chaque cycle d'horloge par la suite, en supposant que vous chargez un nouvel ensemble dans chaque cycle). Ce que vous faites exactement, est inconnu (bien que, je suppose qu'il est lié à la multiplication de Montgomery). Ce concept est connu sous le nom de pipelining, et c'est ce qui rend les FPGA extrêmement efficaces dans certaines tâches de traitement.

Si les résultats suivants sont liés d'une manière ou d'une autre, vous pouvez démarrer en les combinant d'une manière ou d'une autre. Inversement, si vous devez gérer séparément les valeurs de sortie, vous pouvez regrouper les sorties (éventuellement en utilisant un compteur) dans des registres individuels pour effectuer d'autres opérations selon les besoins.

Une dernière note qui mérite d'être mentionnée. En supposant que vous utilisez un bloc DSP sous-jacent, en fonction de la "logique additionnelle" que vous devez implémenter, il est possible d'en implémenter une partie dans le bloc DSP lui-même (par exemple mult, accumuler, arrondir, saturer etc. caractéristiques diffèrent entre les fournisseurs).