FPGA HLS Matrix_MUL 矩阵乘法的计算与优化

最新推荐文章于 2025-06-30 11:15:48 发布
最新推荐文章于 2025-06-30 11:15:48 发布
阅读量4.5k 收藏 35
点赞数 10
CC 4.0 BY-SA版权
分类专栏： FPGA # HLS Project 文章标签： fpga开发 矩阵 线性代数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45364953/article/details/127641923
本文介绍如何使用Vivado HLS工具优化4x4矩阵乘法的实现过程，包括循环展开、流水线设计、数组分割及重塑等并行优化技术的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

新建Vivado工程

设置clock，10表示一个周期10ns，带宽100M

vivado工具比较保守，计算需要的延迟是14，实际优化可以在10，设置大一点，优化的计算更多，一般约束设置大一点在30-50

image-20221031202053105

选择开发板 xc7z020clg400-1

image-20221031201900305

Source：描述功能模块的cpp和h代码

Test Bench：测试代码的main.cpp

image-20221031204119132

C Code

matrix_mul.h

#ifndef __MATRIX_MUL__
#define __MATRIX_MUL__

#include "ap_fixed.h"

void matrix_mul(ap_int<8> A[4][4], ap_int<8> B[4][4], ap_int<16> C[4][4]);

#endif
  • #ifndef __xxxx__ #define __xxxx__ #endif 用于放置重复引入头文件
  • ap_fixed.h ：arbitrary precision data types 用于自定义精度整形（FPGA的浮点数运算很慢，在后面的模型推理的时候 整形数运算比较快）
  • 两个8位数相乘，结果最大可以是16位

.h文件包含了一个矩阵乘法的函数声明

matrix_mul.cpp

#include "matrix_mul.h"

void matrix_mul(ap_int<8> A[4][4], ap_int<8> B[4][4], ap_int<16> C[4][4])
{
	for(int i = 0; i < 4; ++ i){
		for(int j = 0; j < 4; ++ j){
			C[i][j] = 0;
			for(int k = 0; k < 4; ++ k){
				C[i][j] += A[i][k]*B[k][j];
			}
		}
	}
}

i行k列乘k行j列

image-20221031205949570

main.cpp

#include "matrix_mul.h"
#include <iostream>

int main()
{
	ap_int<8> A[4][4], B[4][4];
	ap_int<16> C[4][4];

	// initial A&B
	for(int i = 0; i < 4; ++ i)
		for(int j = 0; j < 4; ++ j)
			A[i][j] = B[i][j] = i*4 + j;

	// inference
	matrix_mul(A, B, C);

	// print C matrix
	for(int i = 0; i < 4; ++ i){
		for(int j = 0; j < 4; ++ j){
			std::cout << "C["<<i<<"] = " << C[i][j] << "\t";
		}
		std::cout << std::endl;
	}
	return 0;
}

C Simulation

当有许多模块的时候需要指定顶层函数，设置顶层模块(top function):

image-20221031211100559

C仿真主要用于编译C代码与HLS无关，测试功能是否与预期一致。使用C++完成testbench，同样地，C语言可以编译为对应的激励，驱动上一步骤完成的电路模块

_csim.log 文件显示仿真结果

INFO: [SIM 2] *************** CSIM start ***************
INFO: [SIM 4] CSIM will launch GCC as the compiler.
   Compiling ../../../main.cpp in debug mode
   Compiling ../../../matrix_mul.cpp in debug mode
   Generating csim.exe
C[0] = 56	C[0] = 62	C[0] = 68	C[0] = 74	
C[1] = 152	C[1] = 174	C[1] = 196	C[1] = 218	
C[2] = 248	C[2] = 286	C[2] = 324	C[2] = 362	
C[3] = 344	C[3] = 398	C[3] = 452	C[3] = 506	
INFO: [SIM 1] CSim done with 0 errors.
INFO: [SIM 3] *************** CSIM finish ***************

C Synthesis

C++代码综合成RTL逻辑，生成综合报告，包括时序，延时，资源占用，端口信息等。

image-20221101110827719

  • Loop Latency：完成所有循环需要的时钟周期

  • Iteration Latency：循环里面，迭代一次需要的周期

  • Initiation Interval（II）:两次迭代之间的时钟间隔

  • Trip Count：循环次数

image-20220925202823776

工程的资源占用情况（工程使用的资源数目&FPGA的总可用资源）：

image-20221101111612197

