Thrust is so slow as finding max and min of an array? - cuda

Question

Here is my kernel call code by thrust
inline void find_min_max(thrust::device_vector<Npp8u> dev_vec, Npp8u *min, Npp8u *max){
thrust::pair<thrust::device_vector<Npp8u>::iterator,thrust::device_vector<Npp8u>::iterator> tuple;
tuple = thrust::minmax_element(dev_vec.begin(),dev_vec.end());
*min = *(tuple.first);
*max = *tuple.second;
}
I also implement same algorithm with my raw CUDA kernel by using map-reduce paradigm and also simple CPU code. As a result of the measure I see that thrust is the slowest significantly.
For brevity, I used events for measuring raw CUDA and thrust code. If events work for thrust benchmarking I am pretty sure that I measure execution time correctly.
Here is the measurement segment;
....
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaEventRecord(start, 0);
thrust::device_vector<Npp8u> image_dev(imageHost, imageHost+N);
// Device vector allocation
find_min_max(image_dev,&min,&max);
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
float elapsedTime1;
cudaEventElapsedTime(&elapsedTime1, start, stop);
cudaEventDestroy(start);
cudaEventDestroy(stop);
totalTime1 = elapsedTime1/1000
....
My real question, is there any possibility to have better approach other than the simple minmax_element function in thrust?
My machine specs: It is asus k55v laptop with GeForce 635M and i7 processor.
And all codes for Thrust code and CPU code

Answer 1

You haven't shown any of your code that you're comparing to thrust, you haven't given any machine specifications (GPU, CPU, etc.) and you also haven't told us what were the actual measured times.
Nevertheless, I took your code and created a test case out of it, comparing thrust vs. STL (since you haven't shown your CPU code or any other implementation):
#include <stdio.h>
#include <thrust/device_vector.h>
#include <thrust/extrema.h>
#include <thrust/pair.h>
#include <algorithm>
#include <time.h>
#define N 1000000
#define LOOPS 1000
inline void find_min_max(thrust::device_vector<int> &dev_vec, int *min, int *max){
thrust::pair<thrust::device_vector<int>::iterator,thrust::device_vector<int>::iterator> tuple;
tuple = thrust::minmax_element(dev_vec.begin(),dev_vec.end());
*min = *(tuple.first);
*max = *tuple.second;
}
int main(){
int minele, maxele;
std::vector<int> a;
for (int i=0; i<N; i++)
a.push_back(rand());
thrust::host_vector<int> h_a(N);
thrust::copy(a.begin(), a.end(), h_a.begin());
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaEventRecord(start, 0);
for (int i=0; i < LOOPS; i++){
thrust::device_vector<int> d_a = h_a;
find_min_max(d_a,&minele,&maxele);
}
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
float elapsedTime1, totalTime1;
cudaEventElapsedTime(&elapsedTime1, start, stop);
cudaEventDestroy(start);
cudaEventDestroy(stop);
totalTime1 = elapsedTime1/(1000*LOOPS);
printf("thrust min element = %d, max element = %d\n", minele, maxele);
printf("thrust time = %f\n", totalTime1);
clock_t t;
t = clock();
std::vector<int>::iterator resultmax, resultmin;
for (int i = 0; i<LOOPS; i++){
resultmax = std::max_element(a.begin(), a.end());
resultmin = std::min_element(a.begin(), a.end());
}
t = clock() - t;
printf("STL min element = %d, max element = %d\n", *resultmin, *resultmax);
printf("STL time = %f\n", ((float)t)/(CLOCKS_PER_SEC*LOOPS));
return 0;
}
I compiled this code using CUDA 5.0, RHEL 5.5, Xeon X5560 2.8GHz CPU, and a Quadro 5000 GPU, which is a cc 2.0 device that is somewhat slower than an M2050 (11 SMs vs. 14), these are the results:
thrust min element = 1210, max element = 2147480021
thrust time = 0.001741
STL min element = 1210, max element = 2147480021
STL time = 0.004520
Even if we make allowance for the fact that I am using 2 function calls in STL to get min and max, (knowing that c++11 standard includes a single minmax function call) and cut the STL time in half, thrust is faster.
If you want to discuss why your case may be special, please include a complete, compilable, simple comparison code, similar to what I have provided, along with your machine specifications, and the actual timing results.
As a minor optimization comment, if you pass the device_vector to your find_min_max function by reference (&) rather than by value, it will run a bit quicker.
In my case, if I take the host-> device_vector copy out of the timing loop, my thrust time drops from 0.001741 seconds to 0.000387 seconds, indicating that the host-> device copy is about 78% of the total thrust time.
EDIT: Now that you've posted your code (although you don't mention the timings you get) I ran it with a 512x512 lena grayscale image, and got the following results on my setup:
$ ./cpu
Version: P5
Comment: # Created by Imlib
Width: 512 Height: 512
Max value: 255
ELAPSED TIME -AVG finding max and min: 0.0014437
ELAPSED TIME -AVG finding max and min: 0.0038715
$ ./thr
Load PGM file.
Version: P5
Comment: # Created by Imlib
Width: 512 Height: 512
Max value: 255
ELAPSED TIME -AVG for kernel 1: 0.000658944
ELAPSED TIME -AVG for kernel 2: 0.000179552
$
So it seems to me that even for your code, thrust is faster on my setup.