FPGA矩阵乘法器设计：从Verilog实现到架构优化

1. 项目概述：为什么要在FPGA上实现矩阵乘法？

如果你接触过数字信号处理、图像处理或者机器学习加速，那“矩阵乘法”这个词对你来说肯定不陌生。它是这些领域的核心运算，计算量巨大。在通用处理器（CPU）上跑大规模的矩阵乘法，效率瓶颈非常明显，尤其是当数据吞吐成为关键时。这时候，FPGA（现场可编程门阵列）的优势就凸显出来了。它不像CPU那样一条指令一条指令地执行，而是可以通过硬件描述语言（比如Verilog）把计算任务“烧”成硬件电路，实现真正的并行计算。今天要聊的，就是怎么用Verilog在FPGA里搭一个矩阵乘法器，并且我会把核心源码和设计思路掰开揉碎了讲清楚。

这个项目适合谁呢？首先是FPGA的初学者，想通过一个具体的、有实际意义的项目来巩固Verilog语法和数字电路设计思想。其次是做算法加速的工程师，你可能正在评估FPGA作为协处理器的潜力，一个高效的矩阵乘法单元是很多复杂加速器的基石。哪怕你只是对硬件加速感兴趣，想看看软件里的for循环是怎么变成硬件里的数据流和状态机的，这篇文章也能给你一个清晰的图景。简单说，这不是一个玩具Demo，而是一个可以从理论走到仿真，再走到板级验证的完整设计。

2. 核心架构设计与思路拆解

2.1 并行度与资源消耗的权衡

设计一个矩阵乘法器，第一个要决定的就是并行策略。最直观的想法是“全并行”：一次性把两个矩阵的所有元素读进来，用组合逻辑在一个时钟周期内算出所有结果。比如计算一个4x4的矩阵乘，这需要16个乘法器和大量的加法树。对于小矩阵（比如2x2, 3x3），这在FPGA上完全可行，资源消耗可以接受。但一旦矩阵维度变大，比如16x16，全并行就需要256个乘法器，加上中间累加的逻辑，会瞬间吃光FPGA的DSP Slice和逻辑资源，这显然不现实。

因此，对于稍大些的矩阵，我们必须采用“分时复用”的策略。最常见的是“乘累加（MAC）”单元阵列。假设我们设计一个拥有P个并行MAC单元的引擎。计算一个MxN的矩阵A和NxK的矩阵B的乘法时，我们可以一次计算输出矩阵C的P个元素（或部分和）。这就在计算速度（并行度P）和硬件资源消耗之间取得了平衡。P越大，算得越快，但占用的DSP和逻辑资源也越多。在实际项目中，我们需要根据目标FPGA芯片的资源（特别是DSP48E1/E2的数量）和性能要求来确定这个P值。

2.2 数据流与存储层次设计

确定了计算核心，下一个关键问题是数据怎么喂给它。矩阵数据量通常远超FPGA片上Block RAM的容量，所以必须考虑数据复用和流水线。经典的优化思路来自计算机体系结构里的“局部性原理”。

我们可以把大矩阵分块（Tiling）。假设片上BRAM能容纳一个BLOCK_SIZE x BLOCK_SIZE的子矩阵，那么计算大矩阵乘法时，我们就一次加载两个块（A的一个块和B的一个块）到片上，用我们的MAC阵列计算这两个块相乘对最终结果块的贡献，然后累加到结果块中。处理完当前块对后，再加载下一个块。这个过程极大地减少了片外存储器（如DDR）的访问次数，因为每个数据块被加载后，会被重复使用多次。

在数据流设计上，通常采用“脉动阵列（Systolic Array）”或“滑动窗口（Sliding Window）”的结构，让数据在计算单元间有节奏地流动，确保每个时钟周期乘法器都不空闲，达到最高的计算效率。对于入门设计，我们可以先从简单的“行固定，列流动”或“双缓冲（Double Buffer）”开始，理解数据调度的重要性。

2.3 控制逻辑：状态机与计数器

一个高效的矩阵乘法器离不开清晰的控制逻辑。它需要精确地控制：何时从外部读取数据、数据加载到哪个缓冲区、何时启动计算单元、计算进行到哪个阶段、何时将结果写回。这通常由一个主状态机（FSM）和若干嵌套的计数器来完成。

