CUDA初学者-Thrust - Algorithms - Reductions（4）

最新推荐文章于 2023-11-30 13:49:16 发布
最新推荐文章于 2023-11-30 13:49:16 发布
阅读量444 收藏
点赞数
分类专栏： cuda小白 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011732139/article/details/124750597
版权

本人 CUDA小白一枚，要是有什么不对，还望各位大佬指点。
本文及后面的几篇将分别从几个方面来大概阐述一下Thrust的一些接口。原来的网址在这里。

1.Algorithms

1.4 Reductions
1.4.1 reduce

template<typename DerviedPolicy, typename InputIterator> 
__host__ __device__ thrust::iterator_traits< InputIterator >::value_type thrust::reduce(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last
);

template<typename InputIterator> 
thrust::iterator_traits< InputIterator >::value_type thrust::reduce(
  	InputIterator first,
  	InputIterator last
);

template<typename DerviedPolicy, typename InputIterator, typename T> 
__host__ __device__ T thrust::reduce(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	T init
);

template<typename InputIterator, typename T> 
T thrust::reduce(
  	InputIterator first,
  	InputIterator last,
  	T init
);

template<typename DerviedPolicy, typename InputIterator, typename T, typename BinaryFunction> 
__host__ __device__ T thrust::reduce(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	T init,
  	BinaryFunction binary_op
);

template<typename InputIterator, typename T> 
T thrust::reduce(
  	InputIterator first,
  	InputIterator last,
  	T init,
  	BinaryFunction binary_op
);

对数组进行一定的操作得到一个值的输出，可以指定起始值，可以指定特定的操作，默认的操作是求和
例子：

int data[6] = {1, 0, 2, 2, 1, 3};
int result1 = thrust::reduce(thrust::host, data, data + 6);
// int result1 = thrust::reduce(data, data + 6);
// result1 = 9

int result2 = thrust::reduce(thrust::host, data, data + 6, 1);
// int result2 = thrust::reduce(data, data + 6, 1);
// result2 = 10

int result3 = thrust::reduce(thrust::host, data, data + 6, 1, thrust::maximum<int>());
// int result3 = thrust::reduce(data, data + 6, 1, thrust::maximum<int>());
// reuslt3 = 3

1.4.2 reduce_by_key

template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator1, typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator1 keys_first,
  	InputIterator1 keys_last,
  	InputIterator2 values_first,
  	OutputIterator1 keys_output,
  	OutputIterator2 values_output
);

template <typename InputIterator1, typename InputIterator2, typename OutputIterator1, typename OutputIterator2>
thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key(
  	InputIterator1 keys_first,
  	InputIterator1 keys_last,
  	InputIterator2 values_first,
  	OutputIterator1 keys_output,
  	OutputIterator2 values_output
);

template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator1, typename OutputIterator2, typename BinaryPredicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator1 keys_first,
  	InputIterator1 keys_last,
  	InputIterator2 values_first,
  	OutputIterator1 keys_output,
  	OutputIterator2 values_output,
  	BinaryPredicate binary_pred
);

template <typename InputIterator1, typename InputIterator2, typename OutputIterator1, typename OutputIterator2, typename BinaryPredicate>
thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key(
  	InputIterator1 keys_first,
  	InputIterator1 keys_last,
  	InputIterator2 values_first,
  	OutputIterator1 keys_output,
  	OutputIterator2 values_output,
  	BinaryPredicate binary_pred
);

template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator1, typename OutputIterator2, typename BinaryPredicate, typename BinaryFunction>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator1 keys_first,
  	InputIterator1 keys_last,
  	InputIterator2 values_first,
  	OutputIterator1 keys_output,
  	OutputIterator2 values_output,
  	BinaryPredicate binary_pred,
  	BinaryFunction binary_op
);

template <typename InputIterator1, typename InputIterator2, typename OutputIterator1, typename OutputIterator2, typename BinaryPredicate, typename BinaryFunction>
thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key(
  	InputIterator1 keys_first,
  	InputIterator1 keys_last,
  	InputIterator2 values_first,
  	OutputIterator1 keys_output,
  	OutputIterator2 values_output,
  	BinaryPredicate binary_pred,
  	BinaryFunction binary_op
);

按照key的值来对整个数组进行操作，可以指定对应的操作（默认求和）和对key的判断条件，用来判断那些key可以执行对应的操作。对于keys中连续出现相同数值的时候，对对应的value进行reduce的操作。
例子：

