vivado HLS实例----实现AWB

最新推荐文章于 2023-12-19 14:59:03 发布
最新推荐文章于 2023-12-19 14:59:03 发布
阅读量460 收藏
点赞数
文章标签： fpga开发 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiXi_happy/article/details/127627493
版权

通过实现一个基础算法，熟悉vivadoHLS操作步骤，同时理解串行转并行的思维

文章目录

vivado HLS实例----实现AWB

一、AWB工程代码

1.ReadFile.h

        2.stream_awb_head.h

3.stream_awb_top.cpp

4.stream_awb_tb.cpp

二、添加Directive

三、实例工程分析

1.在for循环中加pipeline的同时，谨慎添加rewinding

2.串行转并行。

3.最后波形图

总结

vivado HLS实例----实现AWB

通过实现一个基础算法，熟悉vivadoHLS操作步骤，同时理解串行转并行的思维

一、AWB工程代码

1.ReadFile.h

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

using std::cerr;
using std::cout;
using std::setw;
using std::setfill;
using std::ifstream;
using namespace std;

//using namespace hls;
//typedef ap_uint<128> img_rgb;
//typedef stream<img_rgb> img_rgb_stream;
//hls::stream<my_uint128_t>
template <int N, typename Tn>
void ReadFilaeVec(char * fp, Tn &Img_rgb_stream)
{
	int i;
	int val;

	ifstream fp_strmi(fp);//fp is file mode
	if (!fp_strmi.is_open())
	{
		cerr << "Error!\n The file is not albe to open!\n";

	}
	else
	{

		for (i = 0; i < N; i++) // N= w*h*ch
		{
			fp_strmi >> val;
			//			*pOutBuf = val;
			Img_rgb_stream << val;
			//			pOutBuf++;

		}
	}
	fp_strmi.close();
	//cout << setw(60) << setfill('-') << '----'<<'\n';
	cout << "Read file successfully\n";
	//cout << setw(60) << setfill('-') << '-----'<<'\n';
}

2.stream_awb_head.h

#include <ap_int.h>
#include <ap_fixed.h>
#include <hls_stream.h>
using namespace hls;
typedef ap_uint<10> img_rgb;
typedef stream<img_rgb> stream_rgb;
//stream_rgb in_rgb_stream;
//stream_rgb out_rgb_stream;
#define IMAGE_WIDTH 100
#define IMAGE_HEIGHT 100
#define IMAGE_CHANNEL 3
#define IMAGE_WINSIZE (IMAGE_WIDTH * IMAGE_HEIGHT)
#define IMAGE_SIZE (IMAGE_WINSIZE * IMAGE_CHANNEL)
#define W  35
#define I  23
typedef ap_ufixed<W,I> img_cef;
//ap_ufixed<W,I> img_cef = 0;

//img_rgb M = img_rgb(255);
//img_cef T = (img_cef)(256);
//
//img_cef g_coefr = (img_cef)(1);
//img_cef g_coefg = (img_cef)(1);
//img_cef g_coefb = (img_cef)(1);

typedef unsigned char U8;
void balance_white_top(stream_rgb &in_rgb_stream, stream_rgb &out_rgb_stream,
		img_cef &g_kr,img_cef &g_kg,img_cef &g_kb);

//void balance_white_top(U8 img_r[IMAGE_WINSIZE], U8 img_g[IMAGE_WINSIZE], U8 img_b[IMAGE_WINSIZE]);

3.stream_awb_top.cpp

#include<fstream>
#include <iomanip>
#include<fstream>
#include<iostream>
#include <ap_fixed.h>
#include "stream_awb_head.h"
img_cef W_div = 1.0 / 3.0;

//img_cef coefr, coefg, coefb;
//static float W_div = 1.0 / 3.0;

img_rgb M = img_rgb(255);
img_cef T = (img_cef)(256);
img_cef g_coefr = (img_cef)(1);
img_cef g_coefg = (img_cef)(1);
img_cef g_coefb = (img_cef)(1);

