2D卷积C/C++实现(高级综合HLS)

2D卷积C/C++实现

void _2DConv(int8_t *in,int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride)
/* 
in:输入图像
out:输出图像
filter:滤波器
nrows:输出图像的行数
ncols:输出图像的列数
k:滤波器大小(k*k)
stride:滤波窗口步进长度
 */

{
uint16_t r,c,i,j;
uint32_t nrows_i=nrows*stride+k-1;//输入图像的行数
uint32_t ncols_i=ncols*stride+k-1;//输入图像的列数

for(r=0;r<nrows;r++)
	{
	for(c=0;c<=ncols;c++)
		{
		for(i=0;i<k;i++)
			{
			for(j=0;j<k;j++)
				{
				uint32_t offset=(r*stride+i)*ncols_i+(c*stride+j);
				int32_t in_tmp=*(in+offset);
				int32_t filter_tmp=*(filter+i*k+j);
				*(out+r*ncols+c)+=in_tmp *filter_tmp;
				}
			}
		}
	}

} 

把代码封装成基于AXI4的形式

void HW_2DConv_Mmap_1(int8_t *pixel_in,int8_t *pixel_out,int32_t addr_reserved)
{
	/*
	AXI4数据总线(m_axi):
	pixel_in用于FPGA加速器主动读取DDR的输入图像和滤波器
	pixel_out用于FPGA加速器主动写入输出结果到DDR中
		
	AXI4Lite控制总线(s_axilite):
		用于输入输出图像访存基地址
	*/
	#pragma HLS INTERFACE m_axi depth =482*272+3*3 port=pixel_in offset=slave bundle=user_axi_in register 
	#pragma HLS INTERFACE m_axi depth =482*270     port=pixel_out offset=slave bundle=user_axi_out register
	
	#pragma HLS INTERFACE s_axilite port=pixel_in bundle=user_axi4lite_config register
	#pragma HLS INTERFACE s_axilite port=pixel_out bundle=user_axi4lite_config register
	#pragma HLS INTERFACE s_axilite port=addr_reserved offset=0xFFF0  bundle=user_axi4lite_config register
	#pragma HLS INTERFACE s_axilite port=return  bundle=user_axi4lite_config register
	
	
	int8_t *filter_base=pixel_in+ROWS_I*COLS_I;
	
	_2DConv(pixel_in,pixel_out,filter_base,ROWS_O,COLS_O,FILTER_SIZE,STRIDE);
}

实现结果的时间和资源

  • 时间(latency):21.25M clock cycles
  • 主要资源开销:1个dsp 84个乘法器
  • 瓶颈:四层迭代 串行运行

里面的两层迭代需要展开
外面的两层迭代需要流水

迭代优化

void _2DConv(int8_t *in,int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride)
{
uint16_t r,c,i,j;
uint32_t nrows_i=nrows*stride+k-1;//输入图像的行数
uint32_t ncols_i=ncols*stride+k-1;//输入图像的列数

for(r=0;r<nrows;r++)
	{
	for(c=0;c<=ncols;c++)
		{
		#pragma HLS PIPELINE II=1//流水
		for(i=0;i<k;i++)
			{
			for(j=0;j<k;j++)
				{
				uint32_t offset=(r*stride+i)*ncols_i+(c*stride+j);
				int32_t in_tmp=*(in+offset);
				int32_t filter_tmp=*(filter+i*k+j);
				*(out+r*ncols+c)+=in_tmp *filter_tmp;
				}
			}
		}
	}

} 	

实现结果的时间和资源

  • 时间(latency):2.33M clock cycles 提高了9倍多
  • 主要资源开销:6个dsp 365个乘法器
  • 瓶颈:目标流水线是1个clock cycles ,但是目前只能达到18个clock cycles,访存瓶颈

访存及核心计算优化

void _2DConv——Op(int8_t *in,int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride)
{
uint16_t r,c,i,j;
uint32_t nrows_i=nrows*stride+k-1;//输入图像的行数
uint32_t ncols_i=ncols*stride+k-1;//输入图像的列数

int8_t *filter_based=in+ROWS_I*COLS_I;

int8_t filter_buffer[FILTER_SIZE][FILTER_SIZE]
//*pragma HLS ARRAY_PARTITION variable=filter_buffer complete dim=0
memcpy (&filter_buffer[0][0],filter_base,FILTER_SIZE*FILTER_SIZE*sizeof(int8_t));//提前将卷积核放到片上


for(r=0;r<nrows;r++)
	{
	for(c=0;c<=ncols;c++)
		{
		#pragma HLS PIPELINE II=1
		int8_t store_data=0;
		for(i=0;i<k;i++)
			{
			for(j=0;j<k;j++)
				{
				uint32_t offset=(r*stride+i)*ncols_i+(c*stride+j);
				int8_t val=*(in+offset);
				int8_t res=0;
				
				if(filter_buffer[i][j]==0)//针对二值卷积核进行优化
					res=0;
				else if(filter_buffer[i][j]==1)
					res=val;
				else if(filter_buffer[i][j]==-1)
					res=-val;
				
				store_data+=res
				*(out+r*ncols+c)+=store_data;
				}
			}
		}
	}

} 	

