1. 从零开始:理解FPGA乘法器的硬件本质
很多刚开始接触FPGA的朋友,一看到乘法运算,第一反应可能就是直接用Verilog里的 * 号。这当然没错,综合工具会帮你搞定一切。但如果你想知道这背后到底发生了什么,或者你的项目对资源消耗、时序性能有极致要求,那么亲手搭建一个乘法器,并理解它的每一块“砖瓦”,就变得至关重要了。这就像学开车,自动挡当然方便,但学会手动挡,你才能真正理解发动机和变速箱是如何协同工作的,在特殊路况下你才能有更多的控制权。
那么,FPGA里的乘法器到底是什么?简单来说,它就是一套用最基本的逻辑门(与门、或门、异或门等)搭建起来的电路,专门用来完成两个二进制数的乘法运算。FPGA内部并没有一个现成的、像CPU里那样的“乘法器硬核”等着你用(除非芯片里专门集成了DSP块,那是另一回事)。我们写的 assign Z = X * Y;,对于综合工具而言,就是一个“设计需求”,工具会调用它库里的各种基本单元(主要是查找表LUT和进位链Carry Chain)来拼凑出能满足这个功能的电路网表。这个自动拼接的过程,就像给你一堆乐高积木,让机器自动拼出一辆汽车,它可能能用,但未必是最省积木、跑得最快的拼法。
我们自己设计乘法器,目的就是把这辆“乐高汽车”的拼装图纸画出来,精确到每一块积木放在哪里。这样做的好处是显而易见的:第一,你完全掌控了电路结构,可以针对面积(资源)或速度(时序)进行深度优化;第二,你能更深刻地理解数据在硬件中流动的每一个节拍,这对调试复杂逻辑和进行时序分析有巨大帮助;第三,在一些对功耗极其敏感的场合,精简的、定制的结构往往比工具综合的通用结构更高效。我刚开始做图像处理项目时,一个流水线里用了很多乘法,直接用的 * 运算符,结果布局布线后时序怎么都过不了,资源也用得七七八八。后来不得不回头,从最基础的乘法单元开始重构,才把问题解决。这个“踩坑”的经历让我明白,知其然更要知其所以然,在FPGA设计里绝不是一句空话。
2. 庖丁解牛:构建你自己的乘法单元(MU)
要搭建一个乘法器,我们得先从最小的“细胞”开始,这个细胞我习惯称之为乘法单元(Multiplication Unit, MU)。它的功能非常纯粹:计算两个1比特二进制数的乘积,并处理来自低位的进位(Carry-in)和部分和(Sum-in),然后产生本位的和(Sum-out)以及向高位的进位(Carry-out)。
你可以把它想象成一个微型的全加器,但多了一个“乘”的动作。具体来说,一个MU的输入输出接口是这样的:
- 输入:乘数位
X(1比特),被乘数位Y(1比特),来自低位的部分和输入Sin(1比特),来自低位的进位输入Cin(1比特)。 - 输出:本位和输出
Sout(1比特),向高位的进位输出Cout(1比特)。
它的内部操作分两步走,非常清晰:
- 位乘:
Pij = X & Y。这就是一个简单的与门,如果X和Y都是1,那么Pij就是1,否则为0。这对应着乘法竖式中,交叉相乘的那一步。 - 累加:将
Pij、Sin和Cin这三个1比特数相加。这不就是一个标准的全加器(Full Adder)的功能吗?没错!所以一个MU的核心,就是一个与门加上一个全加器。
下面我们用Verilog来实现它。首先,我们需要一个全加器模块:
module full_adder(
input A,
input B,
input Cin,
output S,
output Cout
);
// 和 = A 异或 B 再异或 Cin
assign S = A ^ B ^ Cin;
// 进位 = (A&B) | (B&Cin) | (A&Cin)
assign Cout = (A & B) | (B & Cin) | (A & Cin);
endmodule
有了全加器,乘法单元 mu 的实现就水到渠成了:
module mu(
input Y,
input X,
input Sin,
input Cin,
output Cout,
output Sout
);
wire Pij; // 位乘结果
assign Pij = X & Y; // 与门实现位乘
// 调用全加器,将 Pij, Sin, Cin 相加
full_adder u_adder(
.A(Pij),
.B(Sin),
.Cin(Cin),
.S(Sout),
.Cout(Cout)
);
endmodule
看,就是这么简单!这个小小的 mu 模块,就是我们构建整个乘法器大厦的基石。你可以把它理解为一个“三输入加法器”,其中有一个输入被预先做了“屏蔽”处理(与门)。在实际的电路布局中,一个MU通常会被映射到FPGA的几个查找表(LUT)上,因为一个LUT可以实现少量输入的任意组合逻辑。理解这个映射关系,是后续进行资源优化的基础。
3. 积木成塔:搭建4x4位阵列乘法器
有了MU这块“砖”,我们现在可以盖房子了。最直观的乘法器结构就是“阵列乘法器”,它直接模拟我们手算乘法的竖式过程,结构规整,非常容易理解。我们以两个4位无符号数相乘,得到一个8位结果为例。
想象一下手算 13 (1101) × 11 (1011):
1 1 0 1 (X)
× 1 0 1 1 (Y)
-------------
1 1 0 1 (Y[0]*X)
1 1 0 1 (Y[1]*X,左移一位)
0 0 0 0 (Y[2]*X,左移两位)
+ 1 1 0 1 (Y[3]*X,左移三位)
-----------------
1 0 0 0 1 1 1 1
硬件实现时,我们不会真的去“移位”,而是通过MU的互联,将每个位乘结果 Pij(即 X[i] & Y[j])放到正确的位置上进行累加。整个结构就像一个斜着的金字塔,或者说一个网格阵列,每一个网格点都是一个MU。
下面是我用Verilog实现的4x4阵列乘法器 array_multiplier。代码看起来有点长,但结构是对称且规律的,我加了详细的注释帮你理清每个MU的连接关系:
module array_multiplier (
input [3:0] X,
input [3:0] Y,
output [7:0] Z
);
// 声明内部连线:进位C和部分和S
// 命名规则:C_行_列, S_行_列。例如C_1_2表示第1行第2列MU产生的进位。
wire C_0_1, C_0_2, C_0_3;
wire C_1_0, C_1_1, C_1_2, C_1_3;
wire C_2_0, C_2_1, C_2_2, C_2_3;
wire C_3_0, C_3_1, C_3_2;
wire S_1_1, S_1_2, S_1_3;
wire S_2_0, S_2_1, S_2_2, S_2_3;
wire S_3_0, S_3_1, S_3_2;
// --- 第0行 (对应Y[0]) ---
// 这一行每个MU的Sin输入都是0,因为是最低位,没有来自下方的部分和。
mu mu_00 (.Y(Y[0]), .X(X[0]), .Sin(1'b0), .Cin(1'b0), .Cout(C_0_1), .Sout(Z[0]));
mu mu_01 (.Y(Y[0]), .X(X[1]), .Sin(1'b0), .Cin(C_0_1), .Cout(C_0_2), .Sout(S_1_1));
mu mu_02 (.Y(Y[0]), .X(X[2]), .Sin(1'b0), .Cin(C_0_2), .Cout(C_0_3), .Sout(S_1_2));
mu mu_03 (.Y(Y[0]), .X(X[3]), .Sin(1'b0), .Cin(C_0_3), .Cout(/* 输出到S_2_0 */), .Sout(S_1_3));
// --- 第1行 (对应Y[1]) ---
// Sin来自上一行同列的Sout,Cin来自左侧MU的Cout或上一行的进位。
mu mu_10 (.Y(Y[1]), .X(X[0]), .Sin(S_1_1), .Cin(1'b0), .Cout(C_1_0), .Sout(Z[1]));
mu mu_11 (.Y(Y[1]), .X(X[1]), .Sin(S_1_2), .Cin(C_1_0), .Cout(C_1_1), .Sout(S_2_1));
mu mu_12 (.Y(Y[1]), .X(X[2]), .Sin(S_1_3), .Cin(C_1_1), .Cout(C_1_2), .Sout(S_2_2));
mu mu_13 (.Y(Y[1]), .X(X[3]), .Sin(/* 来自mu_03的Cout */), .Cin(C_1_2), .Cout(C_1_3), .Sout(S_2_3));
// --- 第2行 (对应Y[2]) ---
mu mu_20 (.Y(Y[2]), .X(X[0]), .Sin(S_2_1), .Cin(1'b0), .Cout(C_2_0), .Sout(Z[2]));
mu mu_21 (.Y(Y[2]), .X(X[1]), .Sin(S_2_2), .Cin(C_2_0), .Cout(C_2_1), .Sout(S_3_1));
mu mu_22 (.Y(Y[2]), .X(X[2]), .Sin(S_2_3), .Cin(C_2_1), .Cout(C_2_2), .Sout(S_3_2));
mu mu_23 (.Y(Y[2]), .X(X[3]), .Sin(C_1_3), .Cin(C_2_2), .Cout(C_2_3), .Sout(/* 输出到最终结果高位 */));
// --- 第3行 (对应Y[3]) ---
mu mu_30 (.Y(Y[3]), .X(X[0]), .Sin(S_3_1), .Cin(1'b0), .Cout(C_3_0), .Sout(Z[3]));
mu mu_31 (.Y(Y[3]), .X(X[1]), .Sin(S_3_2), .Cin(C_3_0), .Cout(C_3_1), .Sout(Z[4]));
mu mu_32 (.Y(Y[3]), .X(X[2]), .Sin(/* 来自mu_23的Sout */), .Cin(C_3_1), .Cout(C_3_2), .Sout(Z[5]));
mu mu_33 (.Y(Y[3]), .X(X[3]), .Sin(C_2_3), .Cin(C_3_2), .Cout(Z[7]), .Sout(Z[6]));
endmodule
写一个简单的测试平台验证一下功能:
module tb_array_multiplier;
reg [3:0] X, Y;
wire [7:0] Z;
array_multiplier uut (.X(X), .Y(Y), .Z(Z));
initial begin
// 测试几组数据
X = 4'd5; Y = 4'd3; #10; // 5*3=15
$display("X=%d, Y=%d, Z=%d", X, Y, Z);
X = 4'd10; Y = 4'd10; #10; // 10*10=100
$display("X=%d, Y=%d, Z=%d", X, Y, Z);
X = 4'd15; Y = 4'd15; #10; // 15*15=225
$display("X=%d, Y=%d, Z=%d", X, Y, Z);
$finish;
end
endmodule
如果仿真结果正确,恭喜你!你已经亲手用最基础的逻辑门,构建了一个完整的数字电路功能单元。这种成就感,是直接使用 * 运算符无法比拟的。更重要的是,这个结构是完全透明的,你可以清晰地看到每一位数据是如何产生、如何流动、如何相加最终形成结果的。接下来,我们就可以打开综合工具,看看我们搭的这座“积木城堡”到底占用了多少FPGA资源。
4. 资源洞察:综合工具下的硬件真相
设计写完了,功能也对,是时候把它放到真实的FPGA环境中看看“成色”了。这里我以Xilinx的Vivado工具为例(其他如Intel Quartus流程类似)。综合(Synthesis)这一步,会把我们的Verilog代码翻译成FPGA底层可用的基本元件,主要是查找表(LUT)、触发器(FF)和进位链(Carry Chain)。
我们把上面写的 array_multiplier 模块进行综合。综合报告里,我们最需要关注的就是 LUT 的用量。为什么是LUT?因为在我们这个纯组合逻辑的乘法器里,绝大部分功能都是由LUT实现的。一个MU(一个与门+一个全加器)通常需要多个LUT来实现其逻辑功能。
综合完成后,你可能会看到类似这样的资源报告:
Utilization:
LUT as Logic: 17
这意味着我们的4x4阵列乘法器使用了17个查找表。这个数字是怎么来的?我们可以粗略估算一下:一个全加器需要2个LUT(一种常见实现方式),一个与门可以合并到LUT里。我们一共有16个MU,但工具会进行优化,可能将一些相邻的逻辑合并到同一个LUT中,所以最终不是简单的16*2=32个,而是优化后的17个。这体现了综合工具逻辑优化(Logic Optimization)的能力。
注意:不同的综合工具、不同的优化策略(面积优先还是速度优先)、甚至不同系列的FPGA芯片,这个数字都可能会有差异。所以17只是一个参考值,关键是理解趋势。
作为对比,我们直接使用行为级描述 assign Z = X * Y; 写一个乘法器:
module behavioral_multiplier (
input [3:0] X,
input [3:0] Y,
output [7:0] Z
);
assign Z = X * Y;
endmodule
综合这个模块,你可能会发现它用了 19个LUT 和 2个CARRY4(这是Xilinx FPGA中的专用进位链资源)。为什么比我们手动的17个还多?这是因为综合工具在将乘法运算符翻译成电路时,可能采用了一种不同的、更通用的结构,或者为了追求更好的时序性能而牺牲了一些面积。专用进位链的引入则是因为工具识别出了快速的进位逻辑,使用CARRY4这种硬核资源比用LUT搭建进位链速度更快、更省资源。
到了实现(Implementation)阶段的布局布线后,资源报告可能显示最终只用了 16个LUT。这是因为布局布线器(Placer & Router)会进行更底层的优化,比如将两个逻辑功能非常接近的LUT“打包”(Pack)到同一个物理LUT中(一个LUT6通常可以实现两个有共同输入的5输入逻辑函数)。这告诉我们,看资源消耗不能只看综合报告,最终的实现报告更准确。
| 实现方式 | 预估LUT用量 | 关键特点 |
|---|---|---|
| 手动阵列乘法器 | ~17 | 结构清晰,完全可控,易于流水线切割。资源消耗相对固定。 |
行为级描述 (*) | ~19 (含专用进位链) | 代码简洁,依赖工具优化。工具可能根据时序约束选择不同架构,结果不可预测。 |
这个对比实验给了我们一个核心启示:对于简单的、固定位宽的乘法,手动设计在资源优化上可能更有优势,尤其是当你对电路结构有深刻理解并能针对性优化时。而对于快速原型开发或位宽较大、结构复杂的情况,使用运算符依赖工具优化则是更高效的选择。 工具不是万能的,但它能处理我们手动难以完成的复杂优化。我们的价值在于,知道在什么时候该信任工具,什么时候该自己动手。
5. 进阶优化:让乘法器更快更省
知道了基本结构的资源消耗,我们就可以玩点“花活”了,目标就是:要么让乘法器跑得更快(优化时序),要么让它面积更小(节省资源)。这两者往往是矛盾的,需要根据项目需求权衡。
5.1 速度优先:流水线化你的乘法器
阵列乘法器是一个很深的组合逻辑链,从输入到输出,信号需要经过很多级MU。对于4位乘法还好,如果是16位、32位乘法,关键路径会非常长,成为系统时钟频率的瓶颈。这时候,流水线(Pipeline) 就是你的救星。
流水线的思想很简单:把长长的组合逻辑链切成几段,在段与段之间插入寄存器(触发器)。这样,虽然单个数据从进到出的总时间(延迟)变长了(因为多了寄存器建立时间),但系统可以同时处理多个处于不同阶段的数据,吞吐率(单位时间完成的计算量)大大提升。
给我们的4x4阵列乘法器插入一级流水线,可以在中间某一行(比如第1行和第2行之间)插入寄存器,锁存中间的部分和与进位结果。这样,一个时钟周期内,电路只需要计算一部分MU,时钟频率就可以提得很高。修改后的代码需要增加时钟和复位信号,并将内部部分连线改为寄存器输出。这里给出一个概念性的代码结构:
module pipelined_array_multiplier (
input clk,
input rst_n,
input [3:0] X,
input [3:0] Y,
output reg [7:0] Z
);
// 第一级流水线寄存器(存储第0、1行的中间结果)
reg [/* 宽度 */] stage1_reg;
// 第二级组合逻辑(计算第2、3行)和输出寄存器
// ... 具体连接需要仔细设计
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
stage1_reg <= 0;
Z <= 0;
end else begin
// 第一级逻辑计算,结果存入stage1_reg
// 第二级逻辑计算stage1_reg和剩余输入,结果存入Z
end
end
endmodule
流水线设计是高性能数字系统的基石,在图像处理、信号处理等需要大量连续乘加运算的领域应用极广。实测下来,对于一个32位乘法器,三级流水线通常能将最高工作频率提升2-3倍以上。
5.2 面积优先:探索更紧凑的结构
如果你的设计对资源极其敏感,比如用在低功耗、小规模的FPGA上,那么可以尝试更节省面积的乘法器结构。阵列乘法器虽然规整,但并不是最省面积的。
一种经典的优化方法是 华莱士树(Wallace Tree)。它不再规整地排列加法器,而是用一种树形结构,大量使用压缩器(如3:2压缩器,即全加器)来快速将多个部分积减少到两个,最后用一个快速加法器(如超前进位加法器)完成相加。华莱士树通过减少加法器的级数来优化速度,同时由于其不规则结构,在面积上有时也能得到优化(但布线可能更复杂)。
另一种思路是 Booth编码。它通过编码乘数,将连续的1转换为加减操作,从而减少部分积的数量。部分积少了,后面需要的加法器也就少了,自然就节省了面积。Booth算法在处理器ALU和高性能乘法器中非常常见。
对于FPGA而言,还需要考虑其独特的硬件结构。例如,Xilinx FPGA中的 DSP48 Slice 是专为乘加运算设计的硬核,它内部集成了乘法器、加法器和累加器。如果设计中用到很多乘法,直接例化DSP48比用LUT搭建要高效得多——速度极快,且不消耗宝贵的LUT资源。使用DSP48通常通过调用IP核或者直接使用 (* use_dsp48 = "yes" *) 这样的综合属性来引导工具实现。
5.3 位宽与精度:动态调整的艺术
很多时候,我们并不需要全精度的乘法。比如两个8位数相乘,理论上结果是16位,但后续处理可能只取高8位或中间某些位。这时,我们可以设计 截断乘法器,省去计算低位部分的逻辑,从而节省面积和功耗。
另一种情况是处理有符号数。对于有符号乘法(补码乘法),可以直接使用支持有符号数的运算符 $signed(X) * $signed(Y),也可以手动实现Booth算法。需要注意的是,直接使用行为级描述时,要确保变量声明为 signed 类型,或者进行正确的符号位扩展。
资源优化是一个永无止境的探索过程。我个人的经验是,在项目初期,先用行为级描述快速验证功能。在性能瓶颈出现时,再针对关键路径模块(如高频时钟域下的乘法器)进行手动优化或流水线设计。同时,一定要善用芯片提供的专用资源(如DSP、Block RAM),它们往往是性能和效率的最佳平衡点。记住,没有最好的结构,只有最适合你当前项目约束的结构。多尝试几种方案,对比综合实现报告,你会有更直观的体会。
299



被折叠的 条评论
为什么被折叠?