void Addfunnction(img_rgb &val, img_cef coef, img_cef &K){
	img_cef valNew;
	//float K_img = 0;
	img_rgb val_rgb = val;

	K += val_rgb;
	//更新像素
	valNew = ((img_cef)(val_rgb) * coef);
	val = (valNew >= T) ? M : (img_rgb)(valNew);
}

void balance_white_top(
		stream_rgb &in_rgb_stream,
		stream_rgb &out_rgb_stream,
		img_cef &g_kr,img_cef &g_kg,img_cef &g_kb
		) {
	img_cef K = 0;
	img_cef Kr = 0;
	img_cef Kg = 0;
	img_cef Kb = 0;

//	img_cef coefr = g_coefr;
//	img_cef coefg = g_coefg;
//	img_cef coefb = g_coefb;
	//U8 valr, valg, valb;
	//img_rgb valr_r, valg_g, valb_b;
	//img_rgb valNewr, valNewg, valNewb;

	img_rgb valR;
	img_rgb valG;
	img_rgb valB;
	img_rgb img_r[IMAGE_WINSIZE] = { 0 };
	img_rgb img_g[IMAGE_WINSIZE] = { 0 };
	img_rgb img_b[IMAGE_WINSIZE] = { 0 };

//	g_kr = g_coefr;


loop1:
	for (int i = 0; i < IMAGE_WINSIZE; i++) {
		in_rgb_stream >> valR;
		in_rgb_stream >> valG;
		in_rgb_stream >> valB;

	block1:
		{
			Addfunnction(valR, g_coefr, Kr);
			Addfunnction(valG, g_coefg, Kg);
			Addfunnction(valB, g_coefb, Kb);
		}

		img_r[i] = valR;
		img_g[i] = valG;
		img_b[i] = valB;

		out_rgb_stream << img_r[i];
		out_rgb_stream << img_g[i];
		out_rgb_stream << img_b[i];


//		out_rgb_stream << valR;
//		out_rgb_stream << valG;
//		out_rgb_stream << valB;
	}
//		K = Kr + Kg + Kb;
//		K = K * W_div;
	K = (Kr + Kg + Kb) * W_div;

//block2:
//	{
	g_coefr = K / Kr;
	g_coefg = K / Kg;
	g_coefb = K / Kb;
	//}
//	g_coefr = coefr;
//	g_coefg = coefg;
//	g_coefb = coefb;

//	g_kr = g_coefr;
//	g_kg = g_coefg;
//	g_kb = g_coefb;

}

//第三版
//#include<fstream>
//#include <iomanip>
//#include<fstream>
//#include<iostream>
//
//#include "stream_awb_head.h"
//img_rgb M = 255;
//img_rgb T = 256;
//float coefr, coefg, coefb;
//static float W_div = 1.0 / 3.0;
//float g_coefr = 0;
//float g_coefg = 0;
//float g_coefb = 0;
//
//void Addfunnction(img_rgb *val, float coef, float *K){
//	img_rgb valNew;
//	//	U8 *p = img;
//	float K_img = 0;
loop2:
	for (int i = 0; i < IMAGE_WINSIZE; i++) {
		val = img[i];
//		//更新像素
//		valNew = *val * coef;
//		*val = (valNew >= T) ? M : valNew;
//
//		K_img += (float)(*val);
//		//out_rgb << img[i];
	}
