FPGA HLS 基于stream的池化单元 hls优化&约束

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

池化算法设计

image-20221106125127795

将池化操作分为两步horizontal和vertical：

  • 先做横向的池化，将池化结果存下来，传给垂直方向的池化
  • 再做垂直方向的池化

image-20221106125225876

例如一个3*2的池化

先做水平horizontal方向的1*2的池化：

image-20221106125751472

再做垂直vertical方向3*1的池化：

image-20221106125829484

硬件设计

image-20221106140452647

128*128的特征图，需要128*8*16bit = 16k的寄存器，需要寄存器的数量太多

可以用16K的BRAM来实现，从对寄存器的读和写，变为对地址的读和写

stream设计实现

image-20221106141643806

接口设计

  • 用AXI-HP接口：

image-20221106162914670

数组a储存在外部存储器之中，HLS生成的电路会从数组a对应的地址依次读回数据。这样写确实可以实现对数组a的访问，但是很可惜，这些访问在电路实现时采用的是基于AXI-HP协议的单次访问的形式，而不是突发传输，因此总线利用效率极低

  • HLS工具生成的AXI-HP口进行突发传输，只能通过使用memcpy函数：

image-20221106163002652

使用memcpy进行传输，依旧有一定的弊端。首先，这会使对于数组a的访问不再那么灵活，且需要一块内部存储区（数组val）对外部存储器a中的数据进行缓存。其次，memcpy函数依旧无法使用AXI-HP中outstanding的特性，对于DDR这类需要预充电的外部存储器而言，其总线利用效率依旧不高。

  • 基于axi-stream的数据访问是一种比AXI-HP更加高效的方法：

img

一个高效的DMA作为stream的source，而HLS生成的电路作为stream的sink。高效的DMA本身通过AXI-HP接口从外部存储器中获取数据，并通过axi-stream送给HLS生成的运算电路。此方法与之前的方法相比，优势在于电路外部的DMA工作时可以使用axi-hp的burst与outstanding的特性，总线利用效率比使用HLS工具生成的axi-hp接口的效率高出很多。

代码

pool.h

#ifndef __POOL_H__
#define __POOL_H__

#include <iostream>
#include <ap_int.h>
#include <hls_stream.h>

#define K 8
#define POOL_2D_BUF_DEP 512

#define MAX(A, B) ((A>B)?A:B)

typedef ap_int<16> data_type;
typedef ap_int<16*K> tile_type;

typedef struct{
	tile_type data;
	bool last;
}stream_out_type;

void pool(hls::stream<tile_type> &stream_in, hls::stream<stream_out_type> &stream_out,
		ap_uint<16> div_tile_num, ap_uint<16> in_height, ap_uint<16> in_width,
		ap_uint<16> out_height, ap_uint<16> out_width,
		ap_uint<16> padding_x, ap_uint<16> padding_y);

void pool_1D(hls::stream<tile_type> &stream_in, hls::stream<tile_type> &stream_out_1d,
		ap_uint<16> div_tile_num, ap_uint<16> in_height, ap_uint<16> in_width,ap_uint<16> padding_x);

void pool_2D(hls::stream<tile_type> &stream_out_1d, hls::stream<tile_type> &stream_out_2d,
		ap_uint<16> div_tile_num, ap_uint<16> in_height, ap_uint<16> out_width,ap_uint<16> padding_y);

void hs2axis(hls::stream<tile_type> &stream_out_2d, hls::stream<stream_out_type> &stream_out,
		ap_uint<16> div_tile_num,ap_uint<16> out_height, ap_uint<16> out_width);

#endif

pool.cpp

#include "pool.h"


