FPGA HLS 卷积单元 数据类型&hls优化&约束设置

最新推荐文章于 2023-10-08 16:26:47 发布
最新推荐文章于 2023-10-08 16:26:47 发布
阅读量1.4k 收藏 22
点赞数 5
分类专栏： FPGA # HLS Project 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45364953/article/details/127708973
版权

数据类型

自定义精度整形：

ap_int<4> in1, in2;
ap_int<8> concat;
concat = (in1, in2);	// in1和in2拼起来（按照补码拼起来）
/*
例子：
in1 = 1, in2 = -1
补码：
in1 =  0001
in2 =  1001 ==> 1110+1 ==> 1111
concat = 00011111 = 31
*/
concat.xor_reduce();	// 按位异或

image-20221104195907274

自定义定点数

为了替换float，double类型的数，加快运算，节约资源

ap_fixed<11, 6> Var1 = 22.96875; // 一共11个bit，其中6个bit表示整数，5个bit表示小数；剩一个bit表示正负数
ap_ufixed<12, 11> Var2 = 512.5;	// 一共12个bit，11位表示整数，最后一位表示小数

image-20221104200355155

卷积的量化或定点化

根据输入的数据，找到卷积层的数据范围

A= aaaaaaaaaaaaaaaa, fix_point=12
B= bbbbbbbbbbbbbbbb, fix_point=13
C= ????????????????, fix_point=13

????????????????*(2^13)=A*B/2^(12+13)

求C的编码：????????????????
= A*B/2^(12+13-13)
= A*B/2^(fix_pointA + fix_pointB – fix_pointC)

例子：
A:0010.1100 = 44/16 = 2+0.5+0.25 = 2.75 fix_point = 4
B:00101.100 = 44/8 = 5+0.5 = 5.5 fix_point = 3
C:????.???? Fix_point = 4
A*B =44*44 = 011110010000 == 右移(3+4) = 01111.0010000 = 15.125
一共有(3+4)位小数，但是C的精度是4，所以需要把多余的小数移出去
移出去的位数就是(3+4-4) = 3
所以C = 1111.0010 fix_point = 4

自定义卷积

特征的内存排布方式

image-20221104213524620

权重的内存排布方式

image-20221104213622677

卷积的大小不固定，需要根据在内存中的排布方式算出地址

新建conv_core项目

conv_core.h

#ifndef __CONV_CORE_H__
#define __CONV_CORE_H__

#include <ap_int.h>
#include <iostream>
using namespace std;

#define K 8

typedef ap_int<16> data_type;	// 单个数据的大小
typedef ap_int<16*K> tile_type;	// 分块数据的大小

typedef ap_int<32> mul_type;	// 两个数据相乘的数据大小：16*16==>32
typedef ap_int<32*K> mul_tile_type; // 分块数据相乘的大小

typedef ap_int<40> acc_type;  // 一次卷积内的数据相加后的大小，按照经验推断

// 卷积的定义
void conv_core(
		ap_uint<16> in_channel, // 输入特征的通道数
		ap_uint<16> in_height, // 输入特征高度
		ap_uint<16> in_width, // 输入特征宽度
		ap_uint<16> out_channel, // 输出特征通道数

		// 卷积核参数
		ap_uint<8> kernel_width, // 卷积核宽度
		ap_uint<8> kernel_height, // 卷积核高度

		ap_uint<8> stride_x, // 宽度方向步长
		ap_uint<8> stride_y, // 高度方向步长

		ap_uint<1> padding_mode, // 卷积的模式; 0: valid（没有padding填充）, 1:same（输入输出的图大小不变）

		ap_uint<1> relu_en, // 激活函数

		tile_type input_feature[], ap_uint<4> input_feature_precision,	// 输入特征图地址和精度（小数点位置）
		tile_type weight[], ap_uint<4> weight_precision,// 权重地址和精度（小数点位置）
		tile_type output_feature[], ap_uint<4> out_feature_precision// 输出特征图地址和精度（小数点位置）
);

#endif

conv_core.cpp

#include "conv_core.h"