//	//	//	return  K_img;
//	*K = K_img;
//}
//
//void balance_white_top(stream_rgb &in_rgb_stream, stream_rgb &out_rgb_stream) {
//	float K = 0;
//	float Kr = 0;
//	float Kg = 0;
//	float Kb = 0;
//
//	float coefr = g_coefr;
//	float coefg = g_coefg;
//	float coefb = g_coefb;
//	//U8 valr, valg, valb;
//	img_rgb valr_r, valg_g, valb_b;
//
//	img_rgb valNewr, valNewg, valNewb;
//
//
//	img_rgb valR;
//	img_rgb valG;
//	img_rgb valB;
//	img_rgb img_r[IMAGE_WINSIZE] = { 0 };
//	img_rgb img_g[IMAGE_WINSIZE] = { 0 };
//	img_rgb img_b[IMAGE_WINSIZE] = { 0 };
//
//loop1:
//	for (int i = 0; i < IMAGE_WINSIZE; i++) {
//		in_rgb_stream >> valR;
//		in_rgb_stream >> valG;
//		in_rgb_stream >> valB;
//
		img_r[i] = valR;
		img_g[i] = valG;
		img_b[i] = valB;
//
//
//	block1:
//		{
//		Addfunnction(&valR, coefr, &Kr);
//		Addfunnction(&valG, coefg, &Kg);
//		Addfunnction(&valB, coefb, &Kb);
//		}
//		out_rgb_stream << valR;
//		out_rgb_stream << valG;
//		out_rgb_stream << valB;
//
//		K = (Kr + Kg + Kb) * W_div;
//
//	block2:
//		{
//			coefr = K / Kr;
//			coefg = K / Kg;
//			coefb = K / Kb;
//		}
//		g_coefr = coefr;
//		g_coefg = coefg;
//		g_coefb = coefb;
//
//	}
//
//}

//第二版
//#include<fstream>
//#include <iomanip>
//#include<fstream>
//#include<iostream>
//
//#include "stream_awb_head.h"
//img_rgb M = 255;
//img_rgb T = 256;
//float coefr, coefg, coefb;
//static float W_div = 1.0 / 3.0;
//float g_coefr = 0;
//float g_coefg = 0;
//float g_coefb = 0;
//
//void Addfunnction(img_rgb img[IMAGE_WINSIZE], float coef, float *K){
//	img_rgb val;
//	img_rgb valNew;
//	//	U8 *p = img;
//	float K_img = 0;
//loop2:
//	for (int i = 0; i < IMAGE_WINSIZE; i++) {
//		val = img[i];
//		//更新像素
//		valNew = val * coef;
//		img[i] = (valNew >= T) ? M : valNew;
//
//		K_img += (float)(val);
//		//out_rgb << img[i];
//	}
//	//	//	return  K_img;
//	*K = K_img;
//}
//
//void balance_white_top(stream_rgb &in_rgb_stream, stream_rgb &out_rgb_stream) {
//	float K = 0;
//	float Kr = 0;
//	float Kg = 0;
//	float Kb = 0;
//
//	float coefr = g_coefr;
//	float coefg = g_coefg;
//	float coefb = g_coefb;
//	//U8 valr, valg, valb;
//	img_rgb valr_r, valg_g, valb_b;
//
//	img_rgb valNewr, valNewg, valNewb;
//
//
//	img_rgb valR;
//	img_rgb valG;
//	img_rgb valB;
//	img_rgb img_r[IMAGE_WINSIZE] = { 0 };
//	img_rgb img_g[IMAGE_WINSIZE] = { 0 };
//	img_rgb img_b[IMAGE_WINSIZE] = { 0 };
//
//loop1:
//	for (int i = 0; i < IMAGE_WINSIZE; i++) {
//		in_rgb_stream >> valR;
//		in_rgb_stream >> valG;
//		in_rgb_stream >> valB;
//
//		img_r[i] = valR;
//		img_g[i] = valG;
//		img_b[i] = valB;
//
//	}
//block1:
//	{
//	Addfunnction(img_r, coefr, &Kr);
//	Addfunnction(img_g, coefg, &Kg);
//	Addfunnction(img_b, coefb, &Kb);
//	}
//	K = (Kr + Kg + Kb) * W_div;
//
//block2:
//	{
//		coefr = K / Kr;
//		coefg = K / Kg;
//		coefb = K / Kb;
//	}
//	g_coefr = coefr;
//	g_coefg = coefg;
//	g_coefb = coefb;
//	loop3:
//	for (int i = 0; i < IMAGE_WINSIZE; i++) {
//		out_rgb_stream << img_r[i];
//		out_rgb_stream << img_g[i];
//		out_rgb_stream << img_b[i];
//	}
//
//}


