在FPGA设计中，主要由三个指标来定义设计的速度：吞吐量、延迟和时序。
本章将针对一下问题进行探讨：
1）高吞吐量结构——每秒可以处理的最大bit数。
2）低延迟结构——从输入到输出的最小延迟。
3）通过时序优化来降低关键路径延迟：

• 在组合逻辑间插入寄存器；
• 将串行处理并行化；
• 将多优先级处理扁平化；
• 流水线寄存器间组合逻辑平衡分配；
• 将关键路径操作转移至非关键路径。

1.1 高吞吐量

流水线设计的美妙之处在于，新的数据可以在前面的数据处理完成之前被处理。

关键词：展开迭代循环
代价：面积增加

软件代码：

 XPower = 1;
   for (i=0;i < 3; i++)
     XPower = X * XPower;

优化前的代码：

module power3(
     output [7:0] XPower,
     output       finished,
     input  [7:0] X,
     input        clk, start); // the duration of start is a single clock
     reg    [7:0] ncount;
     reg    [7:0] XPower;
     assign finished = (ncount == 0);
     always@(posedge clk)
       if(start) begin
         XPower <= X;
         ncount <= 2;
       end
       else if(!finished) begin
         ncount <= ncount - 1;
         XPower <= XPower * X;
       end
   endmodule

优化后的代码：

module power3(
     output reg [7:0] XPower,
     input            clk,
     input      [7:0] X
     );
     reg        [7:0] XPower1, XPower2;
     reg        [7:0] X1, X2;
     always @(posedge clk) begin
       // Pipeline stage 1
       X1      <= X;
       XPower1 <= X;
       // Pipeline stage 2
       X2      <= X1;
       XPower2 <= XPower1 * X1;
       // Pipeline stage 3
       XPower <= XPower2 * X2;
     end
endmodule

1.2 低延迟

以1.1节优化后的代码举例，去掉中间寄存器修改为组合逻辑，则运算可以在一个时钟内完成。
代价：组合逻辑增加了寄存器之间的延迟。

module power3(
     output [7:0] XPower,
     input  [7:0] X
     );
     reg    [7:0] XPower1, XPower2;
     reg    [7:0] X1, X2;
     assign XPower = XPower2 * X2;
     always @* begin 
        X1 =X; 
        XPower1 = X;
     end
     always @* begin
         X2      = X1;
         XPower2 = XPower1*X1;
     end
endmodule

1.3 时序

时序是指设计的时钟速度。 设计中任意两个顺序元件之间的最大延迟将决定最大时钟速度。

最大频率计算公式

1.3.1 添加中间层寄存器

添加寄存器层通过将关键路径分成两个延迟较小的路径来改进时序。
该技术应用于高度流水线设计，其中额外的时钟周期延迟不违反设计规范，并且整体功能不会受到进一步添加寄存器的影响。

优化前代码：

module fir(
     output [7:0] Y,
     input  [7:0] A, B, C, X,
     input        clk,
     input        validsample);
     reg    [7:0] X1, X2, Y;
     always @(posedge clk)
       if(validsample) begin
         X1 <= X;
         X2 <= X1;
         Y <= A* X+B* X1+C* X2;
     end
endmodule

优化后代码：

module fir(
     output [7:0] Y,
     input  [7:0] A, B, C, X,
     input        clk,
     input        validsample);
     reg    [7:0] X1, X2, Y;
     reg    [7:0] prod1, prod2, prod3;
     always @ (posedge clk) begin
       if(validsample) begin
         X1 <= X;
         X2 <= X1;
         prod1 <= A * X;
         prod2 <= B * X1;
         prod3 <= C * X2;
       end
       Y <= prod1 + prod2 + prod3;
     end
endmodule

1.3.2 并行结构

将一个逻辑函数分成多个可以并行计算的较小函数，可以将寄存器间路径延迟减少。
只要当前通过串行逻辑串计算的函数可以被分解并并行计算，就应该使用这种技术。例如前文提到的乘法元算，可以通过下式优化：

乘法并行分解

优化后代码：

