C++11:模板实现opencl向量类型(cl_intn,cl_floatn...)的简单运算符(+,-)重载及length,distance函数

已于 2024-01-02 10:56:32 修改
阅读量3.9k 收藏 1
点赞数
分类专栏： c/c++/c++11 opencl 文章标签： opencl c++11 向量运算 运算符重载 模板
于 2016-04-11 15:10:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/10km/article/details/51121642
版权

主机端opencl向量的运算能不能像在内核代码中一样简单？
opencl内核支持的所有向量数据类型(intn,floatn,doublen…)在主机端都有对应的类型，区别是加了前缀cl_,比如int4对应的主机端类型是cl_int4。
我们知道，在opencl内核代码中，向量类型(vector data type)的数据可以像普通标量类型(scala data type)一样，用各种算术和逻辑运算符进行操作。
比如:

int4 p1=int4(4,2,0,9);
int4 p2=int4(3,9,-1,8);
int4 p3=p1+p2;
float length=length(as_float(p1));//计算向量长度

非常方便，有时候，我们也需要在主机端代码中对这种向量类型的数据进行一些处理，但c/c++以及opencl的API本身并没有提供对这些向量类型的一般运算支持。当有项目中有多个地方需要在主机端进行向量数据的运算时，就会比较痛苦。比如上面的两个向量相加，在主机端就要写成这样：

cl_int4 p1={4,2,0,9};
cl_int4 p2={3,9,-1,8};
cl_int4 p3={p1.x+p2.x,p1.y+p2.y,p1.z+p2.z,p1.w+p2.w};
cl_float length=std::sqrt(
	 std::pow(float(p1.x),2)
	+std::pow(float(p1.y),2)
	+std::pow(float(p1.z),2)
	+std::pow(float(p1.w),2));//计算向量长度

这还只是4个元素的向量，如果是16个元素的向量，这代码更长,很容易出错。
如果能像模板内核代码一样，为向量运算符提供简单的向量运算功能，就可以大大简化这些代码。
利用C++的模板计算函数，可以实现上面的功能。下面是实现代码：

#include <type_traits>
// 设置当opencl出错时抛出异常
#ifndef __CL_ENABLE_EXCEPTIONS
#define __CL_ENABLE_EXCEPTIONS
#endif
// gcc 下如果定义了__STRICT_ANSI__，就没办法使用别名访问vector向量类型(cl_int2,cl_float8...)
#if defined( __GNUC__) && defined( __STRICT_ANSI__ )
#define __STRICT_ANSI__DEFINED__
// 删除__STRICT_ANSI__定义
#undef __STRICT_ANSI__
#endif
#include <CL/cl.hpp>
#ifdef __STRICT_ANSI__DEFINED__
#undef __STRICT_ANSI__DEFINED__
// 恢复__STRICT_ANSI__定义
#define __STRICT_ANSI__
#endif
namespace cl{
/* 根据向量元素类型和向量长度返回opencl向量类型，
 * 如 cl_vector_type<2,cl_int>::type 为 cl_int2
 */
template<int SIZE,typename T>
struct cl_vector_type{
	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_char>::value, cl_char2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_char>::value, cl_char4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_char>::value, cl_char8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_char>::value,cl_char16>::type vector_type(_T);

	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_uchar>::value, cl_uchar2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_uchar>::value, cl_uchar4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_uchar>::value, cl_uchar8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_uchar>::value,cl_uchar16>::type vector_type(_T);

	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_short>::value, cl_short2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_short>::value, cl_short4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_short>::value, cl_short8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_short>::value,cl_short16>::type vector_type(_T);

	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_ushort>::value, cl_ushort2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_ushort>::value, cl_ushort4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_ushort>::value, cl_ushort8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_ushort>::value,cl_ushort16>::type vector_type(_T);

	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_int>::value, cl_int2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_int>::value, cl_int4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_int>::value, cl_int8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_int>::value,cl_int16>::type vector_type(_T);

	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_uint>::value, cl_uint2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_uint>::value, cl_uint4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_uint>::value, cl_uint8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_uint>::value,cl_uint16>::type vector_type(_T);
																														
	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_long>::value, cl_long2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_long>::value, cl_long4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_long>::value, cl_long8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_long>::value,cl_long16>::type vector_type(_T);

	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_ulong>::value, cl_ulong2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_ulong>::value, cl_ulong4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_ulong>::value, cl_ulong8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_ulong>::value,cl_ulong16>::type vector_type(_T);
																														  
	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_float>::value, cl_float2>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_float>::value, cl_float4>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_float>::value, cl_float8>::type vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_float>::value,cl_float16>::type vector_type(_T);