void pool(hls::stream<tile_type> &stream_in, hls::stream<stream_out_type> &stream_out,
		ap_uint<16> div_tile_num, ap_uint<16> in_height, ap_uint<16> in_width,
		ap_uint<16> out_height, ap_uint<16> out_width,
		ap_uint<16> padding_x, ap_uint<16> padding_y)
{

	#pragma HLS INTERFACE s_axilite port = return
	#pragma HLS INTERFACE s_axilite port=div_tile_num
	#pragma HLS INTERFACE s_axilite port=padding_x
	#pragma HLS INTERFACE s_axilite port=in_height
	#pragma HLS INTERFACE s_axilite port=in_width
	#pragma HLS INTERFACE s_axilite port=out_height
	#pragma HLS INTERFACE s_axilite port=padding_y
	#pragma HLS INTERFACE s_axilite port=out_width

	// dataflow 实现任务级并行
	#pragma HLS DATAFLOW
	// 基于axi-stream进行数据访问
	#pragma HLS INTERFACE axis register both port = stream_out
	#pragma HLS INTERFACE axis register both port = stream_in

	hls::stream<tile_type> stream_out_1d;
	#pragma HLS STREAM variable = stream_tp depth = 8 dim = 1

	hls::stream<tile_type> stream_out_2d;

	pool_1D(stream_in, stream_out_1d, div_tile_num, in_height, in_width, padding_x);
	pool_2D(stream_out_1d, stream_out_2d, div_tile_num, in_height, out_width, padding_y);
	hs2axis(stream_out_2d, stream_out, div_tile_num, out_height, out_width);
}

void pool_1D(hls::stream<tile_type> &stream_in, hls::stream<tile_type> &stream_out_1d,
		ap_uint<16> div_tile_num, ap_uint<16> in_height, ap_uint<16> in_width,ap_uint<16> padding_x)
{
	#pragma HLS INTERFACE ap_stable port = in_width
	#pragma HLS INTERFACE ap_stable port = padding_x
	#pragma HLS INTERFACE ap_stable port = in_height
	#pragma HLS INTERFACE ap_stable port = div_tile_num

	tile_type dff;

	for (int c = 0; c < div_tile_num; c++)
	{
		#pragma HLS LOOP_TRIPCOUNT min = 1 max = 1 avg = 1
		for (int i = 0; i < in_height; i++)
		{
			#pragma HLS LOOP_TRIPCOUNT min = 20 max = 20 avg = 20
			for (int j = 0; j < in_width; j++)
			{
				#pragma HLS PIPELINE II = 1
				#pragma HLS LOOP_TRIPCOUNT min = 20 max = 20 avg = 20

				tile_type in_block = stream_in.read();

				tile_type tp_out;

				for (int k = 0; k < K; k++)
				{
					if (j % padding_x == 0) // width_index == 0,3,6,,,,, record first value
						tp_out.range(16 * k + 15, 16 * k) = in_block.range(16 * k + 15, 16 * k);
					else // update value data = max(pre data, now data)
						tp_out.range(16 * k + 15, 16 * k) = MAX((data_type)dff.range(16 * k + 15, 16 * k), (data_type)in_block.range(16 * k + 15, 16 * k));
				}

				if ((j + 1) % padding_x == 0) // if need output：width_index = 2,5,8,,,,
				{
					stream_out_1d.write(tp_out);
					// std::cout<<"pool_1D_out:"<<std::hex<<tp_out<<std::endl;
				}
				else // update max value block
					dff = tp_out;
			}
		}
	}
}