状态机至少应包含以下几个状态：IDLE（空闲）、LOAD_A/LOAD_B（加载矩阵块）、COMPUTE（计算）、STORE_C（存储结果）。在COMPUTE状态下，需要计数器来追踪当前正在计算的是输出矩阵的哪个位置（i, j），以及内部累加到了第k个元素。控制逻辑的设计目标是让数据加载和计算重叠起来（流水线），隐藏数据访问的延迟。

3. 核心模块Verilog实现详解

下面，我们以一个计算MxN矩阵A与NxK矩阵B乘法，得到MxK矩阵C的设计为例，拆解关键模块的Verilog代码。我们采用一个包含P个并行MAC单元的简化架构，并假设数据位宽为DW。

3.1 顶层模块接口与参数化

一个好的设计应该是高度参数化的，便于复用和调整。顶层模块matrix_multiplier的接口和参数定义如下：

module matrix_multiplier #( parameter M = 8, // 矩阵A的行数 parameter N = 8, // 矩阵A的列数 / 矩阵B的行数 parameter K = 8, // 矩阵B的列数 parameter DW = 16, // 数据位宽 parameter P = 4 // 并行MAC单元数量 )( input wire clk, input wire rst_n, // 控制信号 input wire start, output reg done, // 矩阵A输入接口 (假设通过AXI-Stream或类似接口) input wire [DW-1:0] a_data, input wire a_valid, output reg a_ready, // 矩阵B输入接口 input wire [DW-1:0] b_data, input wire b_valid, output reg b_ready, // 矩阵C输出接口 output reg [DW*2-1:0] c_data, // 乘法结果位宽扩展 output reg c_valid, input wire c_ready );

注意：这里使用了类AXI-Stream的握手信号（valid/ready）作为数据接口，这是FPGA内部模块间通信的常见方式，利于构建流水线。实际应用中，这些接口可能会连接到DMA控制器或外部存储器接口。

3.2 并行MAC计算单元阵列

这是计算的核心。我们实例化P个乘累加单元。每个单元在一个时钟周期内完成一次乘法和累加。为了简化，我们先设计一个基础的MAC单元：

module mac_unit #( parameter DW = 16 )( input wire clk, input wire rst_n, input wire en, // 使能信号 input wire clear, // 累加器清零 input wire [DW-1:0] a, input wire [DW-1:0] b, output reg [DW*2-1:0] sum_out // 累加和输出，位宽扩展 ); reg [DW*2-1:0] accumulator; always @(posedge clk or negedge rst_n) begin if (!rst_n) begin accumulator <= 0; sum_out <= 0; end else if (clear) begin accumulator <= 0; sum_out <= 0; end else if (en) begin // 执行乘累加 accumulator <= accumulator + ({{(DW){a[DW-1]}}, a} * {{(DW){b[DW-1]}}, b}); // 有符号数乘法符号位扩展 sum_out <= accumulator; end end endmodule

在顶层，我们需要生成P个这样的单元，并正确地给它们分配数据。这里有一个关键点：数据分配策略。假设我们按输出矩阵C的行方向并行计算P个元素。那么，在同一个周期，我们需要为这P个MAC单元提供矩阵A的同一行元素（但列索引不同）和矩阵B的对应列数据。

// 在 matrix_multiplier 模块内部 genvar i; generate for (i=0; i<P; i=i+1) begin : mac_array wire [DW-1:0] a_to_mac; wire [DW-1:0] b_to_mac; wire [DW*2-1:0] mac_sum; wire mac_en; wire mac_clear; // 数据分配逻辑 (需要根据具体的调度算法实现) // 例如：a_to_mac = a_buffer[row_idx][col_idx+i]; // b_to_mac = b_buffer[col_idx+i][计算所需的列]; assign mac_en = compute_active && (col_counter < N); // 示例使能条件 assign mac_clear = (col_counter == 0); // 每计算一个新的输出元素时清零 mac_unit #(.DW(DW)) u_mac ( .clk(clk), .rst_n(rst_n), .en(mac_en), .clear(mac_clear), .a(a_to_mac), .b(b_to_mac), .sum_out(mac_sum) ); // 将每个MAC单元的结果暂存，用于后续组成输出 always @(posedge clk) begin if (mac_en && col_counter == N-1) begin // 累加完成一个内积 c_partial_sum[i] <= mac_sum; end end end endgenerate