//第一版
//void balance_white_top(stream_rgb &in_rgb_stream, stream_rgb &out_rgb_stream) {
//	float K = 0;
//	float Kr = 0;
//	float Kg = 0;
//	float Kb = 0;
//
//	float coefr = g_coefr;
//	float coefg = g_coefg;
//	float coefb = g_coefb;
//	//U8 valr, valg, valb;
//	img_rgb valr_r, valg_g, valb_b;
//
//	img_rgb valNewr, valNewg, valNewb;
//
//
//	img_rgb valR ;
//	img_rgb valG ;
//	img_rgb valB ;
	img_rgb img_r[IMAGE_WINSIZE] = { 0 };
	img_rgb img_g[IMAGE_WINSIZE] = { 0 };
	img_rgb img_b[IMAGE_WINSIZE] = { 0 };
//
//	loop1:
//	for (int i = 0; i < IMAGE_WINSIZE; i++) {
//		in_rgb_stream >> valR;
//		in_rgb_stream >> valG;
//		in_rgb_stream >> valB;
//
		Addfunnction(img_r, coefr, &Kr, &valr_r);
		Addfunnction(img_g, coefg, &Kg, &valg_g);
		Addfunnction(img_b, coefb, &Kb, &valb_b);
		img_r[i] = valR;
		img_g[i] = valG;
		img_b[i] = valB;
//
//		Kr += (float)(valR);
//		Kg += (float)(valG);
//		Kb += (float)(valB);
//
//		//更新像素
//		valNewr = valR * coefr;
//		valNewg = valG * coefg;
//		valNewb = valB * coefb;
//
//		valr_r = (valNewr >= T) ? M : valNewr;
//		valg_g = (valNewg >= T) ? M : valNewg;
//		valb_b = (valNewb >= T) ? M : valNewb;
		valr_r = (valNewr >= (img_rgb)(256)) ? (img_rgb)(255) : valNewr;
		valg_g = (valNewg >= (img_rgb)(256)) ? (img_rgb)(255) : valNewg;
		valb_b = (valNewb >= (img_rgb)(256)) ? (img_rgb)(255) : valNewb;
//
//		out_rgb_stream << valr_r;
//		out_rgb_stream << valg_g;
//		out_rgb_stream << valb_b;
		/*img_r[i] = valr_r;
		img_g[i] = valg_g;
		img_b[i] = valb_b;*/

//	}
//
//	K = (Kr + Kg + Kb) * W_div;
//
//	block2:
//	{
//		coefr = K / Kr;
//		coefg = K / Kg;
//		coefb = K / Kb;
//	}
//	g_coefr = coefr;
//	g_coefg = coefg;
//	g_coefb = coefb;
//
//}