void pool_2D(hls::stream<tile_type> &stream_out_1d, hls::stream<tile_type> &stream_out_2d,
		ap_uint<16> div_tile_num, ap_uint<16> in_height, ap_uint<16> out_width,ap_uint<16> padding_y)
{
	#pragma HLS INTERFACE ap_stable port=div_tile_num
	#pragma HLS INTERFACE ap_stable port=in_height
	#pragma HLS INTERFACE ap_stable port=out_width
	#pragma HLS INTERFACE ap_stable port=padding_y

	static tile_type buf[POOL_2D_BUF_DEP];

	int ptr = 0;

	for (int c = 0; c < div_tile_num; c++)
	{
		#pragma HLS LOOP_TRIPCOUNT min = 1 max = 1 avg = 1
		for (int i = 0; i < in_height; i++)
		{
			#pragma HLS LOOP_TRIPCOUNT min = 20 max = 20 avg = 20
			for (int j = 0; j < out_width; j++)
			{
				//#pragma HLS DEPENDENCE variable=buf inter true
				#pragma HLS PIPELINE
				#pragma HLS LOOP_TRIPCOUNT min = 10 max = 10 avg = 10

				tile_type in_block = stream_out_1d.read();

				tile_type tp_in;
				tile_type tp_out;

				tp_in = buf[j];

				for (int k = 0; k < K; k++)
				{
					if ((i % padding_y) == 0)
						tp_out.range(16 * k + 15, 16 * k) = in_block.range(16 * k + 15, 16 * k);
					else
						tp_out.range(16 * k + 15, 16 * k) = MAX((data_type)tp_in.range(16 * k + 15, 16 * k), (data_type)in_block.range(16 * k + 15, 16 * k));
				}

				if ((i + 1) % padding_y == 0) // if need output
					stream_out_2d.write(tp_out);
				else
					buf[j] = tp_out;
			}
		}
	}
}

void hs2axis(hls::stream<tile_type> &stream_out_2d, hls::stream<stream_out_type> &stream_out,
		ap_uint<16> div_tile_num,ap_uint<16> out_height, ap_uint<16> out_width)
{
	#pragma HLS INTERFACE ap_stable port = out_height
	#pragma HLS INTERFACE ap_stable port = out_width
	#pragma HLS INTERFACE ap_stable port = div_tile_num

	for (int i = 0; i < out_height * out_width * div_tile_num; i++)
	{
	#pragma HLS PIPELINE II = 1
	#pragma HLS LOOP_TRIPCOUNT min = 200 max = 200 avg = 200

		stream_out_type tp;
		tp.data = stream_out_2d.read();
		if (i == ( out_height * out_width * div_tile_num - 1))
			tp.last = 1;
		else
			tp.last = 0;
		stream_out.write(tp);
	}
}

main.cpp

#include "pool.h"
#include <stdio.h>

void pool_soft(hls::stream<tile_type> &in,hls::stream<stream_out_type> &out,
		int ch_div_K,int height_in,int width_in,
		int height_out,int width_out,int Kx,int Ky);

int main(void)
{
	hls::stream<tile_type> in,in_soft;
	hls::stream<stream_out_type> out,out_soft;

	int ch_div_K=4;
	int height_in=4;
	int width_in=4;
	int Kx=2;
	int Ky=2;

	for(int c=0;c<ch_div_K;c++)
	{
		for(int i=0;i<height_in*width_in;i++)
		{
			tile_type tp;
			for(int j=0;j<K;j++)
			{
				if(j==0)
					tp.range(16*j+15,16*j)=rand()%4001-2000;
				else
					tp.range(16*j+15,16*j)=0;
			}
			in.write(tp);
			in_soft.write(tp);
		}
	}

	pool(in,out,ch_div_K,height_in,width_in,height_in/Ky,width_in/Kx,Kx,Ky);
	pool_soft(in_soft,out_soft,ch_div_K,height_in,width_in,height_in/Ky,width_in/Kx,Kx,Ky);

	int flag=1;
	for(int c=0;c<ch_div_K;c++)
	{
		for(int i=0;i<(height_in/Ky)*(width_in/Kx);i++)
		{
			stream_out_type tp=out.read();
			stream_out_type tp_soft=out_soft.read();
			if(tp.data!=tp_soft.data)
			{
				flag=0;
				std::cout<<"out     :"<<i/(width_in/Kx)<<","<<i%(width_in/Kx)<<":\t"<<std::hex<<tp.data<<",last="<<tp.last<<std::endl;
				std::cout<<"out_soft:"<<i/(width_in/Kx)<<","<<i%(width_in/Kx)<<":\t"<<std::hex<<tp_soft.data<<",last="<<tp.last<<std::endl<<std::endl;
			}
		}
	}

	if(flag==1)
		printf("match\n");
	else
		printf("mis-match\n");
}