	template<int _SIZE,typename _T>static typename std::enable_if< 2== _SIZE&&std::is_same<_T,cl_double>::value, cl_double2>::type  vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 4== _SIZE&&std::is_same<_T,cl_double>::value, cl_double4>::type  vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if< 8== _SIZE&&std::is_same<_T,cl_double>::value, cl_double8>::type  vector_type(_T);
	template<int _SIZE,typename _T>static typename std::enable_if<16== _SIZE&&std::is_same<_T,cl_double>::value,cl_double16>::type  vector_type(_T);

	template<int _SIZE,typename _T>static typename std::enable_if<2!= _SIZE && 4 != _SIZE && 8 != _SIZE &&16 != _SIZE>::type vector_type(...);
	using type=decltype(vector_type<SIZE>(std::declval<T>()));
};
/*
 * 根据opencl 向量类型返回向量的元素类型和向量长度，
 * 如is_cl_vector<cl_int2>::type 为 cl_int
 *  is_cl_vector<cl_int2>::value 为true 是opencl向量类型
 *  is_cl_vector<cl_int2>::size 为向量长度
 */
template<typename T>
struct is_cl_vector{
	template<typename _T, typename ENABLE=void>
	struct vector_size{
		enum{size=-1};
	};
	template<typename _T>
	struct vector_size<_T, typename std::enable_if<
		std::is_same<_T, cl_char2>::value
		|| std::is_same<_T, cl_uchar2>::value
		|| std::is_same<_T, cl_short2>::value
		|| std::is_same<_T, cl_ushort2>::value
		|| std::is_same<_T, cl_int2>::value
		|| std::is_same<_T, cl_uint2>::value
		|| std::is_same<_T, cl_long2>::value
		|| std::is_same<_T, cl_ulong2>::value
		|| std::is_same<_T, cl_float2>::value
		|| std::is_same<_T, cl_double2>::value
	>::type>{
		enum{size=2};
	};
	template<typename _T>
	struct vector_size<_T, typename std::enable_if<
		std::is_same<_T, cl_char4>::value
		|| std::is_same<_T, cl_uchar4>::value
		|| std::is_same<_T, cl_short4>::value
		|| std::is_same<_T, cl_ushort4>::value
		|| std::is_same<_T, cl_int4>::value
		|| std::is_same<_T, cl_uint4>::value
		|| std::is_same<_T, cl_long4>::value
		|| std::is_same<_T, cl_ulong4>::value
		|| std::is_same<_T, cl_float4>::value
		|| std::is_same<_T, cl_double4>::value
	>::type>{
		enum{size=4};
	};
	template<typename _T>
	struct vector_size<_T, typename std::enable_if<
		std::is_same<_T, cl_char8>::value
		|| std::is_same<_T, cl_uchar8>::value
		|| std::is_same<_T, cl_short8>::value
		|| std::is_same<_T, cl_ushort8>::value
		|| std::is_same<_T, cl_int8>::value
		|| std::is_same<_T, cl_uint8>::value
		|| std::is_same<_T, cl_long8>::value
		|| std::is_same<_T, cl_ulong8>::value
		|| std::is_same<_T, cl_float8>::value
		|| std::is_same<_T, cl_double8>::value
	>::type>{
		enum{size=8};
	};
	template<typename _T>
	struct vector_size<_T, typename std::enable_if<
		std::is_same<_T, cl_char16>::value
		|| std::is_same<_T, cl_uchar16>::value
		|| std::is_same<_T, cl_short16>::value
		|| std::is_same<_T, cl_ushort16>::value
		|| std::is_same<_T, cl_int16>::value
		|| std::is_same<_T, cl_uint16>::value
		|| std::is_same<_T, cl_long16>::value
		|| std::is_same<_T, cl_ulong16>::value
		|| std::is_same<_T, cl_float16>::value
		|| std::is_same<_T, cl_double16>::value
	>::type>{
		enum{size=16};
	};