端口信息，ABC数组默认存在存储器ap_memory中，以下ap_clk、ap_rst、ap_start、ap_done、ap_idle、ap_ready都是控制信号

image-20221101111911350

端口分析：

  1. 控制端口用于控制和显示该模块的工作状态。各个端口的功功能如下，默认情况下会生成下面四个控制端口。
    • ap_start（in）：为高时，该模块开始处理数据。
    • ap_done（out）：为高时，表示模块处理数据完成。
    • ap_idle（out）：表明模块是否处于空闲态。高电平有效。为高时，该处于空闲态。
    • ap_ready（out）：为高时，表示模块可以接受新的数据。
  2. 数据端口用于传递模块的输入输出参数。
    参数d_o，d_i 为数组类型，故默认状态下回生成内存接口。内存接口 (数组类型参数)数据来自外部的memory，通过地址信号读取相应的数据，输入到该模块中。输入数组从外部内存中读源数据，输出数组从向外部内存写入结果数据。各个端口的定义如下。
    • address：地址信号
    • ce0：片选信号
    • we0：写使能信号
    • d0 :数据信号

并行优化

A和B的四个数同时相乘，让原先一行乘一列需要8个周期完成，变成一个周期完成

两种实现方法：

  • unroll，手动展开循环
  • pipline，系统自动推断展开
    • partiotion，切分数组
    • reshape，改变存储长度

unroll

image-20221101115409688

source文件自动添加优化代码：#pragma HLS UNROLL

#include "matrix_mul.h"

void matrix_mul(ap_int<8> A[4][4], ap_int<8> B[4][4], ap_int<16> C[4][4])
{
	for(int i = 0; i < 4; ++ i){
		for(int j = 0; j < 4; ++ j){
			C[i][j] = 0;
			for(int k = 0; k < 4; ++ k){
				#pragma HLS UNROLL
				C[i][j] += A[i][k]*B[k][j];
			}
		}
	}
}

运行C综合的结果：((1+2)*4+2)*4+1 =57

image-20221101204510037

pipeline

选择第二个for循环，设置pipeline的迭代间隔等于1

image-20221101210011113

自动添加优化语句：#pragma HLS PIPELINE II=1

#include "matrix_mul.h"

void matrix_mul(ap_int<8> A[4][4], ap_int<8> B[4][4], ap_int<16> C[4][4])
{
	for(int i = 0; i < 4; ++ i){
		for(int j = 0; j < 4; ++ j){
			#pragma HLS PIPELINE II=1
			C[i][j] = 0;
			for(int k = 0; k < 4; ++ k){
				C[i][j] += A[i][k]*B[k][j];
			}
		}
	}
}

C综合结果：

image-20221101210324088

计算一共需要34个周期，这已经比以前的169个周期快了不少了，但是我们希望16个周期就能计算完。

没有达到预期的目标是因为没有指定数组A和B的端口类型，默认为双端口。读取数据时一次只能读取2个，所以16次计算，每次读取4个数据，一共16*4个数据需要花费16*4/2=32个周期

端口只有ce0和ce1:

image-20221101210841771

所以需要同时取出四个数据，可以通过ArrayPartition和ArrayReshape实现

Array_Partition

数组分割：A竖着切割（按照维度2），分成4份分别存储在4个存储器里面；B横着切割（按照维度1）分别存储在4个存储器里面；

计算时同时各取出4个进行运算：

注意维度：高是维度1，宽是维度2

image-20221101211456726

image-20221101211537330

#include "matrix_mul.h"

void matrix_mul(ap_int<8> A[4][4], ap_int<8> B[4][4], ap_int<16> C[4][4])
{
    // partiton 优化语句
	#pragma HLS ARRAY_PARTITION variable=B complete dim=1
	#pragma HLS ARRAY_PARTITION variable=A complete dim=2
	for(int i = 0; i < 4; ++ i){
		for(int j = 0; j < 4; ++ j){
			#pragma HLS PIPELINE II=1
			C[i][j] = 0;
			for(int k = 0; k < 4; ++ k){
				C[i][j] += A[i][k]*B[k][j];
			}
		}
	}
}

C综合结果：

1*16+2 = 18

image-20221101211658088

数组A和B都有四个端口同时读数据了：

image-20221101211756643

Array_Reshape

重定义数组在存储器中的排列方式。原来默认一个地址行放一个数据，宽度只占8位。

A每次计算取一行，所以按照维度 2的方向放置数据：

image-20220925201701754

#include "matrix_mul.h"