void pool_soft(hls::stream<tile_type> &in,hls::stream<stream_out_type> &out,
		int ch_div_K,int height_in,int width_in,
		int height_out,int width_out,int Kx,int Ky)
{
	tile_type in_array[10000];
	for(int i=0;i<height_in*height_in*ch_div_K;i++)
		in_array[i]=in.read();

	for(int m=0;m<ch_div_K;m++)
	{
		for(int i=0;i<height_out;i++)
		{
			for(int j=0;j<width_out;j++)
			{
				tile_type tp;
				for(int k=0;k<K;k++)
					tp.range(16*k+15,16*k)=-32768;

				for(int ii=0;ii<Ky;ii++)
					for(int jj=0;jj<Kx;jj++)
					{
						int row=i*Kx+ii;
						int col=j*Ky+jj;
						tile_type dat=in_array[m*width_in*height_in+row*width_in+col];

						for(int k=0;k<K;k++)
							tp.range(16*k+15,16*k)=MAX((data_type)tp.range(16*k+15,16*k),(data_type)dat.range(16*k+15,16*k));
					}
				stream_out_type tp_stream;tp_stream.data=tp;tp_stream.last=0;
				out.write(tp_stream);
			}
		}
	}
}

运行

C仿真：

image-20221106165237082

C综合：

image-20221106165344226

image-20221106165458902

这里用了四个BRAM，是因为需要存的数据是512*(K=8)*16 = 64K/18K向上取整= 4*18K

image-20221106165357671