void conv_core(
		// 特征图参数
		ap_uint<16> in_channel, // 输入特征的通道数
		ap_uint<16> in_height, // 输入特征高度
		ap_uint<16> in_width, // 输入特征宽度
		ap_uint<16> out_channel, // 输出特征通道数

		// 卷积核参数
		ap_uint<8> kernel_width, // 卷积核宽度
		ap_uint<8> kernel_height, // 卷积核高度

		ap_uint<8> stride_x, // 宽度方向步长
		ap_uint<8> stride_y, // 高度方向步长

		ap_uint<1> padding_mode, // 卷积的模式; 0: valid（没有padding填充）, 1:same（输入输出的图大小不变）

		ap_uint<1> relu_en, // 激活函数

		tile_type input_feature[], ap_uint<4> input_feature_precision,	// 输入特征图地址和精度（小数点位置）
		tile_type weight[], ap_uint<4> weight_precision,// 权重地址和精度（小数点位置）
		tile_type output_feature[], ap_uint<4> out_feature_precision// 输出特征图地址和精度（小数点位置）
)
{
	// Feature: [CHin/K][H][W][K]
	// Weight: [CHout][CHin/K][KH][KW][K]

	// 根据卷积模式，计算padding
	ap_uint<8> padding_x, padding_y;
	if(padding_mode == 0){
		padding_x = padding_y = 0;
	}else{
		padding_x = (kernel_width-1)/2;
		padding_y = (kernel_height-1)/2;
	}
	// 计算分块个数
	ap_uint<16> div_tile_num = (in_channel + K-1) / K;
	// 计算输出截断精度
	ap_uint<5> out_truncate = input_feature_precision + weight_precision - out_feature_precision;
	/*
	 * [x x x] x x x
	 * x x [x x x] x
	 */
	// 计算输出宽度和高度
	ap_uint<16> out_width = (in_width + padding_x*2) / stride_x + 1;
	ap_uint<16> out_height = (in_height + padding_y*2) / stride_y + 1;

	// 选择输出特征的第y行，第x列，第c_out个输出通道的数据
	// 选择第c_out个权重的第y行，第x列，第tile_index个分块

	LOOP_out_channel:
	for(int out_index = 0; out_index < out_channel; ++ out_index){
		LOOP_out_height:
		for(int i = 0; i < out_height; ++ i){
			LOOP_out_width:
			for(int j = 0; j < out_width; ++ j){
				// 相乘结果累加
				acc_type sum=0;
				// 计算输出特征中一个tile的数据
				ap_int<16> out_tile = 0;
				LOOP_kernel_height:
				for(int kh = 0; kh < kernel_height; ++ kh){
					LOOP_kernel_width:
					for(int kw = 0; kw < kernel_width; ++ kw){
						LOOP_div_tile_num:
						for(int tile_index = 0; tile_index < div_tile_num; ++ tile_index){

							// 获取计算点
							ap_uint<16> in_h = i*stride_y-padding_y + kh;
							ap_uint<16> in_w = j*stride_x-padding_x + kw;

							// 获取输入特征和权重的一个块数据
							tile_type data_tile, weight_tile;
							// 有padding会越界
							if(in_h >= 0 && in_h < in_height && in_w >= 0 && in_w < in_width){
								data_tile = input_feature[in_width*in_height*tile_index + in_width*in_h + in_w];
								weight_tile = weight[kernel_width*kernel_height*div_tile_num*out_index
													 + kernel_width*kernel_height*tile_index
													 + kernel_width*kh+kw];
							}else{
								data_tile = 0; weight_tile = 0;
							}
							// 块数据相乘
							mul_tile_type mul_tile_data;
							for(int k = 0; k < K; ++ k)
								mul_tile_data.range(k*32+31, k*32) =
										(data_type)data_tile.range(k*16+15, k*16)*
										(data_type)weight_tile.range(k*16+15, k*16);
							// 相乘结果累加
							for(int k = 0; k < K; ++ k)
								sum += (mul_tile_type)mul_tile_data.range(k*32+31, k*32);
						}
					}
				}

				// 激活函数
				if(relu_en & sum < 0) sum = 0;
				// 截断多余精度
				acc_type res = sum >> out_truncate;

				if (res > 32767)
					res = 32767;
				else if (res < -32768)
					res = -32768;
				out_tile.range((out_index % K) * 16 + 15, (out_index % K) * 16) = res;
				// 存tile里的一个数据
				// 一个tile都存完了或者存到最后一个通道凑不够一个tile
				if((out_index%K) == K - 1 || out_index == (out_channel - 1))
					output_feature[(out_index/K)*out_width*out_height + out_width*i+j] = out_tile;
			}
		}
	}
}

main.cpp

#include "stdio.h"
#include "conv_core.h"

#define IN_WIDTH 10
#define IN_HEIGHT 10
#define IN_CHANNEL 1
#define IN_DIV_TILE_NUM	((IN_CHANNEL+K-1)/K)