	static cl_char check(cl_char2);
	static cl_char check(cl_char4);
	static cl_char check(cl_char8);
	static cl_char check(cl_char16);

	static cl_uchar check(cl_uchar2);
	static cl_uchar check(cl_uchar4);
	static cl_uchar check(cl_uchar8);
	static cl_uchar check(cl_uchar16);

	static cl_short check(cl_short2);
	static cl_short check(cl_short4);
	static cl_short check(cl_short8);
	static cl_short check(cl_short16);

	static cl_ushort check(cl_ushort2);
	static cl_ushort check(cl_ushort4);
	static cl_ushort check(cl_ushort8);
	static cl_ushort check(cl_ushort16);

	static cl_int check(cl_int2);
	static cl_int check(cl_int4);
	static cl_int check(cl_int8);
	static cl_int check(cl_int16);

	static cl_uint check(cl_uint2);
	static cl_uint check(cl_uint4);
	static cl_uint check(cl_uint8);
	static cl_uint check(cl_uint16);

	static cl_long check(cl_long2);
	static cl_long check(cl_long4);
	static cl_long check(cl_long8);
	static cl_long check(cl_long16);

	static cl_ulong check(cl_ulong2);
	static cl_ulong check(cl_ulong4);
	static cl_ulong check(cl_ulong8);
	static cl_ulong check(cl_ulong16);

	static cl_float check(cl_float2);
	static cl_float check(cl_float4);
	static cl_float check(cl_float8);
	static cl_float check(cl_float16);

	static cl_double check(cl_double2);
	static cl_double check(cl_double4);
	static cl_double check(cl_double8);
	static cl_double check(cl_double16);
	static void check(...);
	using type=decltype(check(std::declval<T>()));
	enum{value=!std::is_void<type>::value,size=vector_size<T>::size};
};

template<typename T,typename C=float
		,typename RET=typename std::enable_if<std::is_arithmetic<T>::value,typename std::conditional<std::is_floating_point<T>::value,T,C>::type>::type>
inline
RET
length(const T &x,const T &y){
	return RET(std::sqrt(std::pow(RET(x),2)+std::pow(RET(y),2)));
}
/*
 * 递归计算向量所有元素的平方和（递归结束）
 * */
template<typename T,typename C=float,typename VI=is_cl_vector<T>
		,typename RET=typename std::conditional<std::is_floating_point<typename VI::type>::value,T,C>::type>
inline
typename std::enable_if<2==VI::size&&VI::value,RET>::type
square_sum(const T &pos){
	return RET(std::pow(RET(pos.s[0]),2)+std::pow(RET(pos.s[1]),2));
}
/*
 * 递归计算向量所有元素的平方和
 * */
template<typename T,typename C=float,typename VI=is_cl_vector<T>
	,typename RET=typename std::conditional<std::is_floating_point<typename VI::type>::value,T,C>::type>
inline
typename std::enable_if<2<VI::size&&VI::value,RET>::type
square_sum(const T &pos){
	return square_sum(pos.hi)+square_sum(pos.lo);
}
template<typename T,typename C=float,typename VI=is_cl_vector<T>
		,typename RET=typename std::enable_if<VI::value,typename std::conditional<std::is_floating_point<typename VI::type>::value,T,C>::type>::type>
inline
RET
length(const T &pos){
	return RET(std::sqrt(square_sum(pos)));
}

template<typename T,typename C=float,typename VI = cl::is_cl_vector<T>
		,typename RET=typename std::enable_if<VI::value,typename std::conditional<std::is_floating_point<typename VI::type>::value,T,C>::type>::type>
inline
RET
distance(const T &p0,const T &p1){
	return length(p0-p1);
}
}/* namespace cl */

