CUDA thrust reduce is so slow? [closed] - cuda

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 9 years ago.
I am learning CUDA. Today, I try some code in the book: CUDA Application Design And Development, which make me surprised. Why CUDA Thrust is so slow? Here is the code and the output.
#include <iostream>
using namespace std;
#include<thrust/reduce.h>
#include<thrust/sequence.h>
#include<thrust/host_vector.h>
#include<thrust/device_vector.h>
#include <device_launch_parameters.h>
#include "GpuTimer.h"
__global__ void fillKernel(int *a, int n)
{
int tid = blockDim.x * blockIdx.x + threadIdx.x;
if(tid <n) a[tid] = tid;
}
void fill(int *d_a, int n)
{
int nThreadsPerBlock = 512;
int nBlock = n/nThreadsPerBlock + ((n/nThreadsPerBlock)?1:0);
fillKernel<<<nBlock, nThreadsPerBlock>>>(d_a, n);
}
int main()
{
const int N = 500000;
GpuTimer timer1, timer2;
thrust::device_vector<int> a(N);
fill(thrust::raw_pointer_cast(&a[0]), N);
timer1.Start();
int sumA = thrust::reduce(a.begin(), a.end(), 0);
timer1.Stop();
cout << "Thrust reduce costs " << timer1.Elapsed() << "ms." << endl;
int sumCheck = 0;
timer2.Start();
for(int i = 0; i < N; i++)
sumCheck += i;
timer2.Stop();
cout << "Traditional reduce costs " << timer2.Elapsed() << "ms." << endl;
if (sumA == sumCheck)
cout << "Correct!" << endl;
return 0;
}

Answer 1

You don't have a valid comparison. Your GPU code is doing this:
int sumA = thrust::reduce(a.begin(), a.end(), 0);
Your CPU code is doing this:
for(int i = 0; i < N; i++)
sumCheck += i;
There are so many problems with this methodology I'm not sure where to start. First of all, the GPU operation is a valid reduction which will give a valid result for any sequence of numbers in the vector a. It so happens that you have the sequence from 1 to N in a, but it doesn't have to be that way and it would still give a correct result. The CPU code only gives the correct answer for the specific sequence of 1 to N. Secondly, a smart compiler may be able to optimize the heck out of your CPU code, essentially reducing that entire loop to a constant assignment statement. (Summation from 1 to N is just (N+1)(N/2) isn't it?) I have no idea what optimizations may be going on under the hood on the CPU side.
A more valid comparison would be to do an actual arbitrary reduction in both cases. An example might be to benchmark thrust::reduce operating on a device vector vs. operating on a host vector. Or write your own serial CPU reduction code that actually operates on a vector, rather than summing the integers from 1 to N.
And as indicated in the comments if you're serious about wanting help, document things like the HW and SW platform you are running on, as well as provide all the code. I have no idea what GPUtimer does. I'm voting to close this as "too localized" because I don't think anyone would find this a useful comparison using a methodology like this.