#define KERNEL_WIDTH 5
#define KERNEL_HEIGHT 5
#define STRIDE_X 1
#define STRIDE_Y 1

#define RELU_EN 0
#define PADDING_MODE 0 // 0:valid 1:same
#define PADDING_X (PADDING_MODE?(KERNEL_WIDTH-1)/2:0)
#define PADDING_Y (PADDING_MODE?(KERNEL_HEIGHT-1)/2:0)

#define OUT_CHANNEL 1
#define OUT_WIDTH ((IN_WIDTH+PADDING_X*2-KERNEL_WIDTH)/STRIDE_X+1)
#define OUT_HEIGHT ((IN_HEIGHT+PADDING_Y*2-KERNEL_HEIGHT)/STRIDE_Y+1)
#define OUT_DIV_TILE_NUM ((OUT_CHANNEL+K-1)/K)

int main(void)
{
	tile_type input_feature[IN_DIV_TILE_NUM][IN_HEIGHT][IN_WIDTH];
	tile_type weight[OUT_CHANNEL][IN_DIV_TILE_NUM][KERNEL_HEIGHT][KERNEL_WIDTH];
	tile_type output_feature[OUT_DIV_TILE_NUM][OUT_HEIGHT][OUT_WIDTH];

	for(int tile_index = 0; tile_index < IN_DIV_TILE_NUM; ++ tile_index){
		for(int i = 0; i < IN_HEIGHT; ++ i){
			for(int j = 0; j < IN_WIDTH; ++ j){
				for(int k = 0; k < K; ++ k){
					// 可能除不尽
					if(tile_index*K+k < IN_CHANNEL)
						input_feature[tile_index][i][j].range(k*16+15, k*16) = (1<<14);
					else
						input_feature[tile_index][i][j].range(k*16+15, k*16) = 0;
				}
			}
		}
	}

	for(int out_index = 0; out_index < OUT_CHANNEL; ++ out_index){
		for(int tile_index = 0; tile_index < OUT_DIV_TILE_NUM; ++ tile_index){
			for(int i = 0; i < OUT_HEIGHT; ++ i){
				for(int j = 0; j < OUT_WIDTH; ++j){
					for(int k = 0; k < K; ++ k){
						// 输入特征赋值为0，特征值就不用考虑除不尽的问题
						weight[out_index][tile_index][i][j].range(16*k+15, 16*k) = (1<<14);
					}
				}
			}
		}
	}

	for(int tile_index = 0; tile_index < OUT_DIV_TILE_NUM; ++ tile_index){
		for(int i = 0; i < OUT_HEIGHT; ++ i){
			for(int j = 0; j < OUT_WIDTH; ++ j){
				output_feature[tile_index][i][j] = 0;
			}
		}
	}

	printf("initial down\n");

	conv_core(IN_CHANNEL, IN_HEIGHT, IN_WIDTH, OUT_CHANNEL,
			KERNEL_WIDTH, KERNEL_HEIGHT,
			STRIDE_X, STRIDE_Y,
			PADDING_MODE, RELU_EN,
			&input_feature[0][0][0], 14,
			&weight[0][0][0][0], 14,
			&output_feature[0][0][0], 10
	);

	for(int tile_index = 0; tile_index < OUT_DIV_TILE_NUM; ++ tile_index){
		for(int i = 0; i < OUT_HEIGHT; ++ i){
			for(int j = 0; j < OUT_WIDTH; ++ j){
				cout << "out[" << tile_index <<"]["<<i<<"]["<<j<<"]="<<
				(data_type)output_feature[tile_index][i][j].range(15, 0) << "\t";
			}
			cout << endl;
		}
	}


	return 0;
}

运行

C仿真结果：

image-20221105183939657

C综合：

image-20221105184415141

出错了，需要加约束。报错信息：输入特征feature_in是没有固定长度的

但是我们只是把input_feature当作基地址，而不是数组，所以需要告诉工具，数据来自外部存储器

数据接口约束

image-20221105185249772

image-20221105185314764

#pragma HLS INTERFACE m_axi depth=999999999 port=weight offset=slave
#pragma HLS INTERFACE m_axi depth=999999999 port=output_feature offset=slave
#pragma HLS INTERFACE m_axi depth=999999999 port=input_feature offset=slave

再次C综合：

image-20221105185415418

？？？是因为，循环次数是一个变量，工具无法估计性能

循环次数约束

那就根据test bench里的例子进行测试约束

image-20221105190053192

#include "conv_core.h"