卷积核缓存到片上ram

实现结果的时间和资源

  • 时间:1.16M clock cycles 提高了18倍多
  • 主要资源开销:0个dsp 365个乘法器
  • 瓶颈:目标流水线是1个clock cycles ,但是目前只能达到9个clock cycles,图片还是从ddr读的

2D卷积操作必须对k*k大小的窗口内的所有像素点进行计算
字节从DDR中取像素进行计算的话,访存延迟大,访存周期不确定,无法实现高效的流水处理

图片数据缓冲到片上

行缓冲(line buffer)
窗口缓冲(windows buffer)

2D卷积C/C++实现(高级综合HLS)_第1张图片

算法硬件结构优化:行缓冲

  • 由于DEMO中filter大小为3*3,因此,建立一个3行的行缓冲,用于缓存当前滤波窗口正在处理的三行像素
  • 行缓冲通过ARRAY_PARTITION指示对二维数组的第一维(行)进行展开,每一维通过独立的片上BRAM实现,支持同时访问不同行中的像素点
template<typename T,int LROW,int LCOL>
class ap_linebuffer{
   public:
   	TM[LROW][LCOL];
   	#pragma AP ARRAY_PARTITION variable=M dim=1 complete
   	ap_linebuffer(){
   		};
}	

算法硬件结构优化:窗口缓冲

  • 建立一个3*3的窗口缓存,通过ARRAY_PARTITION对所有维度进行全部展开,窗口缓存中所有9个元素都由LUT实现,支持同时对所有元素并发访问
  • 算法从DDR读取下一个像素,添加到行缓冲中。同时,行缓冲已经缓存了前两行的像素。通过访问行缓存,正好可以得到当前滤波窗口所在位置的所有像素点,这些像素点存入窗口缓存中,并送到流水线中进行处理。
template<typename T,int LROW,int LCOL>
class ap_window{
   public:
   	TM[LROW][LCOL];
   	#pragma AP ARRAY_PARTITION variable=M dim=1 complete
   	ap_window(){
   		};
}	

完整代码

void _2DConv_Op(int8_t *in,int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride)
{
uint16_t r,c,i,j;
uint32_t nrows_i=nrows*stride+k-1;//输入图像的行数
uint32_t ncols_i=ncols*stride+k-1;//输入图像的列数

int8_t *filter_based=in+ROWS_I*COLS_I;

int8_t filter_buffer[FILTER_SIZE][FILTER_SIZE]
//*pragma HLS ARRAY_PARTITION variable=filter_buffer complete dim=0
memcpy (&filter_buffer[0][0],filter_base,FILTER_SIZE*FILTER_SIZE*sizeof(int8_t));//提前将FILTER_SIZE*FILTER_SIZE个像素放到片上

ap_linebuffer<int8_t,FILTER_SIZE,COLS_I> line_buffer;

ROW_LOOP:for(r=0;r<ROWS_I;r++)
	{
	ap_window<int8_t,FILTER_SIZE,FILTER_SIZE> window_buffer;
	
	//fill the line buffer
	COL_LOOP:for(c=0;c<=COLS_I;c++)
		{
#pragma HLS PIPELINE II=1
		int8_t store_data=0;
		int8_t load_data=*(in_base+r*COLS_I+c);
		
		line_buffer.shift_up(c);
		line_buffer.insert_bottom(load_data,c);//行缓冲,保证数据从DDR里面流水的取出
		
		if(r>=2)
			{
			window_buffer.shift_right();
			window_buffer,insert(line_buffer.getval(2,c),0,2);
			window_buffer,insert(line_buffer.getval(1,c),1,2);
			window_buffer,insert(line_buffer.getval(0,c),2,2);
			}//从行缓冲中获取数据,构建卷积计算的窗口缓冲
		
		if(r>=2&&c>=2)
			{
			for(i=0;i<FILTER_SIZE;i++)
				{
				for(j=0;j<FILTER_SIZE;j++)
					{
					int8_t res=0;
					int8_t val=window_buffer.getval(i,j);//从窗口中获取像素值,进行卷积计算									
					
					if(filter_buffer[i][j]==0)//针对二值卷积核进行优化
						res=0;
					else if(filter_buffer[i][j]==1)
						res=val;
					else if(filter_buffer[i][j]==-1)
						res=-val;
					
					store_data+=res
					
					}
				}
			*(out_base+(r-2)*COLS_O+c(c-2))+=store_data;
			}
		}

	}
	
}	

实现结果的时间和资源

  • 时间(latency):131k clock cycles 提高了164倍多
  • 综合后流水线达到目标流水线要求,1个clock cycles
  • latency 降低到1311143个时钟周期,比优化前降低了约99.5%
  • 理论分析,实现COL_LOOP全流水后,每个时钟周期能完成一个滤波窗口的计算。理论上,总的时钟周期开销约为270*480=129600.最终优化后的131143仅与理论值相差1.1%。

你可能感兴趣的:(FPGA)