begin global namespace//
/*
 * (递归结束)向量减法操作符
 */
template<typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value>::type
	, typename RET= typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] - std::declval<T>().s[0])>::type>
inline
typename std::enable_if<2 == VI::size, RET>::type
operator-(const T &p1, const T &p2) {
	return{ p1.s[0] - p2.s[0],p1.s[1] - p2.s[1] };
}
/*
 * (递归)向量减法操作符
 */
template<typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value>::type
	, typename RET = typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] - std::declval<T>().s[0])>::type>
inline
typename std::enable_if<2<VI::size, RET>::type
operator-(const T &p1, const T &p2) {
	RET r;
	r.hi = p1.hi - p2.hi;
	r.lo = p1.lo - p2.lo;
	return r;
}
/*
 * (递归结束)向量减法操作符,第二个操作数非向量
 */
template<typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value>::type
	, typename RET= typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] - std::declval<T>().s[0])>::type>
inline
typename std::enable_if<2 == VI::size, RET>::type
operator-(const T &p1, const typename VI::type &p2) {
	return{ p1.s[0] - p2,p1.s[1] - p2};
}
/*
 * (递归)向量减法操作符,第二个操作数非向量
 */
template<typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value>::type
	, typename RET = typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] - declval<T>().s[0])>::type>
inline
typename std::enable_if<2<VI::size, RET>::type
operator-(const T &p1, const typename VI::type &p2) {
	RET r;
	r.hi = p1.hi - p2;
	r.lo = p1.lo - p2;
	return r;
}
/*
* (递归结束)向量减法操作符,第一个操作数非向量
*/
template<typename N, typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value&&std::is_same<N, typename VI::type>::value>::type
	, typename RET = typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] - std::declval<T>().s[0])>::type>
	inline
	typename std::enable_if<2==VI::size, RET>::type
	operator-(const N &p1, const  T&p2) {
	return{ p1 - p2.s[0],p1 - p2.s[1] };
}

/*
 * (递归)向量减法操作符,第一个操作数非向量
 */
template<typename N,typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value&&std::is_same<N, typename VI::type>::value>::type
	, typename RET = typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] - std::declval<T>().s[0])>::type>
inline
typename std::enable_if<2<VI::size, RET>::type
operator-(const N &p1, const  T&p2) {
	RET r;
	r.hi = p1 - p2.hi;
	r.lo = p1 - p2.hi;
	return r;
}
/*
 * (递归结束)向量加法操作符
 */
template<typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value>::type
	, typename RET= typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] + std::declval<T>().s[0])>::type>
inline
typename std::enable_if<2 == VI::size, RET>::type
operator+(const T &p1, const T &p2) {
	return{ p1.s[0] + p2.s[0],p1.s[1] + p2.s[1] };
}
/*
 * (递归)向量加法操作符
 */
template<typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value>::type
	, typename RET = typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] + std::declval<T>().s[0])>::type>
inline
typename std::enable_if<2<VI::size, RET>::type
operator+(const T &p1, const T &p2) {
	RET r;
	r.hi = p1.hi + p2.hi;
	r.lo = p1.lo + p2.lo;
	return r;
}
/*
 * (递归结束)向量加法操作符,第二个操作数非向量
 */
template<typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value>::type
	,typename RET=typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] + std::declval<T>().s[0])>::type>