module power3(
    output [7:0] XPower,
    input  [7:0] X,
    input        clk);
    reg    [7:0] XPower1;
    // partial product registers
    reg    [3:0] XPower2_ppAA, XPower2_ppAB, XPower2_ppBB;
    reg    [3:0] XPower3_ppAA, XPower3_ppAB, XPower3_ppBB;
    reg    [7:0] X1, X2;
    wire   [7:0] XPower2;
    // nibbles for partial products (A is MS nibble, B is LS nibble)
    wire   [3:0] XPower1_A = XPower1[7:4];
    wire   [3:0] XPower1_B = XPower1[3:0];
    wire   [3:0] X1_A      = X1[7:4];
    wire   [3:0] X1_B      = X1[3:0];
    wire   [3:0] XPower2_A = XPower2[7:4];
    wire   [3:0] XPower2_B = XPower2[3:0];
    wire   [3:0] X2_A      = X2[7:4];
    wire   [3:0] X2_B      = X2[3:0];
    // assemble partial products
    assign XPower2 = (XPower2_ppAA << 8)+(2*XPower2_ppAB << 4)+XPower2_ppBB;
    assign XPower= (XPower3_ppAA << 8)+(2*XPower3_ppAB << 4)+XPower3_ppBB;
    always @(posedge clk) begin
       // Pipeline stage 1
       X1           <= X;
       XPower1      <= X;
       // Pipeline stage 2
       X2           <= X1;
       // create partial products
       XPower2_ppAA <= XPower1_A * X1_A;
       XPower2_ppAB <= XPower1_A * X1_B;
       XPower2_ppBB <= XPower1_B * X1_B;
       // Pipeline stage 3
       // create partial products
       XPower3_ppAA <= XPower2_A * X2_A;
       XPower3_ppAB <= XPower2_A * X2_B;
       XPower3_ppBB <= XPower2_B * X2_B;
     end
endmodule

1.3.3 扁平逻辑结构

在含有多个优先级行为的设计中，综合工具通常没有那么聪明来优化时序，所以，需要我们自行扁平化处理（不影响功能的前提下）。
通过去除不需要的优先级编码，逻辑结构被扁平化，路径延迟被减少。

优化前代码：

module regwrite(
     output reg [3:0] rout,
     input            clk, in,
     input      [3:0] ctrl);
     always @(posedge clk)
       if(ctrl[0])      rout[0] <= in;
       else if(ctrl[1]) rout[1] <= in;
       else if(ctrl[2]) rout[2] <= in;
       else if(ctrl[3]) rout[3] <= in;
endmodule

优化后代码：

module regwrite(
     output reg [3:0] rout,
     input            clk, in,
     input      [3:0] ctrl);
     always @(posedge clk) begin
       if(ctrl[0]) rout[0] <= in;
       if(ctrl[1]) rout[1] <= in;
       if(ctrl[2]) rout[2] <= in;
       if(ctrl[3]) rout[3] <= in;
     end
endmodule

1.3.4 寄存器平衡

寄存器平衡通过将组合逻辑从关键路径移动到相邻路径来改进时序。
只要关键路径和相邻路径之间的逻辑高度不平衡，就应该使用这种技术。 由于时钟速度仅受最坏情况路径的限制，因此可能只需稍作改动即可成功重新平衡关键逻辑。

优化前代码：

module adder(
    output reg [7:0] Sum,
    input [7:0] rA, rB, rC,
    input clk);
    reg   [7:0] A, B, C;
always @(posedge clk) begin 
    rA <=A;
    rB <=B;
    rC <=C;
    Sum <=rA+rB+rC; 
end
endmodule

优化后代码：

module adder(
    output reg [7:0] Sum,
    input [7:0] A, B, C,
    input clk);
    reg [7:0] rABSum, rC;
    always @(posedge clk) begin
       rABSum <= A + B;
       rC     <= C;
       Sum    <= rABSum + rC;
    end
endmodule

1.3.5 路径重组

当多条路径与关键路径组合时，应使用此技术，对组合路径进行重新排序，以便可以将关键路径移动到更靠近目标寄存器的位置。

优化前代码：

module randomlogic(
    output reg [7:0] Out,
    input [7:0] A, B, C,
    input clk,
    input Cond1, Cond2);
    always @(posedge clk)
        if(Cond1)
            Out <= A;
        else if(Cond2 && (C < 8))
            Out <= B;
        else
            Out <= C;
endmodule

优化后代码：

module randomlogic(
    output reg [7:0] Out,
    input [7:0] A,B,C,
    input clk,
    input Cond1,Cond2);
    wire CindB = (Cond2 & !Cond1);
    always @(posedge clk)
       if(CondB && (C < 8))
           Out <= B;
       else if(Cond1)
           Out <= A; 
       else
           Out <= C;
endmodule