3.3 双缓冲存储器与数据调度

为了隐藏数据加载延迟，实现计算与数据搬运的流水，双缓冲（乒乓缓冲）是常用技术。我们需要为矩阵A和B的子块分别准备两个缓冲区。

// 定义块缓冲区，大小例如为 BLOCK_SIZE x BLOCK_SIZE localparam BLOCK_SIZE = 8; reg [DW-1:0] a_buffer_0 [0:BLOCK_SIZE-1][0:BLOCK_SIZE-1]; reg [DW-1:0] a_buffer_1 [0:BLOCK_SIZE-1][0:BLOCK_SIZE-1]; reg a_buffer_sel; // 选择当前用于计算的缓冲区 // 数据加载状态机片段 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin load_state <= IDLE; a_buffer_sel <= 0; // ... 其他初始化 end else begin case (load_state) IDLE: if (start) load_state <= LOAD_A_BUF0; LOAD_A_BUF0: begin if (a_valid && a_ready) begin // 将a_data按地址存入 a_buffer_0 a_buffer_0[wr_addr_row][wr_addr_col] <= a_data; // 更新写地址... end if (/* A块加载完成 */) load_state <= LOAD_B_BUF0; end // ... 加载B到对应缓冲区 LOAD_B_BUF0: if (/* B块加载完成 */) begin load_state <= WAIT_COMPUTE; // 触发计算状态机开始使用 buffer_0 end WAIT_COMPUTE: begin // 当计算状态机开始处理当前缓冲块时，立即切换到加载下一块到另一个缓冲区 if (compute_start) begin a_buffer_sel <= ~a_buffer_sel; // 切换缓冲 load_state <= LOAD_A_BUF1; // 开始加载下一组数据到空闲缓冲区 end end // ... 类似地处理 BUF1 的加载 endcase end end

数据调度的逻辑是设计的难点和精髓。它需要精确计算每个时钟周期，应该从哪个缓冲区的哪个位置读取数据，送到哪个MAC单元。这通常由一组精心设计的行、列、块计数器共同控制。

3.4 主控制状态机实现

主状态机协调加载、计算、存储整个流程。下面是一个简化的状态转移图在代码中的体现：

localparam S_IDLE = 0; localparam S_LOAD = 1; localparam S_COMPUTE = 2; localparam S_STORE = 3; localparam S_DONE = 4; reg [2:0] current_state, next_state; reg [7:0] block_i, block_j, block_k; // 分块索引 reg [3:0] inner_i, inner_j, inner_k; // 块内索引 always @(posedge clk or negedge rst_n) begin if (!rst_n) current_state <= S_IDLE; else current_state <= next_state; end always @(*) begin next_state = current_state; done = 1'b0; // 默认信号赋值... case (current_state) S_IDLE: if (start) next_state = S_LOAD; S_LOAD: if (/* 当前所需数据块加载完成 */) next_state = S_COMPUTE; S_COMPUTE: begin if (/* 当前块内计算完成 */) begin if (/* 所有内积k维度完成 */) begin next_state = S_STORE; // 一个输出子块计算完毕 end else begin next_state = S_LOAD; // 需要加载下一个A/B块对 end end end S_STORE: if (/* 当前结果块写回完成 */) begin if (/* 所有输出块计算完成 */) next_state = S_DONE; else next_state = S_LOAD; // 计算下一个输出块 end S_DONE: begin done = 1'b1; next_state = S_IDLE; end endcase end // 在S_COMPUTE状态下，驱动计数器 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin inner_i <= 0; inner_j <= 0; inner_k <= 0; end else if (current_state == S_COMPUTE) begin if (inner_k < N-1) begin inner_k <= inner_k + 1; end else begin inner_k <= 0; if (inner_j < K-1) begin inner_j <= inner_j + 1; end else begin inner_j <= 0; if (inner_i < M-1) begin inner_i <= inner_i + 1; end else begin inner_i <= 0; // 触发块计算完成信号 end end end end end

4. 仿真验证与性能分析

4.1 测试平台搭建

设计完成后，必须通过仿真验证功能正确性。我们需要编写一个Testbench，生成随机的矩阵A和B，用Verilog模型（或调用软件函数如$readmemh）计算出期望的矩阵C，然后与我们的FPGA设计输出对比。

