Index array in CUDA thrust - cuda

Question

I'm trying to figure out how to work with index array in CUDA thrust. My problem is the following:
vector<int> index(20);
vector<float> data1(100), data2(100), result(20);
for(int i=0;i<index.size();++i)
result.push_back(do_something(data1[index[i]],data2[index[i]]));
The function do_something() takes elements from several large arrays selected by index array. The size of index is usually much smaller than the size of data and the elements of index are sorted.
I can't figure out what is the best strategy of doing this efficiently in thrust.

Answer 1

I recommend reading the thrust quick start guide for basic understanding of thrust, and some of the concepts I will use below.
I can't figure out what is the best strategy of doing this efficiently in thrust.
Most of what you have in your example should map directly to straightforward operations in thrust. Your for-loop and do_something operation would be replaced by a thrust algorithm, probably with an appropriate functor definition that would mimic the functionality you have in do_something. An easy-to-use thrust algorithm is thrust::transform() that may be applicable to this case.
The use of the index array for indirection would often be handled using a thrust permutation_iterator, which is designed exactly for this purpose.
Combining these concepts, and supposing for a simple example that your do_something operation will sum the squares of each indexed element in the two input vectors, and then store the square root of that result in the result vector, we could have an example like this:
$ cat t74.cu
#include <thrust/device_vector.h>
#include <thrust/transform.h>
#include <thrust/iterator/permutation_iterator.h>
#include <thrust/copy.h>
#include <math.h>
#include <iostream>
struct do_something
{
template <typename T>
__host__ __device__ T operator()(const T &i1, const T &i2){
return sqrtf(i1*i1 + i2*i2);
}
};
int main(){
//pythagorean triples
float d1[] = { 3, 5, 8, 7, 20, 12, 9, 28};
float d2[] = { 4, 12, 15, 24, 21, 35, 40, 45};
int i1[] = {1, 3, 5, 7};
const size_t isize = sizeof(i1)/sizeof(i1[0]);
const size_t dsize = sizeof(d1)/sizeof(d1[0]);
thrust::device_vector<int> index(i1, i1+isize);
thrust::device_vector<float> data1(d1, d1+dsize);
thrust::device_vector<float> data2(d2, d2+dsize);
thrust::device_vector<float> result(isize);
thrust::transform(thrust::make_permutation_iterator(data1.begin(), index.begin()), thrust::make_permutation_iterator(data1.begin(), index.end()), thrust::make_permutation_iterator(data2.begin(), index.begin()), result.begin(), do_something());
thrust::copy_n(result.begin(), result.size(), std::ostream_iterator<float>(std::cout, ","));
std::cout << std::endl;
}
$ nvcc -arch=sm_30 -o t74 t74.cu
$ ./t74
13,25,37,53,
$
The index set need not be sorted for this usage (although it may be somewhat beneficial from a performance perspective).