void matrix_mul(ap_int<8> A[4][4], ap_int<8> B[4][4], ap_int<16> C[4][4])
{
	#pragma HLS ARRAY_RESHAPE variable=B complete dim=1
	#pragma HLS ARRAY_RESHAPE variable=A complete dim=2
	for(int i = 0; i < 4; ++ i){
		for(int j = 0; j < 4; ++ j){
			#pragma HLS PIPELINE II=1
			C[i][j] = 0;
			for(int k = 0; k < 4; ++ k){
				C[i][j] += A[i][k]*B[k][j];
			}
		}
	}
}

C综合结果：

image-20221101212321242

image-20221101212414932

latency约束

这里Latency指的是每次迭代的花费的周期数

设置计算消耗的周期数设置为5

image-20221101212901561

image-20220925195648390

#include "matrix_mul.h"

void matrix_mul(ap_int<8> A[4][4], ap_int<8> B[4][4], ap_int<16> C[4][4])
{
	#pragma HLS ARRAY_RESHAPE variable=B complete dim=1
	#pragma HLS ARRAY_RESHAPE variable=A complete dim=2
	for(int i = 0; i < 4; ++ i){
		for(int j = 0; j < 4; ++ j){
			#pragma HLS LATENCY min=5 max=5
			#pragma HLS PIPELINE II=1
			C[i][j] = 0;
			for(int k = 0; k < 4; ++ k){
				C[i][j] += A[i][k]*B[k][j];
			}
		}
	}
}

所以最后使用的周期数一共是：16×( Initiation Interval -1 ) + Latency = （16-1）×1+5 = 20

image-20221101212952817

原来不加latency时，延时是1，所以是(16-1)*1+1=16