void conv_core(
		// 特征图参数
		ap_uint<16> in_channel, // 输入特征的通道数
		ap_uint<16> in_height, // 输入特征高度
		ap_uint<16> in_width, // 输入特征宽度
		ap_uint<16> out_channel, // 输出特征通道数

		// 卷积核参数
		ap_uint<8> kernel_width, // 卷积核宽度
		ap_uint<8> kernel_height, // 卷积核高度

		ap_uint<8> stride_x, // 宽度方向步长
		ap_uint<8> stride_y, // 高度方向步长

		ap_uint<1> padding_mode, // 卷积的模式; 0: valid（没有padding填充）, 1:same（输入输出的图大小不变）

		ap_uint<1> relu_en, // 激活函数

		tile_type input_feature[], ap_uint<4> input_feature_precision,	// 输入特征图地址和精度（小数点位置）
		tile_type weight[], ap_uint<4> weight_precision,// 权重地址和精度（小数点位置）
		tile_type output_feature[], ap_uint<4> out_feature_precision// 输出特征图地址和精度（小数点位置）
)
{
	#pragma HLS INTERFACE m_axi depth=999999999 port=weight offset=slave
	#pragma HLS INTERFACE m_axi depth=999999999 port=output_feature offset=slave
	#pragma HLS INTERFACE m_axi depth=999999999 port=input_feature offset=slave
	// Feature: [CHin/K][H][W][K]
	// Weight: [CHout][CHin/K][KH][KW][K]

	// 根据卷积模式，计算padding
	ap_uint<8> padding_x, padding_y;
	if(padding_mode == 0){
		padding_x = padding_y = 0;
	}else{
		padding_x = (kernel_width-1)/2;
		padding_y = (kernel_height-1)/2;
	}
	// 计算分块个数
	ap_uint<16> div_tile_num = (in_channel + K-1) / K;
	// 计算输出截断精度
	ap_uint<5> out_truncate = input_feature_precision + weight_precision - out_feature_precision;
	/*
	 * [x x x] x x x
	 * x x [x x x] x
	 */
	// 计算输出宽度和高度
	ap_uint<16> out_width = (in_width + padding_x*2) / stride_x + 1;
	ap_uint<16> out_height = (in_height + padding_y*2) / stride_y + 1;

	// 选择输出特征的第y行，第x列，第c_out个输出通道的数据
	// 选择第c_out个权重的第y行，第x列，第tile_index个分块

	LOOP_out_channel:
	for(int out_index = 0; out_index < out_channel; ++ out_index){
#pragma HLS LOOP_TRIPCOUNT min=1 max=1 avg=1
		LOOP_out_height:
		for(int i = 0; i < out_height; ++ i){
#pragma HLS LOOP_TRIPCOUNT min=10 max=10 avg=10
			LOOP_out_width:
			for(int j = 0; j < out_width; ++ j){
#pragma HLS LOOP_TRIPCOUNT min=10 max=10 avg=10
				// 相乘结果累加
				acc_type sum=0;
				// 计算输出特征中一个tile的数据
				ap_int<16> out_tile = 0;
				LOOP_kernel_height:
				for(int kh = 0; kh < kernel_height; ++ kh){
#pragma HLS LOOP_TRIPCOUNT min=5 max=5 avg=5
					LOOP_kernel_width:
					for(int kw = 0; kw < kernel_width; ++ kw){
#pragma HLS LOOP_TRIPCOUNT min=5 max=5 avg=5
						LOOP_div_tile_num:
						for(int tile_index = 0; tile_index < div_tile_num; ++ tile_index){
#pragma HLS LOOP_TRIPCOUNT min=1 max=1 avg=1
							// 获取计算点
							ap_uint<16> in_h = i*stride_y-padding_y + kh;
							ap_uint<16> in_w = j*stride_x-padding_x + kw;

							// 获取输入特征和权重的一个块数据
							tile_type data_tile, weight_tile;
							// 有padding会越界
							if(in_h >= 0 && in_h < in_height && in_w >= 0 && in_w < in_width){
								data_tile = input_feature[in_width*in_height*tile_index + in_width*in_h + in_w];
								weight_tile = weight[kernel_width*kernel_height*div_tile_num*out_index
													 + kernel_width*kernel_height*tile_index
													 + kernel_width*kh+kw];
							}else{
								data_tile = 0; weight_tile = 0;
							}
							// 块数据相乘
							mul_tile_type mul_tile_data;
							for(int k = 0; k < K; ++ k)
								mul_tile_data.range(k*32+31, k*32) =
										(data_type)data_tile.range(k*16+15, k*16)*
										(data_type)weight_tile.range(k*16+15, k*16);
							// 相乘结果累加
							for(int k = 0; k < K; ++ k)
								sum += (mul_tile_type)mul_tile_data.range(k*32+31, k*32);
						}
					}
				}

				// 激活函数
				if(relu_en & sum < 0) sum = 0;
				// 截断多余精度
				acc_type res = sum >> out_truncate;

				if (res > 32767)
					res = 32767;
				else if (res < -32768)
					res = -32768;
				out_tile.range((out_index % K) * 16 + 15, (out_index % K) * 16) = res;
				// 存tile里的一个数据
				// 一个tile都存完了或者存到最后一个通道凑不够一个tile
				if((out_index%K) == K - 1 || out_index == (out_channel - 1))
					output_feature[(out_index/K)*out_width*out_height + out_width*i+j] = out_tile;
			}
		}
	}
}