inline
typename std::enable_if<2 == VI::size, RET>::type
operator+(const T &p1, const typename VI::type &p2) {
	return{ p1.s[0] + p2,p1.s[1] + p2 };
}
/*
 * (递归)向量加法操作符,第二个操作数非向量
 */
template<typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value>::type
	, typename RET = typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] + std::declval<T>().s[0])>::type>
inline
typename std::enable_if<2<VI::size, RET>::type
operator+(const T &p1, const typename VI::type &p2) {
	RET r;
	r.hi = p1.hi + p2;
	r.lo = p1.lo + p2;
	return r;
}

/*
 * 向量加法操作符,第一个操作数非向量
 */
template<typename N,typename T, typename VI = cl::is_cl_vector<T>
	, typename ENABLE = typename std::enable_if<VI::value&&std::is_same<N, typename VI::type>::value>::type
	, typename RET = typename cl::cl_vector_type<VI::size, decltype(std::declval<T>().s[0] + std::declval<T>().s[0])>::type>
inline
RET
operator+(const N &p1, const  T&p2) {
	return p2+p1;
}
end global namespace//

上面的代码中实现了opencl向量类型的+,-运算，支持两个向量类型数据的加/减运算，以及一个向量和一个标量类型的加/减运算，以及legnth,distance函数。（实现其他的运算符和函数也是差不多的代码，因为我暂时不需要就没有继续写下去）。
代码开始有两个很长的模板函数cl_vector_type和is_cl_vector，所有的其他函数模板都要用到这两个模板函数：
cl_vector_type用于构造一个指定元素类型和长度的opencl向量类型。
is_cl_vector则用于判断一个类型是否是opencl的向量类型，如果是value为true，size中保存向量长度，type则是向量元素的类型。

有了这些模板函数的支持，主机端opencl向量的运算就变得像在内核代码中一样简单，还以前面的例子用模板函数重写，就是这样：