xiongyuqing
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Intel FPGA的HLS应用.pdf
09-06
1、HLS基本知识介绍 1 1.1HLS简介 1 1.2 Intel HLS的编译器 1 1.3 x86仿真 2 1.4联合仿真 5 1.5 HTML报告 8 1.6默认的接口 10 1.7查看仿真波形 11 1.8 Intel Quartus 软件集成 11 2、HLS模块的接口 13 2.1Avalon接口 13 2.2模块调用接口 14 2.3流接口 18 2.4从接口 22 3、循环的并行化 25 3.1循环的执行 26 3.2循环流水分析 28 3.3循环展开 29 3.4展开参数因子 31 3.5循环展开的HTML报告 31 4、数据类型的优化 33 4.1AC数据类型 33 4.2在Intel HLS 编译器里使用ac-int 33 4.3整数进位的举例 35 4.4浮点编译优化 36 4.5其他数据类型和数学考虑 38 4.6算术开发的考虑 39
XILINX7 系列FPGA HLS入门.pdf
12-01
XILINX7 系列FPGA HLS入门
浅析点直播流媒体传输协议之 —— HLS（HTTP Live Streaming）
qingkongyeyue的博客
08-09 2151
转自http://blog.csdn.net/phachon/article/details/52524596 版权声明：本文为博主原创文章，未经博主允许不得转载。 目录(?)[+] 点直播流媒体传输协议之 —— HLS（HTTP Live Streaming） HLSTSM3u8 在最近一年的工作中接触比较多的是视频点播和直播
HLS（HTTP Live Streaming）协议浅析
菜鸟博客
03-19 6734
​HLS（HTTP Live Streaming）是苹果公司基于HTTP提出来的一种自适应码率的流媒体传输协议，编号RFC8216​，它的主要内容由HTTP + M3U8 + TS这三个部分共同组成。
HLS 流传输库hls::stream
jerwey的博客
08-14 1万+
hls::stream 类仅限在 C++ 设计中使用。不支持流传输数组。 hls::stream&lt;float&gt; data_istrm; hls::stream&lt;bool&gt; e_data_istrm;
FPGA HLS 卷积单元 vivado电路综合与zynq主机测试
xiongyuqing的博客
11-05 546
给函数参数添加axilite控制端口 Export RTL 生成IP核 新建Vivado工程，导入IP核 开两个HP口用于控制和数据的传输：控制端口AXILite AXI_F和AXI_W用HP口相连，注意要选new AXI Inerconnect：包装，生成product，然后生成bit流文件 zynq 主机程序
如何理解HLS中的Stream
qq_62199813的博客
05-17 275
从流中读取数据或向流中写入数据都是顺序进行的，这意味着数据只能从流中读取一次，不能反复读取，这与第一个特征相吻合；的流用于内部函数之间的数据传递，那么该接口最终被综合为一个深度为。关于HLS Stream Library。的流为顶层函数接口，最终该接口会被综合为。需要说明的是hls::stream<>的行为类似于一个深度无限大。用于流数据的算法建模。是类模板，故只可用于。，因此，并不需要定义。
FPGA HLS stream与dataflow
xiongyuqing的博客
11-06 1519
这是因为没有深度约束，深度默认为1，但是这是数据流风格的，所以可以写一个数据，取一个数据，模块依然可以正常工作。这里的模块是等两个送一个，所以把之前的10000深度，设置为4也可以，不耗费啥资源。也就是说我们stream_tmp的长度不够，因为我们需要写两个数据，取一个数据。但是这是不合理的，中间的流很长，但是我们只需要每取两个数据，计算一次写一次数据。那么中间流的16的深度就不够用，需要设置为10000。part1的波形图，确实是读一个写一 个。就算去掉深度的约束，C综合结果也可以过。
hls优化指令
僧哥叨叨叨
10-21 527
优化指令 pipiline、dataflow等
Xilinx_HLS开发——FPGA学习笔记＜?＞
qq_32971095的博客
10-14 728
FPGA 设计过程中的不同抽象层级:其中最底层的抽象（结构性的）涉及到对底层硬件单元直接的例化，比如逻辑门，甚至是更 底层的 LUT 或者触发器。设计者更常用的是在“寄存器传输级（Register Transfer Level，RTL）”进行设计， 这个层级的抽象隐藏了底层的细节，是在描述寄存器和寄存器之间可执行的操作。更上层的“行为性的” 描述是对电路的算法描述，也就是描述电路表现出什么样的功能（行为），而不是描述每个寄存器该如何进行操作。
基于PYNQ实现LeNet（4）HLS约束及优化
m0_56090952的博客
03-24 591
使用PIPELINE和UNROLL并行计算后，工程所消耗的周期会大大降低，而工程所消耗的资源量会提高，这就要求我们在资源和时间中取得平衡，在使用这些优化过程中，对代码也有一定要求，有些代码添加优化后并不能得到想要的结果，甚至与没有添加优化的代码综合结果一样，这就需要改写代码或者使用其他优化方法。接下来是接口相关的约束，数据和模块的INTERFACE。还有数据的读取接口，选择m_axi，depth是数据的个数，port是数据，offest设置为slave，bundle为接口名称可自行设置。
ThunderGP:FPGA上基于HLS的图处理框架
05-16
ThunderGP：FPGA上基于HLS的图形处理框架什么是新的？ ThunderGP在获得第三名，在79个团队中排名前9。 ThunderGP被接受为 。 阅读 。 包含ThunderGP。 在。 请参阅， ， 。介绍ThunderGP使数据科学家能够在不影响可...
gemm_hls:在Xilinx FPGA的Vivado HLS中实现的基于可伸缩脉动阵列的矩阵矩阵乘法
05-06
该存储库包括用于Xilinx FPGA的矩阵矩阵乘法（A * B = C）的纯Vivado HLS实现，使用Xilinx Vitis / SDx / SDAccel实例化内存和PCIe控制器并与主机接口。 在上进行的实验实现了一半，单精度和双精度的462 GFLOP / s...
HLS实现矩阵乘法，并且不同约束优化
03-29
HLS实现矩阵乘法，并且在不同约束下综合成为不同的电路，不同的速度；使用HLS优化RTL电路 CNN的卷积被实现为IPcore的基本实现文件
HLS 协议入门指南以及延迟优化策略
m0_60259116的博客
04-20 2883
HLS是什么 HLS是HTTP Live Streaming 的缩写，是由苹果公司推出的基于HTTP的能自适应的流媒体传输协议，常用于直播和点播。 HLS 的工作原理是当推流端把视频流推到服务端后，服务端会把视频流切割成一个个小的媒体文件（一般是ts文件，也有可能是fmp4文件）。然后服务器会把这些媒体文件的播放地址按照播放顺序罗列到一个索引文件当中，供客户端查找可以的媒体流。这个索引文件也就是我们平时在播放hls视频的时候，最常见到的m3u8文件。 码率自适应 为了能够适应观众的不同网络环境，
流媒体之HLS详解
热门推荐
技术控的笔记
01-11 21万+
HLS（HTTP Live streaming），是基于HTTP的流媒体传输协议，由apple公司所提出的一种由于传输音视频的协议交互方式，当前HLS被广泛应用于视频点直播领域。HLS采用HTTP协议传输音视频数据，HLS通过将音视频流切割成一个个小的TS切片及生成m3u8的播放列表文件，播放客户端通过HTTP协议下载播放列表文件，按照播放列表文件制定的顺序下载切片文件并播放，从而实现便下载边播放，类似于实时在线播放的效果。
网络流媒体（五）———HLS
yangguoyu8023的博客
08-04 1444
1. 简介 HLS(HTTP Live Streaming)是苹果公司提出的基于HTTP的流媒体网络传输协议。HLS把整个流分成一个个小的基于 HTTP 的文件来下载，每次只下载一些。HLS 协议由三部分组成：HTTP、M3U8、TS。这三部分中，HTTP 是传输协议，M3U8 是索引文件，TS 是音视频的媒体信息。类似于MPEG-DASH，但是HLS更加简洁，它的基本原理也是...
Vivado HLS加速卷积层运算
qq_37719487的博客
12-04 6216
源代码 1.Introduction 卷积神经网络（CNN）主要有卷积层、池化层、全连接层和激活层等网络层顺序连接而成。本文主要针对计算密集型的卷积层，利用Vivado HLS工具对其在FPGA上的执行进行加速。 2.Basic knowledge 一个基本的卷积运算由6层for循环实现，如下面代码所示。从外到里的循环依次是K*K大小的卷积核，输出特征图的行列(Tr,Tc)，输出通道数(Tout)，输入通道数(Tin) Kernel_Row: for(int kr=0;kr&lt;K;kr++) { Ke
FPGA 入门 —— HLS 入门
ppqppl的博客
05-13 1392
FPGA 入门 —— HLS 本片文章主要介绍 Xilinx 的 HLS HLS 简介 Vivado HLS 是 Xilinx 公司 2010 年收购 AutoESL 以后重新打造的高层次综合工具，它可以让用户通过添加适当的 directives(制导语句) 和 constrains(约束), 将其 C/C++/System C 代码直接转换成 FPGA RTL( Verilog, VHDL, ...
xilinx fpga hls例程
最新发布
01-31
Xilinx FPGA HLS（High Level Synthesis）是一种将高级语言编程转换为硬件描述语言的工具，通过HLS可以更快速地实现FPGA设计。Xilinx FPGA HLS例程是指使用Xilinx FPGA HLS工具编写的示例程序。这些例程通常包括了如何使用HLS工具将高级语言编写的算法转换为硬件描述语言，并将其实现在FPGA芯片上的步骤和方法。 Xilinx FPGA HLS例程可以帮助开发者更好地理解如何使用HLS工具进行FPGA设计，以及如何利用高级语言的特性来加速FPGA设计的过程。通过参考这些例程，开发者可以学习到如何编写高级语言代码来描述硬件行为，并将其转换为硬件描述语言，然后在FPGA芯片上实现。 通过学习Xilinx FPGA HLS例程，开发者可以更快速地掌握HLS工具的使用方法，加快FPGA设计的开发周期。此外，通过对比不同的例程，开发者还可以学习到不同的优化方法和技巧，从而提高自己的FPGA设计能力。 总之，Xilinx FPGA HLS例程是一个非常有价值的学习资源，可以帮助开发者更好地了解和掌握如何使用HLS工具进行FPGA设计，并加速自己的学习和开发过程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值