综合结果：

image-20221105190949870

优化

最内层的块相乘只用两个周期完成

一个周期用来去input_tile，另一个取weight_tile，输出计算结果的同时，也在取数据

image-20221105191912130

添加 pipeline 优化

迭代间隔 II = 2

image-20221105192124549

如果效果理想的话应该是 1*10*10*5*5*2=5000

但是综合结果并不是：

image-20221105193101366

卷积一次：2*25 = 50

这里循环的latency是59，多了9个周期是迭代latency

但是顶层的迭代latency达到了70，其中多的11周期的计算在这里：

image-20221105194344619

完美循环优化与计算顺序的调换

  • 完美循环

使用if语句使循环之间没有代码，使得循环可以合并

从存储器取块数据相乘累加的运算，其实可以和计算结果的存储并行

image-20221105201529553

  • 计算顺序调换

将out_channel挪到kernel_width上面，这样每计算完一次卷积tile，就判断一次对输出特征写计算结果

#include "conv_core.h"

void conv_core(
		// 特征图参数
		ap_uint<16> in_channel, // 输入特征的通道数
		ap_uint<16> in_height, // 输入特征高度
		ap_uint<16> in_width, // 输入特征宽度
		ap_uint<16> out_channel, // 输出特征通道数

		// 卷积核参数
		ap_uint<8> kernel_width, // 卷积核宽度
		ap_uint<8> kernel_height, // 卷积核高度

		ap_uint<8> stride_x, // 宽度方向步长
		ap_uint<8> stride_y, // 高度方向步长

		ap_uint<1> padding_mode, // 卷积的模式; 0: valid（没有padding填充）, 1:same（输入输出的图大小不变）

		ap_uint<1> relu_en, // 激活函数

		tile_type input_feature[], ap_uint<4> input_feature_precision,	// 输入特征图地址和精度（小数点位置）
		tile_type weight[], ap_uint<4> weight_precision,// 权重地址和精度（小数点位置）
		tile_type output_feature[], ap_uint<4> out_feature_precision// 输出特征图地址和精度（小数点位置）
)
{
	#pragma HLS INTERFACE m_axi depth=999999999 port=weight offset=slave
	#pragma HLS INTERFACE m_axi depth=999999999 port=output_feature offset=slave
	#pragma HLS INTERFACE m_axi depth=999999999 port=input_feature offset=slave
	// Feature: [CHin/K][H][W][K]
	// Weight: [CHout][CHin/K][KH][KW][K]

	// 根据卷积模式，计算padding
	ap_uint<8> padding_x, padding_y;
	if(padding_mode == 0){
		padding_x = padding_y = 0;
	}else{
		padding_x = (kernel_width-1)/2;
		padding_y = (kernel_height-1)/2;
	}
	// 计算分块个数
	ap_uint<16> div_tile_num = (in_channel + K-1) / K;
	// 计算输出截断精度
	ap_uint<5> out_truncate = input_feature_precision + weight_precision - out_feature_precision;
	/*
	 * [x x x] x x x
	 * x x [x x x] x
	 */
	// 计算输出宽度和高度
	ap_uint<16> out_width = (in_width + padding_x*2) / stride_x + 1;
	ap_uint<16> out_height = (in_height + padding_y*2) / stride_y + 1;

	// 计算输出特征中一个tile的数据
	ap_int<16> out_tile = 0;
	// 相乘结果累加
	acc_type sum=0;

	// 选择输出特征的第y行，第x列，第c_out个输出通道的数据
	// 选择第c_out个权重的第y行，第x列，第tile_index个分块


	LOOP_out_height:
	for(int i = 0; i < out_height; ++ i){
#pragma HLS LOOP_TRIPCOUNT min=1 max=1 avg=1
		LOOP_out_width:
		for(int j = 0; j < out_width; ++ j){
#pragma HLS LOOP_TRIPCOUNT min=10 max=10 avg=10
			LOOP_out_channel:
			for(int out_index = 0; out_index < out_channel; ++ out_index){
#pragma HLS LOOP_TRIPCOUNT min=10 max=10 avg=10

				LOOP_kernel_height:
				for(int kh = 0; kh < kernel_height; ++ kh){
#pragma HLS LOOP_TRIPCOUNT min=5 max=5 avg=5
					LOOP_kernel_width:
					for(int kw = 0; kw < kernel_width; ++ kw){
#pragma HLS LOOP_TRIPCOUNT min=5 max=5 avg=5
						LOOP_div_tile_num:
						for(int tile_index = 0; tile_index < div_tile_num; ++ tile_index){
#pragma HLS PIPELINE II=2
#pragma HLS LOOP_TRIPCOUNT min=1 max=1 avg=1
							// 获取计算点
							ap_uint<16> in_h = i*stride_y-padding_y + kh;
							ap_uint<16> in_w = j*stride_x-padding_x + kw;

							// 获取输入特征和权重的一个块数据
							tile_type data_tile, weight_tile;
							// 有padding会越界
							if(in_h >= 0 && in_h < in_height && in_w >= 0 && in_w < in_width){
								data_tile = input_feature[in_width*in_height*tile_index + in_width*in_h + in_w];
								weight_tile = weight[kernel_width*kernel_height*div_tile_num*out_index
													 + kernel_width*kernel_height*tile_index
													 + kernel_width*kh+kw];
							}else{
								data_tile = 0; weight_tile = 0;
							}
							// 块数据相乘
							mul_tile_type mul_tile_data;
							for(int k = 0; k < K; ++ k)
								mul_tile_data.range(k*32+31, k*32) =
										(data_type)data_tile.range(k*16+15, k*16)*
										(data_type)weight_tile.range(k*16+15, k*16);
							// 相乘结果累加
							for(int k = 0; k < K; ++ k)
								sum += (mul_tile_type)mul_tile_data.range(k*32+31, k*32);

							if(tile_index == div_tile_num-1 && kh == kernel_height-1 && kw == kernel_width-1){
								// 激活函数
								if(relu_en & sum < 0) sum = 0;
								// 截断多余精度
								acc_type res = sum >> out_truncate;

								if (res > 32767)
									res = 32767;
								else if (res < -32768)
									res = -32768;

								// 先缓存下来，下面一次写入
								out_tile.range((out_index % K) * 16 + 15, (out_index % K) * 16) = res;
								sum = 0;
								// 存tile里的一个数据
								// 一个tile都存完了或者存到最后一个通道凑不够一个tile
								if((out_index%K) == K - 1 || out_index == (out_channel - 1)){
									output_feature[(out_index/K)*out_width*out_height + out_width*i+j] = out_tile;
									out_tile = 0;
								}
							}
						}
					}
				}


			}
		}
	}
}