一、基于ZYNQ的HLS矩阵乘法加速实验（二）
梅菜扣肉
10-16 2223
继续上篇： 首先将生成好的IP添加到IP库中，方法如下，第三步选择刚刚导出的路径，会自动识别出IP核。 接下来创建Block Design，先添加ZYNQ处理器，选择合适的DDR芯片型号和UART，然后将新添加的IP核加进BD中，点击自动连接，最终生成的框图如下： 留意一下寄存器的地址： 接下来就是传统的流程：生成output和顶层文件，综合实现布局布线，导出到Hardware，Launch SDK。 在SDK中创建一个新的Application，创建空文件或者HelloWord文件，我.
一、基于ZYNQ的HLS矩阵乘法加速实验（一）
梅菜扣肉
10-16 4649
HLS创建矩阵乘法加速器 目录 HLS创建矩阵乘法加速器 一、实验目的 二、HLS设计 三、打包IP 一、实验目的 通过HLS自动生成一个对两个4*4的矩阵进行乘法的电路，然后通过HLS进行优化，打包AXI接口并创建IP,最后在vivado中调用，在SDK中进行正确性检验。本篇我们只介绍HLS如何加速并打包生成IP，与vivado的联合测试将在下一篇介绍。 二、HLS设计 首先创建一个工程，我的工程名叫matrix，然后在source中添加两个文件，一个是.cpp文件，用来进行函数的定义，
基于FPGA的矩阵乘法器
06-23
该代码是基于FPGA的矩阵乘法器的代码，可以实现32x32大小有符号矩阵相乘，开发环境是ISE，用modelsim进行仿真
基于FPGA的矩阵乘法
qq_40268672的博客
11-13 8523
最近在学system verilog，于是就打算用它写一下矩阵乘法，来体验一把system verilog相对于verilog的方便之处（sv中数组可以作为接口) 以下是矩阵乘法的代码： `timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2020/11/13
FPGA矩阵算法实现
最新发布
weixin_51418325的博客
06-30 1035
本文探讨利用FPGA加速浮点矩阵运算的方法。通过将矩阵元素转换为IEEE754格式的16进制数，使用36个乘法器和5个加法器并行计算，实现高速矩阵乘法运算。实验采用6×6矩阵A和B进行验证，通过MATLAB、在线工具和FPGA仿真三种方式对比计算结果，最终确认FPGA实现结果准确。文章指出DeepSeek工具在浮点计算中存在误差，建议使用专业在线转换工具进行验证。该设计在保证FPGA资源的前提下，显著提升了矩阵运算速度。
FPGA矩阵运算，包括求逆运算等
09-03
论文讲述了FPGA矩阵运算，包括各种矩阵加、减、乘、除和求逆等运算，讲得很详细
基于FPGA的矩阵运算实现
04-13
基于FPGA的矩阵运算实现，基于FPGA的矩阵运算实现基于FPGA的矩阵运算实现基于FPGA的矩阵运算实现
FPGA实现各种矩阵运算
06-24
介绍了采用FPGA实现的各种矩阵运算的方法，是FPGA实现信号处理的基础。
HLS_Matrix.rar
12-16
标题 "HLS_Matrix.rar" 暗示了这个压缩包包含的内容与硬件描述语言（Hardware Description Language, 简称HLS）有关，特别是针对矩阵乘法操作的优化设计。HLS是一种技术，允许工程师使用高级编程语言如C/C++来描述...
HLS矩阵乘法IP生成器教程与源码
这三个文件名暗示了它们各自的作用：matrix_mul.cpp很可能是矩阵乘法核心算法的实现代码，而matrix_mul_tb.cpp很可能是该核心算法的测试平台代码，用于验证和测试矩阵乘法功能的正确性和性能。matrix_mul.h文件很...
FPGA硬件加速学习VIVADO HLS----------001
qq_674462612的博客
06-03 1663
Vivado HLS 矩阵乘法 先通过不加优化指令实现一个矩阵乘法 void Matrix_Mul (float A[4][4], float B[4][4], float C[4][4]) { for(int i=0;i<4;i++) { for(int j=0;j<4;j++) { C[i][j]=0; for(int k=0;k<4;k++) ...
HLS实现矩阵乘法，并且不同约束优化
03-29
HLS实现矩阵乘法，并且在不同约束下综合成为不同的电路，不同的速度；使用HLS优化RTL电路 CNN的卷积被实现为IPcore的基本实现文件
FPGA矩阵的运算实现
02-23
通过该论文，可以了解一般矩阵的设计步骤，以及对从低层构建模型的一般知识。
matrix_mul.zip
06-02
利用CCS（Code Composer Studio）实现N*N的矩阵乘法，两个矩阵数据时从数据段输入的，通过改变N的大小及输入数据就可以实现N*N的矩阵乘法
FPGA实现乘法的两种思路
01-17
简单的乘法运算的实现。有两种方法，一种是直接想乘，另外一种是把乘法转换成加法的思路，具体代码实现如上，经过testbench验证也没问题。
FPGA | Verilog 实现矩阵乘法（附源码）
热门推荐
Always learn from the best.
12-14 1万+
FPGA | Verilog 实现矩阵乘法（附源码）
基于FPGA的脉动阵列矩阵乘法
qq_40268672的博客
02-05 2688
部分信号的时序图： 模块代码： `timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2021/02/04 10:29:57 // Design Name: // Module Name: systolic // Project Name: // Targe
基于脉动阵列的矩阵乘法加速（FPGA）
m0_50735735的博客
03-30 1万+
基于脉动阵列的矩阵乘法加速（FPGA） ​ 原本准备做FADDEV求逆矩阵算法的FPGA实现，其中有一个概念挺吸引人，就是：脉动阵列。 1、脉动阵列 ​ 先来讲讲脉动阵列的概念，脉动阵列其实是一种处理单元的结构。数据同步流过，能够减小降低重复访问，调高处理效率和资源消耗。 ​ 其实这是个比较旧的概念了，1982就有学者提出了。18年谷歌提出的TPU（Tensor Processing Unit）让这个概念回到大众视野，通过脉动阵列可以设计完成矩阵乘法和卷积的操作。今天先讲讲矩阵乘法的实现。 2、脉动阵列结构
矩阵乘法的多种理解形式（硬件设计的基础）（FPGA）
星智云图工作室（StarImagine Studio）
04-19 8653
1、外积和内积：（1）内积：一个行向量乘以一个列向量称作向量的内积 ，又叫作点积，结果是一个数：；（2）外积：一个列向量乘以一个行向量称作向量的外积 ，外积是一种特殊的克罗内克积（克罗内克积是两个任意大小的矩阵间的运算），结果是一个矩阵，；2、矩阵乘法的变换理解：       矩阵是由向量组成的，将矩阵乘法转换为向量乘法，是从多种角度理解矩阵乘法的精髓。        我们对一个矩阵A（假设行和列...
HLS矩阵乘法优化与IPcore实现研究
在HLS中进行矩阵乘法优化时，通常需要考虑以下约束条件： - 计算资源：CPU/GPU核心数量、FPGA逻辑单元数量等。 - 存储资源：可用的内部存储器大小、外部存储器带宽。 - 时钟频率：目标工作频率越高，对电路性能的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值