const int N = 7;
int A[N] = {1, 3, 3, 3, 2, 2, 1};   // keys
int B[N] = {9, 8, 7, 6, 5, 4, 3};   // values
int C[N];
int D[N];

thrust::pair<int *, int *> new_end;
new_end = thrust::reduce_by_key(thrust::host, A, A + N, B, C, D);
// new_end = thrust::reduce_by_key( A, A + N, B, C, D);
// C = {1, 3, 2, 1}    new_end.first - C = 4
// D = {9, 21, 9, 3}    new_end.second - D = 4

int C1[N];
int D1[N];
thrust::pair<int *, int *> new_end1;
thrust::equal_to<int> binary_pred;
new_end1 = thrust::reduce_by_key(thrust::host, A, A + N, B, C1, D1, binary_pred);
// new_end1 = thrust::reduce_by_key(A, A + N, B, C1, D1, binary_pred);
// 由于默认的binary_pred操作就是判断是都相等，因此C1、D1和new_end1的结果和C、D和new_end相同

int C2[N];
int D2[N];
thrust::pair<int *, int *> new_end2;
thrust::plus<int> binary_op;
new_end2 = thrust::reduce_by_key(thrust::host, A, A + N, B, C2, D2, binary_pred, binary_op);
// new_end2 = thrust::reduce_by_key(A, A + N, B, C2, D2, binary_pred, binary_op);
// 由于默认的binary_op操作就是相加，因此C2、D2和new_end2的结果和C、D和new_end相同

1.4.3 euqal

template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2>
__host__ __device__ bool thrust::equal(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator1 first1,
  	InputIterator1 last1,
  	InputIterator2 first2
);

template <typename InputIterator1, typename InputIterator2>
bool thrust::equal(
  	InputIterator1 first1,
  	InputIterator1 last1,
  	InputIterator2 first2
);

template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
__host__ __device__ bool thrust::equal(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator1 first1,
  	InputIterator1 last1,
  	InputIterator2 first2,
  	BinaryPredicate binary_pred
);

template <typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
bool thrust::equal(
  	InputIterator1 first1,
  	InputIterator1 last1,
  	InputIterator2 first2,
  	BinaryPredicate binary_pred
);

比较两个数组是否相同，可以指定对应判断条件
例子：

int A1[7] = {3, 1, 4, 1, 5, 9, 3};
int A2[7] = {3, 1, 4, 2, 8, 5, 7};

bool result = thrust::equal(thrust::host, A1, A1 + 7, A2);
// bool result = thrust::equal(A1, A1 + 7, A2);
// result = false;

struct compare_modulo_two {
	__host__ __device__
	bool operator()(int x, int y) const {
		return (x % 2) == (y % 2);
	}
}
bool result = thrust::equal(thrust::host, A1, A1 + 7, A2, compare_modulo_two());
// bool result = thrust::equal(A1, A1 + 7, A2, compare_modulo_two());
// result = false
// PS 官网的例返回的结果有点问题

1.4.4 count

template <typename DerivedPolicy, typename InputIterator, typename EqualityComparable>
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type thrust::count(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	const EqualityComparable & value
);

template <typename InputIterator, typename EqualityComparable>
thrust::iterator_traits< InputIterator >::difference_type thrust::count(
  	InputIterator first,
  	InputIterator last,
  	const EqualityComparable & value
);

