FPGA时序优化的几种方法

tyui001

衡量FPGA设计的两个重要指标是吞吐率和延迟

吞吐率：指系统每一个时钟周期内能够处理的数据数量，为了获得更高的吞吐率就需要减少组合逻辑延迟，在组合逻辑中间插入寄存器，也就是流水线设计

延迟：指数据从输入系统到输出系统总共需要的时间，为了获得更短的延迟，可以减少组合逻辑延迟，或者删减路径上的寄存器，第二种方法显然不利于系统获得更好的性能

时序优化的几种方法
这里说的优化是让FPGA设计获得更高的工作频率，也就是通常说的性能和吞吐率

1.插入寄存器（pipeline）
举例说明，如果下面一个FIR滤波器的设计没能满足时序要求

1. module fir(
   
2.     output [7:0] Y,
   
3.     input  [7:0] A,B,C,X,
   
4.     input        clk,
   
5.     input        validsample);
   
6.     always @(posedge clk)
   
7.         if(validsample) begin
   
8.             X1<=X;
   
9.             X2<=X1;
   
10.             Y<=A*X+B*X1+C*X2;
    
11.         end
    
12. endmodule
    

复制代码

从代码可以看出，X2这条路径过长，是整个设计的Critical Path,如果采用流水线设计可以用寄存器暂存自已在执行Y的运算，改进如下：

1. module fir(
   
2.     output   [7:0] Y,
   
3.     input    [7:0] A,B,C,X,
   
4.     input            clk,
   
5.     input            validsample);
   
6.     reg       [7:0] X1,X2,Y;
   
7.     reg       [7:0] prod1,prod2,prod3;
   
8.     always @(posedge clk) begin
   
9.         if(validsample) begin
   
10.             X1<=X;
    
11.             X2<=X1;
    
12.             prod1<=A*X;
    
13.             prod2<=B*X1;
    
14.             prod3<=C*X2;
    
15.         end
    
16.         Y<=prod1+prod2+prod3;
    
17.     end
    
18. endmodule

复制代码

2.并行化设计
并行化设计的思想是将一个逻辑函数分解为几个小一些的逻辑函数并行计算，从而减少关键路径上的延迟
例如计算两个8bits数的乘法，将8bits数分为两个4bits数，则乘法运算可以被分解为下面几个部分：
X∗X={A,B}∗{A,B}={(A∗A),(2∗A∗B),(B∗B)};X∗X={A,B}∗{A,B}={(A∗A),(2∗A∗B),(B∗B)};
通过这种方法可以将设计简化为一系列4bits乘法器的实现

1. module power3(
   
2.     output  [7:0] XPower,
   
3.     input   [7:0] X,
   
4.     input         clk);
   
5.     reg     [7:0] XPower1;
   
6.     //部分结果寄存器
   
7.     reg     [3:0] XPower2_ppAA,XPower2_ppAB,XPower2_ppBB;
   
8.     reg     [3:0] XPower3_ppAA,XPower3_ppAB,XPower3_ppBB;
   
9.     reg     [7:0] X1,X2;
   
10.     wire    [7:0] XPower2;
    
11. 
    
12.     wire    [3:0] XPower1_A = XPower1[7:4];
    
13.     wire    [3:0] XPower1_B = XPower1[3:0];
    
14.     wire    [3:0] X1_A      = X1[7:4];
    
15.     wire    [3:0] X1_B      = X1[3:0];
    
16.     wire    [3:0] XPower2_A = XPower2[7:4];
    
17.     wire    [3:0] XPower2_B = XPower2[3:0];
    
18.     wire    [3:0] X2_A      = X2[7:4];
    
19.     wire    [3:0] X2_B      = X2[3:0];
    
20. 
    
21.     assign XPower2 = (XPower2_ppAA << 8) + (2*XPower2_ppBB << 4) + XPower2_ppBB;
    
22.     assign XPower  = (XPower3_ppAA << 8) + (2*XPower3_ppBB << 4) + XPower3_ppBB;
    
23.     always @(posedge clk) begin
    
24.        //第一级流水线
    
25.        X1 <=X;
    
26.        XPower1 <= X;
    
27.        //第二级流水线
    
28.        X2 <= X1;
    
29.        XPower2_ppAA <= XPower1_A * X1_A;
    
30.        XPower2_ppAB <= XPower1_A * X1_B;
    
31.        XPower2_ppBB <= XPower1_B * X1_B;
    