//float Addfunnction(img_rgb val, float coef, float *K,img_rgb *val_l){
//
//	img_rgb valNew;
//	int K_img = 0;
//
loop:
	for (int i = 0; i < IMAGE_WINSIZE; i++) {
//		//val = img[i];
//		//更新像素
//		valNew = val * coef;
//		*val_l = (valNew >= T) ? M : valNew;
//		//out_rgb_stream << val_l;
//		K_img += (float)(val);
//	//}
//	//	return  K_img;
//	*K = K_img;
//}

4.stream_awb_tb.cpp

#include <typeinfo>
#include <iostream>
#include <iomanip>
#include "ReadFile.h"
#include "stream_awb_head.h"
//#include <ap_uint.h>
//#include <hls_stream.h>

//#include <opencv2/opencv.hpp>
//using namespace cv;


int main(){

	//U8 img[IMAGE_WINSIZE] = { 0 };

	//img_rgb Ref[IMAGE_WINSIZE] = { 0 };
	img_cef kr,kg,kb;


	char *fa = "E:/HLS/vsproj/AWB_formal/AWB_formal/3chn.txt";

	char *fp_ref = "E:/HLS/vsproj/AWB_formal/AWB_formal/3chn_ofter.txt";
	//char *fp_ref = "C:/Users/11693/Desktop/ref_file.txt";

	//	typedef ap_uint<128> img_rgb;
	stream_rgb in_img_rgb_stream;
	stream_rgb out_rgb_stream1;
	stream_rgb out_rgb_stream_full;
	stream_rgb refimg_rgb_stream;
	//	stream

	ReadFilaeVec<IMAGE_SIZE, stream_rgb>(fa, in_img_rgb_stream);
	ReadFilaeVec<IMAGE_SIZE, stream_rgb>(fp_ref, refimg_rgb_stream);

	unsigned int i = 0;
	unsigned int errcnt = 0;
	//第一帧
	balance_white_top(in_img_rgb_stream, out_rgb_stream1, kr, kg, kb);
	cout << "kr= " << kr << '\n';//探针
	cout << "kg= " << kg << '\n';//探针
	cout << "kb= " << kb << '\n';//探针

	//第二帧
	ReadFilaeVec<IMAGE_SIZE, stream_rgb>(fa, in_img_rgb_stream);
	balance_white_top(in_img_rgb_stream, out_rgb_stream_full, kr, kg, kb);
	cout << "kr= " << kr << '\n';//探针
	cout << "kg= " << kg << '\n';//探针
	cout << "kb= " << kb << '\n';//探针

	//typedef ap_uint<32> img_rgb;
	img_rgb Ref_val;
	img_rgb out_val;

	int Ref_val_U8;
	int out_val_U8;

	for (i = 0; i< IMAGE_SIZE; i++){
		refimg_rgb_stream >> Ref_val;
		out_rgb_stream_full >> out_val;
		Ref_val_U8 = (int)(Ref_val);
		out_val_U8 = (int)(out_val);
		if (abs(Ref_val_U8 - out_val_U8) > 1.0 ){
			errcnt++;
			cout << "i= " << i << " ----------";
//			cout << "img[1]= " << img[i] << " ----------";
			cout << "out_val= " << out_val << " ----------";
			cout << "Ref_val= " << Ref_val << '\n';
			break;
		}
	}
//	cout << "kr= " << kr << '\n'; //探针
//	cout << "kg= " << kg << '\n';//探针
//	cout << "kb= " << kb << '\n';//探针

	if (errcnt>0){
		cout << "Test with " << errcnt << " error";
//		system("pause");
		return 1;
	}
	else{
		cout << "Test Pass";
//		system("pause");
		return 0;
	}

}

二、添加Directive

在stream_awb_top.cpp文件中添加directive

loop1:
	for (int i = 0; i < IMAGE_WINSIZE; i++) {
#pragma HLS PIPELINE
		in_rgb_stream >> valR;
		in_rgb_stream >> valG;
		in_rgb_stream >> valB;

	block1:
		{
#pragma HLS ALLOCATION instances=Addfunction limit=3 function
			Addfunnction(valR, g_coefr, Kr);
			Addfunnction(valG, g_coefg, Kg);
			Addfunnction(valB, g_coefb, Kb);
		}

三、实例工程分析

1.在for循环中加pipeline的同时，谨慎添加rewinding

 添加rewinding会导致全局变量失效，g_coefr、g_coefg、g_coefb不会随着Addfunnction函数调用发生改变

2.串行转并行。

stream_awb_top.cpp文件中第一版、第二版、第三版都是串行

当前一帧的像素值使用上一帧的更新的g_coefr、g_coefg、g_coefb参数值。舍弃第一帧，只用第一帧的像素值只用于更新g_coefr、g_coefg、g_coefb参数值。

3.最后波形图

 

 

总结

  • HLS很重要的是串行转并行的思想
XiXi_happy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Vivado HLS 二：fir简单例子结果详解
weixin_50988214的博客
03-29 1213
Vivado HLS 二：fir简单例子结果详解 感谢FPGA那点事儿公众号，提供了很多入门知识！ 本文参考自：https://mp.weixin.qq.com/s/Si3CdIGwPW86lIzPiE6w4g 目录： 一、代码 二、结果分析 1、综合后的代码： 2、资源消耗 3、延迟 HLS为Xilinx近几年推出的高级综合工具，能够把C/C++代码转化为可综合的verilog/VHDL代码。 下面用数字滤波器fir的例子，解释代码和具体参数。 一、代码...
Vivado-hls使用实例－详细教程
热门推荐
塔克拉玛与大兴安岭的博客
04-21 2万+
【引言】 本系列教程演示如何使用xilinx的HLS工具进行算法的硬件加速。 分为三个部分，分别为HLS端IP设计，vivado硬件环境搭建，SDK端软件控制。 在HLS端，要将进行硬件加速的软件算法转换为RTL级电路，生成便于嵌入式使用的axi控制端口，进行数据的传输和模块的控制。 工程源码 【HLS介绍】 HLS可以将算法直接映射为RTL电路，实现了高层次综合。vivado-HLS可以实现直接...
FPGA开发之Vivado安装及HLS环境配置，并实现流水灯实例
qq_54347584的博客
05-22 3909
FPGA学习之HLS
AWB实现流程
羽凌寒
02-17 9946
简介 　　本篇谈论下对AWB算法的调查和预研工作。 内容概述 　　所谓AWB也就是自动白平衡的意思，白平衡在相机中很常见，主要是和色温、色彩还原、色调调整相关。当白平衡设置不佳的时候，常会出现如下这些情况:在日光灯的房间里拍摄的影像会显得发绿，在室内钨丝灯光下拍摄出来的景物就会偏黄等。而awb的作用，就是在相机拍摄的环境色温变化的时候，主动调整白平衡参数，使得相机图像不因为环境色温变化
AWB学习笔记
09-14
关于手机camera方面的AWB学习笔记，主要讲述GC0329的AWB
ug1197-vivado-high-level-productivity
11-02
Vivado HLS（High-Level Synthesis）是一种高层次综合工具，用于将高级语言（如C/C++）编写的算法转换为RTL（Register Transfer Level）代码，以便在FPGA或ASIC上实现高速执行。UG1197是Xilinx官方提供的一份指南，...
vivado-boards-master.zip
03-29
"vivado-boards-master.zip" 文件就是针对这个需求提供的一项资源，它包含了Vivado对于各种开发板的支持信息。 **标题解析：** "vivado-boards-master.zip" 是一个包含Vivado开发板定义的压缩文件。"master"通常...
vivado-hls-broadcast-optimization:[DAC 2020]分析和优化FPGA HLS中的隐式广播以提高最大频率
05-10
此存储库可以在以下方面为您提供帮助： 更好地了解由Vivado HLS生成的看似凌乱的RTL，这对于希望手动破解RTL的专家用户将是有益的。 正确的编码样式可导致设计具有良好的时序质量。 用于优化数据流设计中管道
ug902-vivado-high-level-synthesis（中文）.pdf
08-09
ug902-vivado-high-level-synthesis（中文）、HLS学习必备开发文档
ug894-vivado-tcl-scripting.pdf
07-31
综上所述，UG894-vivado-tcl-scripting.pdf是一份非常全面的文档，它不仅覆盖了TCL脚本的基本用法，还深入探讨了许多高级主题，为用户提供了丰富的参考资料和实用技巧。对于希望在Vivado环境中利用TCL进行自动化设计...
自动白平衡算法Awb原代码
11-17
自动白平衡算法Awb原代码,针对相机行业软件人员学习
自动白平衡AWB算法 基于DTM PRA GWA的matlab代码
12-06
自动白平衡AWB算法 基于DTM PRA GWA方法的matlab代码
vivado hls 输出监制与格式控制
weixin_41967965的博客
08-26 853
输出格式控制。主要用于控制如何显示结果同时显示辅助信息。下图是用于理解left、right、internal的功能和区别。   整数的输出控制。 bitset(val):将val使用N位二进制格式输出 oct：使用八进制格式输出； dec：使用十进制格式输出，缺省情况下为十进制； hex：使用十六进制格式输出。 val.to_string(N).c_str():将val按N进制格...
vivado hls学习笔记-测试文件输出打印
最新发布
z529904088的博客
12-19 571
用于vivado hls的测试用例，打印输出文件，以上可用于测试文件中的数据输出推荐使用。来输出数据，能够更好的保证浮点数精度。
Vivado HLS循环语句优化
XiXi_happy的博客
10-11 504
谨慎使用rewind。在directive中添加pipeline并且执行rewind操作，代码在运行中会出现全局变量数值更新错位的情况，无法在HLS中成功生成波形图。在添加pipeline后先完整跑一边代码，执行成功后，若有需要再在pipeline中添加rewind操作，谨慎执行rewind操作。
vivado HLS c平台文件输入测试实例
weixin_41967965的博客
08-26 2750
以下代码为vivado HLS 在进行testbench测试的时候，利用文件读取的方式获取激励的方法   -----------------------------------代码------------------------------------------------------------------------- //-------------------------------...
HLS最全知识库
jk_101的博客
09-18 916
原创 碎碎思OpenFPGA。
vivado hls 命名空间的使用
weixin_50988214的博客
04-26 372
1、可以将这些地址传入，如AXI_STREAM和矩阵。但是还不会将mat类型传入。 函数的声明开始加static，后续无需再实例化。且内部参数仅该函数内可以调用。后续的内联函数为定义。 myfilter2d.hpp #ifndef SRC_HLS_IM_PROC_HPP_ #define SRC_HLS_IM_PROC_HPP_ //#include <stdint.h> //#include <hls_stream.h> //#include <hl..
vivado HLS从实例看优化
wd1603926823的专栏
08-31 1万+
虽然看完了ug902关于vivado HLS优化的内容，但有点囫囵吞枣，所以想从实例去探索如何应用优化指令来达到最大的性能！ 一、第一个实例 #ifndef _XIANGANWO3_H_ #define _XIANGANWO3_H_ #include "hls_video.h" // maximum image size #define MAX_WIDTH 1936 #define MA...
vivadohlsdsp_FPGA硬件加速学习vivado hls-----------------卷积加速
06-01
对于使用 Vivado HLS 进行 FPGA 硬件加速的卷积加速问题，我们可以通过以下步骤实现： 1. 将卷积操作转换为 C/C++ 代码，以便在 Vivado HLS 中进行进一步的优化。 2. 在 Vivado HLS 中使用 pragma 指令进行优化，例如 unroll、pipeline、array_partition 等。 3. 将优化后的 C/C++ 代码传递给 Vivado 编译器进行综合和实现。 4. 在 Vivado 中使用 Block Design 工具将实现的 IP 核集成到系统设计中。 5. 在 SDK 中编写驱动程序，并将其运行在 FPGA 上进行测试。 需要注意的是，卷积操作的优化涉及到许多细节，如数据重用、缓存优化、流水线优化等。因此，在使用 Vivado HLS 进行卷积加速时，需要深入了解硬件加速的原理和 Vivado HLS 工具的使用技巧。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值