template <typename DerivedPolicy, typename InputIterator, typename Predicate>
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type thrust::count(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

template <typename InputIterator, typename EqualityComparable>
thrust::iterator_traits< InputIterator >::difference_type thrust::count(
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

计数，可以统计相同元素，也统计一类元素
例子：

thrust::device_vecotr<int> vec(5, 0);
vec[1] = 1;
vec[3] = 1;
vec[4] = 1;

int result = thrust::count(thrust::device, vec.begin(), vec.end(), 1);
// int result = thrust::count(vec.begin(), vec.end(), 1);
// 返回的result为3

struct is_odd {
  __host__ __device__
  bool operator()(int &x) {
    return x & 1;
  }
};

int result = thrust::count(thrust::device, vec.begin(), vec.end(). is_odd());
// int result = thrust::count(vec.begin(), vec.end(). is_odd());
// 返回结果为3

1.4.5 min_element 和 max_element

template <typename DerivedPolicy, typename ForwardIterator>
__host__ __device__ ForwardIterator thrust::min_element(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	ForwardIterator first,
  	ForwardIterator last
);

template <typename ForwardIterator>
ForwardIterator thrust::min_element(
  	ForwardIterator first,
  	ForwardIterator last
);

template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
__host__ __device__ ForwardIterator thrust::min_element(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	ForwardIterator first,
  	ForwardIterator last,
  	BinaryPredicate comp
);

template <typename ForwardIterator, typename BinaryPredicate>
ForwardIterator thrust::min_element(
  	ForwardIterator first,
  	ForwardIterator last,
  	BinaryPredicate comp
);

找到一组元素中的最小值

int data[6] = {1, 0, 2, 2, 1, 3};
int *result = thrust::min_element(thrust::host, data, data + 6);
// int *result = thrust::min_element(thrust::host, data, data + 6);
// 结果为0

struct key_value {
  int key;
  int value;
};

struct compare_key_value {
  __host__ __device__
  bool operator()(key_value lhs, key_value rhs) {
    return lhs.key < rhs.key;
  }
};
key_value data[4] = {{4, 5}, {0, 7}, {2, 3}, {6, 1}};
key_value *result = thrust::min_element(thrust::host, data, data + 4, compare_key_value);
// key_value *result = thrust::min_element(data, data + 4, compare_key_value);
// 结果为{0, 7}

1.4.6 minmax_element

template <typename DerivedPolicy, typename ForwardIterator>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator > thrust::minmax_element(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
 	ForwardIterator first,
  	ForwardIterator last
);

template <typename ForwardIterator>
thrust::pair< ForwardIterator, ForwardIterator > thrust::minmax_element(
 	ForwardIterator first,
  	ForwardIterator last
);

template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator > thrust::minmax_element(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
 	ForwardIterator first,
  	ForwardIterator last,
  	BinaryPredicate comp
);

template <typename ForwardIterator, typename BinaryPredicate>
thrust::pair< ForwardIterator, ForwardIterator > thrust::minmax_element(
 	ForwardIterator first,
  	ForwardIterator last,
  	BinaryPredicate comp
);

返回最小元素和最大元素
例子：

int data[6] = {1, 0, 2, 2, 1, 3};
thrust::pair<int *, int*> result = thrust::minmax_element(thrust:host, data, data + 6);
// thrust::pair<int *, int*> result = thrust::minmax_element(data, data + 6);
// result.first 是最小值 0
// result.second 是最大值 3

struct key_value {
  int key;
  int value;
};

struct compare_key_value {
  __host__ __device__
  bool operator()(key_value lhs, key_value rhs) {
    return lhs.key < rhs.key;
  }
};

key_value data[4] = {{4, 5}, {0, 7}, {2, 3}, {6, 1}};
thrust::pair<key_value *, key_value *> result = thrust::minmax_element(thrust::host, data, data + 4, compare_key_value());
// thrust::pair<key_value *, key_value *> result = thrust::minmax_element(data, data + 4, compare_key_value());
// 最小值为{0, 7}   最大的为{6, 1}

1.4.7 all_of

template <typename DerivedPolicy, typename InputIterator, typename Predicate>
__host__ __device__ bool thrust::all_of(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

template <typename InputIterator, typename Predicate>
bool thrust::all_of(
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

判断指定元素是否全等于pred, 如果指定元素为空，则返回false
例子：

bool A[3] = {true, true, false};
thrust::all_of(thrust::host, A, A + 2, thrust::identity<bool>());
// thrust::all_of(A, A + 2, thrust::identity<bool>());
// resunt true

thrust::all_of(thrust::host, A, A + 3, thrust::identity<bool>());
// thrust::all_of(A, A + 3, thrust::identity<bool>());
// resunt false

1.4.8 any_of

template <typename DerivedPolicy, typename InputIterator, typename Predicate>
__host__ __device__ bool thrust::any_of(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

template <typename InputIterator, typename Predicate>
bool thrust::any_of(
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

判断指定元素是否存在pred，如果指定元素为空，则返回false
例子：

bool A[3] = {true, true, false};
thrust::any_of(thrust::host, A, A + 2, thrust::identity<bool>());
// thrust::any_of(A, A + 2, thrust::identity<bool>());
// resunt true

thrust::any_of(thrust::host, A + 2, A + 3, thrust::identity<bool>());
// thrust::any_of(A + 2, A + 3, thrust::identity<bool>());
// resunt false

1.4.9 none_of

template <typename DerivedPolicy, typename InputIterator, typename Predicate>
__host__ __device__ bool thrust::none_of(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

template <typename InputIterator, typename Predicate>
bool thrust::none_of(
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

判断指定元素是否不存在pred，如果为空，则返回true
例子：

bool A[3] = {true, true, false};
thrust::none_of(thrust::host, A, A + 2, thrust::identity<bool>());
// thrust::none_of(A, A + 2, thrust::identity<bool>());
// resunt false

thrust::none_of(thrust::host, A + 2, A + 3, thrust::identity<bool>());
// thrust::none_of(A + 2, A + 3, thrust::identity<bool>());
// resunt true

1.4.10 is_partitioned

template <typename DerivedPolicy, typename InputIterator, typename Predicate>
__host__ __device__ bool thrust::is_partitioned(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

template <typename InputIterator, typename Predicate>
bool thrust::is_partitioned(
	InputIterator first,
  	InputIterator last,
  	Predicate pred
);

判断指定范围内数据是否按照特定的规则进行划分。
例子：

struct is_even {
	__host__ __device__ 
	bool operator()(const int &x) {
		return (x % 2) == 0;
	}
}

int A[] = {2, 4, 6, 8, 10, 1,3, 5, 7, 9};
int B[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

thrust::is_partitioned(thrust::host, A, A + 10, is_even()); // returns true
// thrust::is_partitioned(A, A + 10, is_even()); // returns true
thrust::is_partitioned(thrust::host, B, B + 10, is_even()); // returns false
// thrust::is_partitioned(B, B + 10, is_even()); // returns false

1.4.11 is_sorted

template <typename DerivedPolicy, typename ForwardIterator>
__host__ __device__ bool thrust::is_sorted(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	ForwardIterator first,
  	ForwardIterator last
);

template <typename ForwardIterator>
__host__ __device__ bool thrust::is_sorted(
  	ForwardIterator first,
  	ForwardIterator last
);

判断是否是有序的（递增）

thrust::device_vector<int> v(6);
v[0] = 1;
v[1] = 4;
v[2] = 2;
v[3] = 8;
v[4] = 5;
v[5] = 7;
bool result = thrust::is_sorted(thrust::device, v.begin(), v.end()); // return false
// bool result = thrust::is_sorted(v.begin(), v.end());

thrust::greater<int> copm;
bool result = thrust::is_sorted(thrust::device, v.begin(), v.end(), comp);
// bool result = thrust::is_sorted(v.begin(), v.end(), comp);

1.4.12 is_sorted_until

template <typename DerivedPolicy, typename ForwardIterator>
__host__ __device__ ForwardIterator thrust::is_sorted_until(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	ForwardIterator first,
  	ForwardIterator last
);

template <typename ForwardIterator>
ForwardIterator thrust::is_sorted_until(
	ForwardIterator first,
  	ForwardIterator last
);

template <typename DerivedPolicy, typename ForwardIterator, typename Compare>
__host__ __device__ ForwardIterator thrust::is_sorted_until(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	ForwardIterator first,
  	ForwardIterator last,
  	Compare comp
);

template <typename ForwardIterator, typename Compare>
ForwardIterator thrust::is_sorted_until(
	ForwardIterator first,
  	ForwardIterator last,
  	Compare comp
);

返回指定范围内的元素从first开始符合递增的最大index，同样的可以指定排序的方式

int A[8] = {0, 1, 2, 3, 0, 1, 2, 3};
int *B = thrust::is_sorted_until(thrust::host, A, A + 8);
// int *B = thrust::is_sorted_until(A, A + 8);
// 返回的结果 B - A = 4，（A, B）之间是有序递增的

thrust::greater<int> comp;
int *C = thrust::is_sorted_until(thrust::host, A, A + 8, comp);
// int *C = thrust::is_sorted_until(A, A + 8, comp);

1.4.13 inner_product

template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputType>
__host__ __device__ OutputType thrust::inner_product(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator1 first1,
  	InputIterator1 last1,
  	InputIterator2 first2,
  	OutputType init
);

template <typename InputIterator1, typename InputIterator2, typename OutputType>
OutputType thrust::inner_product(
  	InputIterator1 first1,
  	InputIterator1 last1,
  	InputIterator2 first2,
  	OutputType init
);

template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputType, typename BinaryFunction1, typename BinaryFunction2>
__host__ __device__ OutputType thrust::inner_product(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator1 first1,
  	InputIterator1 last1,
  	InputIterator2 first2,
  	OutputType init,
  	BinaryFunction1 binary_op1,
  	BinaryFunction2 binary_op2
);

template <typename InputIterator1, typename InputIterator2, typename OutputType, typename BinaryFunction1, typename BinaryFunction2>
OutputType thrust::inner_product(
  	InputIterator1 first1,
  	InputIterator1 last1,
  	InputIterator2 first2,
  	OutputType init,
  	BinaryFunction1 binary_op1,
  	BinaryFunction2 binary_op2
);

两个向量按位相乘求和，可以指定初始值，也可以指定对应位置元素的操作（默认相乘）及针对每一位的结果需要进行的操作（默认求和）。
例子：

float vec1[3] = {1.0f, 2.0f, 5.0f};
float vec1[3] = {4.0f, 1.0f, 5.0f};
float result = 0.0f;
thrust::plus<float>       binary_op1;
thrust::multiplies<float> binary_op2;

result = thrust::inner_product(thrust::host, vec1, vec1 + 3, vec2, 0.0f);
// result = thrust::inner_product(vec1, vec1 + 3, vec2, 0.0f);
// result = thrust::inner_product(thrust::host, vec1, vec1 + 3, vec2, 0.0f, binary_op1, binary_op2);
// result = thrust::inner_product(vec1, vec1 + 3, vec2, 0.0f, binary_op1, binary_op2);
// 四种算出来的结果是一致的

1.4.14 transform_reduce

template <typename DerivedPolicy, typename InputIterator, typename UnaryFunction, typename OutputType, typename BinaryFunction>
__host__ __device__ OutputType thrust::transform_reduce(
	const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  	InputIterator first,
  	InputIterator last,
  	UnaryFunction unary_op,
  	OutputType init,
  	BinaryFunction binary_op
);

template <typename InputIterator, typename UnaryFunction, typename OutputType, typename BinaryFunction>
OutputType thrust::transform_reduce(InputIterator first,
  InputIterator last,
  UnaryFunction unary_op,
  OutputType init,
  BinaryFunction binary_op);

将transform和reduce结合，首先g根据unary_op将[first, last)中的数据进行transform，然后结合初始值对转换之后的数值进行binary_op的操作。
例子：

struct absolute_value : public unary_function<T, T> {
	__host__ __device__ T operator()(const T &x) const {
		return x < T(0) ? -x : x;
	}
};

int data[6] = {-1, 0, -2, -2, 1, -3};
int result = thrust::transform_reduce(thrust::host, data, data + 6, absolute_value<int>(), 0, thrust::maximum<int>());
// int result = thrust::transform_reduce(data, data + 6, absolute_value<int>(), 0, thrust::maximum<int>());
MQTXWD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Cuda并行编程笔记（三）Reduce & Scan & Histogram
月球上的博客
08-05 3842
Reduce Intro to Parallel Programming CUDA - Udacity 458 https://www.youtube.com/playlist?list=PLGvfHSgImk4aweyWlhBXNF6XISY3um82_ reduce操作: 对二元可结合运算（没有先后顺序），前一项结果作为后一项输入。 a) Binary b...
Use thrust reduce_by_key with raw pointers instead of device pointers
newtonbear的专栏
10-16 888
Thrust is a powerful library to improve the performance the program has relatively abundant of memory and computation.  Thrust is self independent which often needs to pass thrust's own device pointe
thrust::reduce
邹九的个人博客
05-03 135
用作累加可以用在cpu，也可以用在gpu，gpu要使用相应的指针broadcast。
reduce和reduceByKey区别
Romantic_sir的博客
11-27 221
reduce: reduce 是用于一元组，遍历一元组的数据，进行处理。 object reduceTest{ def main(args: Array[String]): Unit = { val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("reduceTest") val sc...
cuda 使用trust库计算最值
xysjj的博客
12-14 1763
Thrust是并行算法和数据结构的基于GPU CUDA的C++库，类似于C++标准库stl,cuda安装后自带。Trust用于求最值的函数为min_element和max_element，和stl名字一样； 我是偶然发现原来cuda还有一个这个库，在项目中，因为中间有一个过程需要最值的索引，原本我是把数据从显存中拷贝到主机，然后使用stl的标准库计算的，因为主机与设备之间的数据交换慢，速度不是很...
algorithms-cuda-master.zip
07-15
CUDA的Thrust库提供了一套模板类和函数，用于实现高效的数据操作，包括数组操作和并行算法，对于实现二维卷积非常有帮助。 再者，递归高斯滤波器是一种用于图像平滑的滤波器，它通过多次应用单次高斯滤波来达到递归...
clj-thrust:推力的Clojure绑定
05-26
clj-thrust允许您像编写Web应用程序一样编写桌面GUI应用程序（ 和是遵循类似方法的两个流行应用程序）。 这样，就可以使用相同的代码库同时定位桌面和Web，而无需付出太多额外的努力（当然，这还取决于您设计项目的...
Determination-of-Motor-thrust
04-01
简介（第0回合） 纪律 工程 实验室 无人机 实验 1.确定电机推力 关于实验： 关于实验室（目标）： 该模拟的主要目的是使用不同的螺旋桨测量电动机的推力。...4 阿卜杜勒·沙米尔（Adbul Shameer） 尼
nvidia cuda-samples
01-11
CUDA是由NVIDIA公司推出的并行计算平台和编程模型，它允许开发者利用图形处理单元（GPU）进行高...这对于初学者来说是一份宝贵的资源，对于经验丰富的开发者，这些示例也可以作为设计新算法或改进现有代码的灵感来源。
node-thrust:用于 Thrust 的 NodeJS 语言绑定
07-09
在安装时，node-thrust post_install脚本会自动下载当前平台的 Thrust 二进制分发版。 require('node-thrust')(function(err, api) { api.window({ root_url: 'https://breach.cc' }).show(); }); 地位 支持完整...
Thrust是个CUDA并行算法库
03-19
Thrust是个CUDA并行算法库，含有一个类似于C++标准模板库(STL)的界面。Thrust提供了一个灵活的高级GPU编程接口，可以极大地增强开放者的生产力，可以利用Thrust迅速开发高性能的应用程序。这是一个非常重要的第三方包括：IntroductionToThrust.pdf和thrust-v1.0.0.zip
Thrust快速入门教程（三） —— Algorithms
Neo Arcadia
03-19 7696
Thrust提供了丰富的常用并行算法。这算法的功能与STL中的非常相似。所有的Thrust算法均提供了host端（主机端）和device端（设备端）的实现。当传入迭代器指向主机端时，将会调用主机端方法，当使用迭代器指向设备端时将调用设备端实现。
thrust(并行STL算法库)使用指南
最新发布
xiaochuideai的博客
11-30 662
本文是对于原thrust官网文档的阅读笔记，可以理解为译文。方便自己对thrust的工程应用，若要追求深度，可能这里不能提供太多的帮助。
Using CUDA and Thrust with Visual Studio 2010
923723914
10-13 244
Using CUDA and Thrust with Visual Studio 2010 Sunday, March 6, 2011 – 11:16 am &lt;!-- by Ade Miller --&gt;Using CUDA 4.0 RC2? Read the update post here. I was working on setting up some new CUDA pro...
thrust::minmax_element
邹九的个人博客
05-03 116
用作求序列最小值最大值，可以用在cpu，也可以用在gpu，gpu要使用相应的指针broadcast。
CUDA 进阶编程 Thrust库使用-算法与迭代器
10-07 2899
文章目录device_ptrfor_each, transform, copy等简单算法自定义function与STL进行配合 device_ptr thrust提供了一个ptr, 叫device_ptr。 但是注意, 这个不是类似auto_ptr, 也不是类似shared_ptr, 只是为了类型安全做的简单的封装，从device_ptr的源码里面，我们没有看到对应的析构代码 size_t N =...
max_element函数
qq_42759120的博客
03-05 9781
max_element（）函数和min_element（）函数，就是找最大值和最小值 数组：int position=max_element(a,a+n)-a; int data=*max_element(a,a+n); //这个函数是在[a,a+n)这个区间内寻找极值的 容器： int position=max_element(v.begin(), v.e...
*max_element
LzyRapX
07-26 886
std::max_element #include #include using namespace std; int main() { int n[]={1,4,22,3,8,5}; int len=sizeof(n)/sizeof(int); cout<<*max_element(n,n+len)<<endl; cout<<*min_element(n,n+len)<<endl;
使用Thrust提升CUDA编程效率
"Thrust是一个面向效率的CUDA编程库，它基于C++的Standard Template Library (STL)，旨在简化CUDA编程，使开发者能高效地实现高性能的并行应用。Thrust库提供了一系列数据并行原语，如扫描、排序和归约，这些可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值