C综合已经达到我们的预期了

image-20221105201042737

访问方式的优化-通道方向的并行

给特征图和权重分别分配一条总线，那么就可以同时取出两个数据，只需要一个周期就可以完成一次tile的计算

bundle：一捆，不选的话默认是同一个总线

所以这里我们给input_feature和weight取两个不同的名字，就给它们分配了不同的总线：

image-20221105202209564

image-20221105202520163

AXI是全双工的，可以同时写和读，但是同时读两个就不太行，读一个的同时写一个可以。所以不需要给output_feature分配一个总线

然后我们就可以在一个周期内运行一次tile计算，设置pipeline的II = 1:

image-20221105203023536

也就是K个数据的乘法和累加，需要K个乘法器同时进行

image-20221105203224253

可以看出来是2500个周期：1*10*10*5*5*(1 clock)=2500

xiongyuqing
关注
  • 5
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
卷积神经网络代码（HLS版本）.zip
08-09
关于一些初步卷积神经网络的HLS代码及约束。通过这部分可以了解卷积神经网络在HLS上面的实现。具有一些借鉴意义，想要真正的了解还请参加Xilinx每年的暑期计划。
基于Cyclone V SoC利用HLS实现卷积手写体数字识别设计
m0_73063250的博客
04-23 984
基于SoCFPGA的手写体识别项目，包括FPGA和HPS两大板块。在FPGA板块中，细分为OV5640摄像头、HDMI显示和算法处理三个模块。HPS板块包含DDR3和手写体算法控制两个模块。OV5640摄像头模块采集RGB565格式的图像数据，每个像素占两个字节，分辨率为1024x760，通过Avalon接口的memory_map Master接口输出给DDR3高速存储器。在DDR3中，设计了一块frame_buffer数据缓冲区，用于存储采集到的图像数据。
卷积操作的HLS优化初步操作
祥瑞的技术博客
08-09 5595
背景：卷积操作运用到了三个for循环，非常耗时耗力，HLS综合之后需要耗费很多时钟周期，我们需要对卷积操作进行相应的优化，从而减少卷积运行的时间。 目的：优化卷积操作。 目录 0.原始未优化情况 0.1 testBench确保程序正确 0.2 原始时钟周期 1. 最内层pipeline 1.1直接pipeline 1.2 读写指令分开 1.3 创建变量用于存储 2. 批量读写卷...
基于HLS工具的进阶实战学习笔记1——卷积单元
ye_song的专栏
02-06 1948
这里写自定义目录标题笔记——学习HLS：卷积单元 笔记——学习HLS：卷积单元 void Conv(ap_uint<16> CHin,ap_uint<16> Hin,ap_uint<16> Win,ap_uint<16> CHout, ap_uint<8> Kx,ap_uint<8> Ky,ap_uint<8> S...
hls之优化
weixin_40162095的博客
03-13 2887
HLS实战1：矩阵乘法 循环展开 Pipeline处理 数组优化 基于联合仿真的电路优化 文章目录1.并行计算介绍2.使用方法一：手动展开(1) unroll(2)pipeline联合仿真Open Wave Viewer(3)ARRAY_PARTITION修改代码后再次Run Synthesis不优化、只加PIPELINE优化、PIPELINE与ARRAY_PARTITION共同优化，资源对比(4)ARRAY_RESHAPE添加约束文件Run Synthesisreshape相比partition无法做
Vivado HLS实现卷积和池化操作
最新发布
Legendyyy的博客
10-08 736
Vivado HLS实现卷积和池化操作
基于HLS的高效深度卷积神经网络FPGA实现方法1
08-03
1.1 考虑硬件友好和网络小巧的设计思路 1.1.1 1.1.2 1.1.3 1.1.4 1.1.5 1.1.6
基于HLS的高效深度学习卷积神经网络FPGA实现方法项目全部数据.zip
11-30
基于HLS的高效深度学习卷积神经网络FPGA实现方法项目全部数据.zip本文通过对现有相关研究的分析、总结和改进，给出了一系列在软件层面上如何构建和训练小巧高效且利于硬件加速的网络方法，在FPGA实现时如何减少资源...
基于Python HLS的高效深度卷积神经网络FPGA实现方法【100011343】
03-22
通过对现有相关研究的分析、总结和改进，给出了一系列在软件层面上如何构建和训练小巧高效且利于硬件加速的网络方法，在FPGA实现时如何减少资源、降低功耗及提高速度的方法，以及在HLS中如何增加设计灵活性、可移植...
基于HLS的Tiny_yolo卷积神经网络加速研究
09-13
基于HLS的Tiny_yolo卷积神经网络加速研究，从论文的角度对基于FPGA的深度学习实现方法进行了说明
xilinx Vivado HLS技术性能优化指南
07-22
该文档描述了使用HLS技术时如何进行性能优化，例如如何减少时延或减少面积。Vivado® 高层次综合（HLS）在所有 Vivado HLx 版本中以免费升级形式提供，可以实现直接使用 C，C++ 以及 System C 语言规范对赛灵思可编程器件进行编程，无需手动创建 RTL，从而可加速 IP 创建。
用HLS LineBuffer实现2D卷积
qq_40268672的博客
12-21 1650
为了在每个周期都能得到一个3x3的卷积窗口，我们可以通过linebuffer来实现，具体方法为：对于一个KxK的卷积核和一个NxN输入特征图的卷积，我们可以设置K-1个深度为N的FIFO，然后将第i个FIFO的读出连接到第i+1个FIFO的读入端，第0个FIFO的读入则直接从特征图按序获取。下面是HLS的代码实现，为了简单起见，本代码仅支持步长S=1，卷积核大小为K=3的情形，支持任意大小的N（只要不超过LineBuffer的最大深度）： #include<iostream> #include&
HLS：卷积神经网络LeNet5的实现与测试
光年之外
05-27 9709
目录一、引言二、LeNet5的学习三、数学知识补充四、HLS代码设计引言引言 一、引言 1、开发环境。 Windows10、Vivado2018.2、Vivado HLS与Xilinx SDK。 2、LeNet5概述。 1994年，CNN网络，手写字符识别与分类，确立了CNN结构，适合入门。 LeNet5共分为7层： C1，卷积层 S2，池化层 C3，卷积层 S4，池化层 C5，卷积层 F6，全连接层 OUTPUT，全连接层 二、LeNet5的学习 LeNet5每层结构内容的学习。 1°输入层INPU
MobileNet+SSD使用HLS的卷积优化记录
qq_41137205的博客
04-20 934
MobileNet+SSD使用HLS的卷积优化记录 深度卷积单独的优化： 下面是量化之后的使用16bit的定点数进行深度卷积计算的HLS源码： // #include "dep_conv.h" void dep_conv(short bottom[], int Cw, int Hin, int Win, short weight[], int K, int pad, int S, short top[], short bias[]) { Channel_out_num: for(cnum =
HLS函数层面优化
qq_35608277的博客
03-04 1162
1 代码风格 代码风格主要说的就是函数的参数，针对参数要看的就是数据类型。 C++里面定义的数据类型是以 8 为边界的，如 char、short 等，但在实际硬件上可能会遇到任意精度的数据类型。所以如果算法使用到的数据是任意精度那么一定要将其定义为任意精度。 2 Inline 对函数的 inline 就是去除了函数的层次化，可以通过 INLINE 这个 directive 来实现。对函数 inl...
HLS对卷积层优化指令的理解
qq_41137205的博客
04-20 518
在祥瑞Coding的博客中提到了下面的一个例子： // Array Order : 0 1 2 3 4 5 6 7 8 9 10 etc. 16 etc... // Sample Order: A0 B0 C0 D0 E0 F0 G0 H0 A1 B1 C2 etc. A2 etc... // Output Order: A0 B0 C0 D0 E0 F0 G0 H0 A0+A1 B0+B1 C0+C2 etc. A0+A1+A2 etc... #define CHANNELS 8 #define SAMP
FPGA——HLS编程入门
qq_48008050的博客
05-28 8364
目录一、HLS简介二、HLS与VHDL/Verilog三、HLS优点与局限四、入门级的HLS程序（一）官方教程文档（二）新建工程（三）添加源文件（四）添加 C 仿真文件（五）进行 C 仿真（六）进行C综合（七）联合仿真（八）添加 Directive（九）使用Modelsim 打开联合仿真所产生的波形（十）导出IP核参考资料 一、HLS简介 HLS(High Level Synthesis)：一款高层次综合工具。 能够将 C/C++ 或 者 system C 等高级语言转化为 RTL (底层硬件描述语言)
FPGA HLS工具
qq_43628162的博客
11-14 1442
学习视频是哔哩哔哩的赛灵思HLS的官方教程，本博文是上课做的笔记
HLS学习练习1——卷积层（Convolution layer）
u014798590的博客
11-22 1548
0、先验知识 首先，下图所采用得卷积操作，是对边界补0得情况下得到的，卷积的核心在于乘加操作， 关于卷积操作的计算量，可参考此篇文章进行学习 下图的计算量为：输入通道数x输出通道数x卷积核大小x输出图像的长x输出图像的宽 即：RCKKCHout*CHin 1、设置流程 在综合前，需要先进行以下流程的设置 project——》project setting——》synthesis——》Top Function 选择对应的函数 C synthesis 2、卷积的软件实现 优化前的solution1 #def
基于HLS的高效深度卷积神经网络fpga实现方法
04-28
基于HLS的高效深度卷积神经网络FPGA实现方法通常包括以下几个步骤： 1. 数据预处理：将输入数据进行预处理，包括数据归一化、图像增强等。 2. 网络模型设计：设计卷积神经网络模型，包括网络的结构、参数等。 3. HLS代码生成：使用高层次综合（HLS）工具生成FPGA可执行的代码。 4. 硬件平台搭建：搭建FPGA硬件平台，包括硬件开发板、外设等。 5. 数据传输与计算：将预处理后的数据传输到FPGA上进行计算，并将计算结果传输回主机端。 6. 性能优化：针对算法和硬件平台进行优化，提高性能和能耗效率。 需要注意的是，HLS的使用需要熟悉硬件描述语言（HDL）和计算机体系结构等相关知识，因此需要具备一定的技术背景和经验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值