`timescale 1ns/1ps module tb_matrix_multiplier; reg clk, rst_n, start; wire done; // 接口信号声明... integer i, j; reg [15:0] A_mem [0:63]; // 假设8x8矩阵 reg [15:0] B_mem [0:63]; reg [31:0] C_expected [0:63]; // 期望结果 // 时钟生成 always #5 clk = ~clk; // 实例化待测设计 matrix_multiplier #(.M(8), .N(8), .K(8), .DW(16), .P(4)) uut ( ... ); initial begin // 初始化 clk = 0; rst_n = 0; start = 0; #100 rst_n = 1; // 1. 用软件方式（或调用C模型）计算期望结果 // 这里简化，用双重循环计算 for (i=0; i<8; i=i+1) begin for (j=0; j<8; j=j+1) begin C_expected[i*8+j] = 0; for (int k=0; k<8; k=k+1) begin C_expected[i*8+j] = C_expected[i*8+j] + A_mem[i*8+k] * B_mem[k*8+j]; end end end // 2. 通过任务或过程，模拟AXI-Stream将A_mem和B_mem数据喂给uut feed_matrix(A_mem, 64); feed_matrix(B_mem, 64); // 3. 启动计算 @(posedge clk) start = 1; @(posedge clk) start = 0; // 4. 等待计算完成，并收集输出结果C wait(done); collect_matrix(); // 5. 逐元素比较 for (i=0; i<64; i=i+1) begin if (C_collected[i] !== C_expected[i]) begin $display("ERROR at C[%0d][%0d]: expected %h, got %h", i/8, i%8, C_expected[i], C_collected[i]); $finish; end end $display("Test PASSED!"); $finish; end // 定义 feed_matrix 和 collect_matrix 任务... endmodule

4.2 时序收敛与性能估算

在FPGA设计中，光功能正确还不够，必须满足时序要求。综合和实现后，需要关注关键路径的建立时间（Setup Time）和保持时间（Hold Time）是否满足。矩阵乘法器的关键路径通常在MAC单元的乘加链或者跨多个计算单元的长路径上。

• 性能估算公式： 计算整个MxN * NxK矩阵乘法所需的理论时钟周期数（忽略初始化等开销）可以粗略估算为：Total Cycles ≈ (M * K * N) / P其中P是并行度。这是理想情况，实际由于数据加载、流水线填充和排空、控制开销，周期数会更多。我们的双缓冲设计就是为了让加载下一块的时间与计算当前块的时间重叠，从而逼近这个理想值。

• 资源消耗：主要关注DSP Slice、Block RAM和LUT/FF的用量。在Vivado或Quartus的编译报告中可以清晰看到。P个MAC单元大约消耗P个DSP。缓冲区消耗的BRAM数量取决于块大小和数据位宽。

4.3 常见问题与调试技巧实录

1. 仿真结果全为X或0：

   • 检查点：首先检查复位逻辑是否生效，所有寄存器是否在复位后正确初始化。其次，检查数据通路上的valid/ready握手信号。很多时候数据没进来是因为ready信号一直为低，或者valid和ready的时序没对齐。在Testbench中打印关键接口的信号波形。
   • 技巧：在初始仿真时，可以暂时绕过握手逻辑，用简单的@(posedge clk)直接给数据，先验证计算核心的正确性。

2. 计算结果与软件比对有误差：

   • 检查点：首先确认是定点数还是浮点数。我们这里用的是整数或定点数。重点检查符号位处理和位宽扩展。在乘法a * b时，两个DW位宽的数相乘，结果是2*DW位宽。如果是有符号数，必须进行符号位扩展，如前面代码中的{{(DW){a[DW-1]}}, a}。累加时，累加器的位宽要足够大，防止溢出。
   • 技巧：可以先用很小的矩阵（如2x2），并赋上简单的值（如全1或序列数），手工计算验证。在Verilog代码中关键节点添加$display语句，打印中间值。

3. 时序不收敛，建立时间违例：

   • 检查点：关键路径通常出现在组合逻辑过长的地方。比如，从一个缓冲区的输出，经过多级MUX选择，再进入乘法器，最后经过一个大的加法树。
   • 解决策略：
     • 流水线打拍：在长组合逻辑路径中插入寄存器，将其分割成多个时钟周期完成。例如，可以将“地址生成 -> 数据读取 -> 乘法 -> 累加”这个链条打断，每步都寄存一下。
     • 寄存器输出：确保模块的所有输出都是寄存器输出（Flop Output），避免组合逻辑输出导致下游路径紧张。
     • 降低频率：如果性能要求允许，可以尝试降低系统时钟频率。

4. 资源利用率过高：

   • 检查点：如果DSP不够用，考虑是否使用了全并行结构。降低并行度P。如果BRAM不够，考虑减小分块大小BLOCK_SIZE，或者优化缓冲区数据结构（例如，如果矩阵是稀疏的，可以采用压缩格式）。
   • 技巧：对于FPGA，乘法器是宝贵资源。如果数据位宽不是很大（比如小于18位），可以考虑用LUT构建乘法器（但性能较差）。也可以尝试使用时间复用的MAC单元，即一个物理MAC单元通过时分复用来服务多个逻辑计算，但这会降低吞吐率。

5. 无法正确与外部DDR或AXI接口对接：

   • 检查点：这是系统集成常见问题。确保你的矩阵乘法器模块的接口时序（如AXI-Stream）符合外部IP（如DMA或DDR控制器）的要求。仔细阅读IP的时序图，编写正确的接口适配逻辑（如FIFO）。
   • 技巧：先使用AXI Verification IP（VIP）或简单的仿真模型来验证你的模块接口行为是否正确，再连接到复杂的系统上。

5. 优化进阶与扩展思路

一个基础的矩阵乘法器工作后，可以从以下几个方向进行优化和扩展，这也是区分普通设计和优秀设计的地方：

5.1 计算阵列结构优化

将简单的并行MAC单元升级为脉动阵列。在脉动阵列中，数据像血液一样在固定的处理单元（PE）间规律地流动。每个PE只与邻居通信，极大地减少了全局连线和寄存器扇出，更容易达到高时钟频率。数据从阵列边界流入，结果从另一侧流出，计算吞吐量非常高，非常适合FPGA的流水线结构。设计脉动阵列需要对数据流有更深的理解，但性能收益显著。

5.2 支持可变精度与稀疏化

• 可变精度：通过参数化支持INT8、INT16、FP16等不同精度。这需要设计可配置的乘法器和累加器，以及相应的舍入和饱和处理逻辑。这对于机器学习推理加速至关重要。
• 稀疏矩阵计算：很多实际场景中的矩阵是稀疏的（大部分元素为0）。为稀疏矩阵设计专用的存储格式（如CSR、CSC）和计算单元，可以跳过零值计算，大幅提升效率和降低功耗。这需要在数据加载和调度逻辑上做更多文章。

5.3 系统级集成与软硬协同

单独的矩阵乘法器IP需要集成到更大的系统中才能发挥作用。

• 通过AXI接口封装：将我们的模块包装成标准的AXI-Lite控制接口和AXI-Stream数据接口的IP，方便在Vivado或Quartus的Block Design中像搭积木一样使用。
• 软硬协同：在SoC FPGA（如Zynq、Agilex）中，可以用处理器（ARM）运行软件，负责准备矩阵数据、配置DMA、启动加速器IP、读取结果。软件端可以使用OpenCL或Vitis HLS更高抽象层的工具来调用硬件模块，但手写Verilog/RTL通常能获得更极致的性能和效率。

5.4 功耗分析与优化

在高性能计算中，功耗是关键指标。

• 门控时钟：当某些计算单元或缓冲区在一段时间内空闲时，通过门控时钟关闭其时钟信号，可以动态降低功耗。
• 动态电压频率缩放：根据计算负载，动态调整模块的工作电压和频率。这通常需要更复杂的电源管理单元支持。
• 操作数隔离：确保当乘法器或加法器的输入无效时，其值被固定为0，防止不必要的翻转功耗。

设计一个FPGA矩阵乘法器，从功能实现到性能优化，是一个层层递进的过程。它几乎涵盖了数字系统设计的各个方面：算法映射、架构设计、接口协议、时序约束、资源优化和系统集成。把这个项目吃透，你对硬件加速的理解会上一个大台阶。我自己的体会是，最开始能跑通仿真就很有成就感，然后会不断追求更高的频率、更低的延迟和更高的能效比，这个过程本身就是最大的乐趣。在实际流片或部署到板卡时，记得预留足够的调试接口（如ILA），波形图永远是你最可靠的朋友。