cl_int4 p1={4,2,0,9};
cl_int4 p2={3,9,-1,8};
cl_int4 p3=p1+p2;
cl_float length=cl::length(p1);//计算向量长度
cl_float dist=cl::distance(p1,p2);//计算向量距离
10km
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
OpenCL编程指南-10.1C++包装器API
qq_36314864的博客
09-07 290
C++API划分为多个类，分别映射到一个OpenCL C类型，例如，cl::Memory类就映射到OpenCL C中的cl_mem。不过，C++ API会尽可能使用继承提供额外的一层类型抽象；例如，类cl::Buffer派生自基类cl::Memory，表示所有可能的OpenCL内存对象的1维内存子类。类层次体系结构见图12-1。一般地，C++类类型到底层OpenCL C类型有直接的映射，在这种情况下，底层C类型可以通过操作符()访问。//not safe。
OpenCL编程指南-4.2矢量数据类型
qq_36314864的博客
05-12 969
矢量字面量的写法如下：首先是一个用括号括起的矢量类型，后面是一个用括号括起的参数列表，各参数之间用逗号分隔。可用的函数形式为可能的参数列表集合，其中所有参数与结果矢量有相同的元素类型，而且元素总数等于结果矢量中元素的个数。另外，还可以采用一种单个标量的形式，该标量的类型要与矢量的元素类型相同。如果一个内置数据类型的大小（字节数）不是2的幂，则要按紧邻的下一个2的幂值对齐（即大于它的最小的2的幂值)。例如，下面的用法是不合法的。)后缀来得到较小的矢量类型，或者把较小的矢量类型结合为一个较大的矢量类型。
自定义一个简单OpenCL C++ 类
万类霜天竞自由
12-25 447
新建一个类，用来管理opencl整个流程，设定为单例模式，直接上主要代码： .h 文件 #ifndef CLMANAGER_H_ #define CLMANAGER_H_ #include <CL/cl.hpp> #include <cstdio> #include <cstdlib> #include <fstream> #include <iostream> #include <string> #include <i
C++ 实战之OpenCL环境搭建（一）
热门推荐
天马行空，隐姓埋名
10-05 1万+
前言：接触opencl并行计算变成之前，在我的认知观中，所谓的并行应该就是应用多线程技术达到，比如openMP，openMPI等多线程技术。不过这些都是在cpu上运行，原理都是更好的利用多核处理器的硬件特性，让程序最大程度的利用了多核的优势。 接触opencl之后，认识到了opencl编程技术可以把一些复杂的代码搬运到GPU或其他加速处理器上运行，而gpu又比cpu更适应与计算比如加法，乘法等。第
全网第一个c++版本的opencl编程详解（gpu编程）
brucexiajun的博客
09-16 4153
本文主要讲解opencl在windows下，使用cpp编程的基本过程，使用的IDE是Visual Studio 2017。 下面的代码连在一起就可以运行 step1：新建工程，导入头文件 在VS上新建一个工程，然后配置相关的头文件：视图->其它窗口->属性管理器，然后配置一些项，目的是将opencl的头文件导入这个cpp工程里面。（这里不介绍了，有很多现成的文章） step2：...
OpenCL专题01：开发配置
吴智深的博客
06-15 2339
GPU编程 OpenCL开发
opencl_univ_kit_1.0.rar_C# OpenCL_OpencL_vectoradd.cl
09-24
在本篇中，我们将探讨C#结合OpenCL实现OpenCL应用，并以"vectoradd.cl"为例，深入理解OpenCL的基本原理和应用。 首先，OpenCL由三大部分组成：主机API、设备API和内核语言。主机API是程序员在主机（如CPU）上使用的...
petsc-3.6.3.rar_GPU+MPI_exodusII.inc_opencl cuda_petsc cuda版
09-24
PETSc, pronounced PET-see (the S is silent), is a suite of data structures and routines for the scalable ... It supports MPI, and GPUs through CUDA or OpenCL, as well as hybrid MPI-GPU parallelism
CUDA-programming.zip_GPGPU_OpencL_cuda_opencl cuda_opencl+cuda
09-24
CUDA编程和GPGPU（通用计算并行图形处理器）是现代高性能计算的重要组成部分，而OpenCL则是一种跨平台的并行编程框架。本压缩包文件包含的“cuda程序设计.ppt”显然是一份关于CUDA编程的详细介绍，我们将深入探讨...
altera_opencl.rar_Altera OpenCL_FPGA OpenCL_OpenCL FPGA_fpga 加速
07-14
《Altera OpenCL：FPGA平台上的OpenCL与并行加速技术详解》 在现代高性能计算领域，FPGA（Field-Programmable Gate Array）因其可编程性和高效能的优势，正逐渐成为加速计算的重要工具。而OpenCL作为跨平台的并行...
AMD-OpenCL-.rar_OpencL
09-24
**OpenCL 概述** OpenCL，全称为Open Computing Language，是一种开放标准的并行编程框架，用于在异构计算平台上进行数据并行和任务并行计算。它由Khronos Group组织制定，旨在实现跨平台的高效计算，涵盖了从CPU、...
基于OpenCL的多维卷积计算实现
noobkiller
04-17 848
本文介绍了如何使用OpenCL实现卷积运算，文中给出了相应的代码，介绍了设计思路，给出了性能分析结果。
用于OpenCL的C++
最新发布
aggs1990的专栏
11-09 161
​更多详细信息可在其用户手册中找到。然而，由于应用程序复杂性的增长，特别是那些从丰富的C++特性和高级抽象中获益最多的应用程序，预计大多数用于OpenCL内核的C++都将离线编译。​C++for OpenCL是一种社区驱动的开放语言，欢迎任何有兴趣改进clang中的语言编译或OpenCL文档中托管的语言文档的人提供意见。​OpenCL工作组已经从最初在OpenCL 2.2中定义的OpenCL C++内核语言过渡到为OpenCL内核语言开发的社区C++，该语言提供了改进的功能和与OpenCL C的兼容性。
GPGPU OpenCL编程步骤与简单实例
weixin_33869377的博客
03-06 253
http://www.cnblogs.com/xudong-bupt/p/3582780.html  1.OpenCL概念 　　OpenCL是一个为异构平台编写程序的框架，此异构平台可由CPU、GPU或其他类型的处理器组成。OpenCL由一门用于编写kernels （在OpenCL设备上运行的函数）的语言（基于C99）和一组用于定义并控制平台的API组成。 　　OpenCL提供了两种层面的并...
OpenCL 语言中的 Vector Operations (向量运算)
既然选择了远方 便只顾风雨兼程 - 永强
01-15 743
OpenCL 语言中的 Vector Operations (向量运算)
理解OpenCL数据类型
weixin_30239339的博客
03-14 700
OpenCL支持从C编程语言派生而来的多种数据类型，大致可以分为两类，标量和向量。 标量基本上是元素值，向量是元素值的集合。 OpenCL变量整型数据类型由有符号类型和无符号类型组成，如cl_int, cl_double；而向量数据类型由成倍数的整型和浮点标量数据类型组成，如cl_char<N>,cl_float<N>,其中<N>代表值2、3、4、8或16。...
opencl: C++ 接口(cl.hpp)创建kernel
10km的专栏
02-27 6317
OpenCL不仅提供了标准C接口，同时提供C++的接口(cl.hpp)，其实就是基于C接口的进一步封装。有了这个C++接口,对于C++项目来说，就大大提高了使用的便利性，本人涉及的这个项目对OpenCL的调用全部都是基于OpenCL的C++接口来完成的。本文讲述如何用OpenCL 1.2的C++接口来从cl原文件创建kernel。在cl.hpp中对cl_kernel被封装成了cl::Kernel对象
C++实战之OpenCL矩阵相乘优化（二）
天马行空，隐姓埋名
11-21 9521
前言上一篇文章，分析了简单的矩阵相乘在opencl里面的优化kernel代码，每个work-item只负责计算结果矩阵的一个元素。下一步准备每次计算出结果矩阵的块元素，看看计算时间是如何。这个矩阵系列参考国外一个大神的教程： https://cnugteren.github.io/tutorial/pages/page4.html 有每个kernel的详解工程，还有github代码工程。具体分析
opencl:c++接口(cl.hpp)利用cl::LocalSpaceArg设置__local 参数
10km的专栏
05-16 2352
当我们需要在kernel中使用local memory数组的时候，有两种方式定义local 数组 第一种,编译期静态定义，这是比较普通的使用方式，如下代码，这种方式，在编译期就分配了local 数组的大小。#define LOCAL_ARRAY_SIZE 64 // LOCAL_ARRAY_SIZE 可以通过编译选项-D在编译的时候定义 __kernel void test_kernel( ){
写一段C++代码，把opencv读入的图像cv::Mat A转化为cl_mem格式送入opencl的命令队列
03-09
我可以回答这个问题。以下是将opencv读入的图像cv::Mat A转化为cl_mem格式送入opencl的命令队列的C代码示例： ``` // 假设已经创建了OpenCL上下文和命令队列 // 假设cv::Mat A是一个3通道的图像 // 创建OpenCL内存对象 cl_mem cl_A = clCreateBuffer(context, CL_MEM_READ_ONLY, A.total() * A.elemSize(), NULL, &err); // 将cv::Mat A的数据复制到OpenCL内存对象中 err = clEnqueueWriteBuffer(command_queue, cl_A, CL_TRUE, , A.total() * A.elemSize(), A.data, , NULL, NULL); // 将OpenCL内存对象添加到OpenCL内核参数中 err = clSetKernelArg(kernel, , sizeof(cl_mem), (void *)&cl_A); // 执行OpenCL内核 err = clEnqueueNDRangeKernel(command_queue, kernel, 2, NULL, global_work_size, local_work_size, , NULL, NULL); ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

10km

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值