32.        //第三级流水线
    
33.        XPower3_ppAA <= XPower2_A * X2_A;
    
34.        XPower3_ppAB <= XPower2_A * X2_B;
    
35.        XPower3_ppBB <= XPower2_B * X2_B；
    
36.        end
    
37. endmodule

复制代码

3.逻辑展平
通过优化掉设计中的优先级译码电路，逻辑结构被展平，路径延迟得以缩短，优先级译码电路常出现在IF/ELSE结构语句中出现

1. module regwrite(
   
2.     output reg [3:0] rout,
   
3.     input            clk,in,
   
4.     input      [3:0] ctrl);
   
5.     always @(posedge clk)
   
6.         if(ctrl[0])      rout[0] <= in;
   
7.         else if(ctrl[1]) rout[1] <= in;
   
8.         else if(ctrl[2]) rout[2] <= in;
   
9.         else if(ctrl[3]) rout[3] <= in;
   
10. endmodule

复制代码

上面代码综合后就会产生优先级译码器，通过各项平级的if语句或者case语句可以避免这样的优先级译码设计

1. //改进后
   
2. module regwrite(
   
3.     output reg [3:0] rout,
   
4.     input            clk,in,
   
5.     input      [3:0] ctrl);
   
6.     always @(posedge clk) begin
   
7.         if(ctrl[0]) rout[0] <= in;
   
8.         if(ctrl[1]) rout[1] <= in;
   
9.         if(ctrl[2]) rout[2] <= in;
   
10.         if(ctrl[3]) rout[3] <= in;
    
11.     end
    
12. endmodule

复制代码

4.均衡设计
均衡设计的思想是把 Critical Path 上的组合逻辑拿出一部分放在 short path 上进行，从而缩短 Critical Path 的延迟
下面举例一个8位加法器

1. module adder(
   
2.     output reg [7:0] Sum,
   
3.     input      [7:0] A,B,C,
   
4.     input            clk);
   
5.     reg        [7:0] rA,rB,rC;
   
6.     always @(posedge clk) begin
   
7.         rA <= A;
   
8.         rB <= B;
   
9.         rC <= C;
   
10.         Sum <= rA+rB+rC;
    
11.     end
    
12. endmodule

复制代码

可以看到，在寄存器rA，rB，rC之前的路径上没有组合逻辑，所以可以考虑把一部分计算拿到寄存器之前

1. //改进后
   
2. module adder(
   
3.     output reg [7:0] Sum,
   
4.     input      [7:0] A,B,C,
   
5.     input            clk);
   
6.     reg        [7:0] rABSum,rC;
   
7.     always @(posedge clk) begin
   
8.         rABSum <= A + B;
   
9.         rC     <= C
   
10.         Sum    <= rABSum + rC;
    
11.     end
    
12. endmodule

复制代码

5.优化路径
最后一种方法也是我认为最难的，通过优化数据流的路径来缩短 Critical Path ，提升系统性能。重新布局和 Critical Path 在一起的路径，从而 Critical Path上的逻辑门可以更靠近目标寄存器。举一个栗子：

1. module randomlogic(
   
2.     output reg [7:0] Out,
   
3.     input      [7:0] A,B,C,
   
4.     input            clk,
   
5.     input            Cond1,Cond2);
   
6.     always @(posedge clk)
   
7.         if(Cond1)
   
8.             Out <= A;
   
9.         else if(Cond2&&(C<8))
   
10.             Out <= B;
    
11.         else
    
12.             Out <= C;
    
13. endmodule

复制代码

可以看到C作为B的输出条件的路径最长，经过了一个比较器和两个逻辑门，是整个设计的 Critical Path ,可以做后续优化

1. //改进后
   
2. module randomlogic(
   
3.     output reg [7:0] Out,
   
4.     input      [7:0] A,B,C,
   
5.     input            clk,
   
6.     input            Cond1,Cond2);
   
7.     wire CondB = (Cond2 &!Cond1);
   
8.     always @(posedge clk)
   
9.         if(CondB&& (C<8))
   
10.             Out <= b;
    
11.         else if(Cond1)
    
12.             Out <= A;
    
13.         else
    
14.             Out <= C;
    
15. endmodule

复制代码

原文：https://blog.csdn.net/u012156319/article/details/78357875

morenbuou

学习一下，很好的。

Plunify

有没有试过调节参数？

feixiang20

学习一下