使用CUDA查找数组中大小未知的区域的最大值

Question

Say I have an array A[4000] of values that contains all different numbers [45,21,764,234,7,0,12,55,...]

Then I have another array B[4000] that denotes the location of regions in array A with the number 1 if it is a part of a region, and 0 if it is not. If the 1's are next to each other that means they are part of the same region, if they are not next to each other (there is a 0 in between the 1's ) then they are part of a different region.

ex. B = [1,1,1,0,1,1,0,0...] Means that I want to find the maximum value in the region of the first three numbers in array A , and the maximum number in the 5th and 6th numbers in array A, etc. So that I can produce an array C[4000] that holds the maximum values of A in each of the regions denoted by B , and a 0 in the areas that are not part of the regions.

So in this case C = [764,764,764,0,7,7,0,0...]

There can be anywhere from 0 to 2,000 regions , and the length of the regions can range from 2 to 4,000 numbers long . I never know beforehand how many regions there are or the different sizes of the regions.

I have been trying to come up with a kernel in CUDA that can achieve this result. It needs to be done as fast as possible since it in reality it will be used for images, this is just a simplified example. All of my ideas, such as using reduction, only work if there is only one region spans all 4000 numbers of array A . However, I do not think that I can use reduction here because there can be multiple regions in the array separated by 1 to 3996 spaces ( 0's ) and reduction will cause me to loose track of the separated regions. Or, the kernel has far too many loops and if statements in it to be fast such as

int intR = 0;
 while(B[blockIdx.x * blockDim.x + threadIdx.x + intR] > 0){
     intMaxR = intMaxR < A[blockIdx.x * blockDim.x + threadIdx.x + intR] ? A[blockIdx.x * blockDim.x + threadIdx.x + intR] : intMaxR;
     intR++;
 }

 int intL = 0;
 while(B[blockIdx.x * blockDim.x + threadIdx.x - intL] > 0){
     intMaxL = intMaxL < A[blockIdx.x * blockDim.x + threadIdx.x - intL] ? A[blockIdx.x * blockDim.x + threadIdx.x + intL] : intMaxL;
     intL++;
 }

 intMax =  intMaxR > intMaxL ? intMaxR : intMaxL;

 for(int i = 0; i < intR; i++){
     C[blockIdx.x * blockDim.x + threadIdx.x + i] = intMax;
 }
 for(int i = 0; i < intL; i++){
     C[blockIdx.x * blockDim.x + threadIdx.x - i] = intMax;
 }

Clearly the code is slow even with shared memory, and isn't really taking advantage of the parallel nature of CUDA. Does anyone have any idea on how or if this can be done efficiently in CUDA?

Thanks in advance.

Answer 1

One possible approach would be to use thrust .

A possible sequence would be like this:

1. use thrust::reduce_by_key to generate the max values for each range.
2. use thrust::adjacent_difference to delineate the start of each range
3. use an inclusive scan on the results of step 2 to generate the gather indices, ie the indices that will be used to select the reduced value (results from step 1) that will go in each location of the output vector.
4. Use thrust::gather_if to selectively place the reduced values into appropriate locations (where there is a 1 in the B vector) in the output vector, using the gather indices generated in step 3.

Here's a fully worked code demonstrating this, using A and B vectors like your example:

#include <iostream>
#include <thrust/device_vector.h>
#include <thrust/adjacent_difference.h>
#include <thrust/reduce.h>
#include <thrust/copy.h>
#include <thrust/transform_scan.h>
#include <thrust/iterator/discard_iterator.h>
#include <thrust/iterator/transform_iterator.h>
#include <thrust/functional.h>

#define DSIZE 8

template <typename T>
struct abs_val : public thrust::unary_function<T, T>
{
  __host__ __device__
  T operator()(const T& x) const
  {
    if (x<0) return -x;
    else return x;
  }
};

template <typename T>
struct subtr : public thrust::unary_function<T, T>
{
  const T val;
  subtr(T _val): val(_val) {}
  __host__ __device__
  T operator()(const T& x) const
  {
    return  x-val;
  }
};

int main(){

  int A[DSIZE] = {45,21,764,234,7,0,12,55};
  int B[DSIZE] = {1,1,1,0,1,1,0,0};
  thrust::device_vector<int> dA(A, A+DSIZE);
  thrust::device_vector<int> dB(B, B+DSIZE);
  thrust::device_vector<int> dRed(DSIZE);
  thrust::device_vector<int> diffB(DSIZE);
  thrust::device_vector<int> dRes(DSIZE);

  thrust::reduce_by_key(dB.begin(), dB.end(), dA.begin(), thrust::make_discard_iterator(), dRed.begin(), thrust::equal_to<int>(), thrust::maximum<int>());
  thrust::adjacent_difference(dB.begin(), dB.end(), diffB.begin());
  thrust::transform_inclusive_scan(diffB.begin(), diffB.end(), diffB.begin(), abs_val<int>(), thrust::plus<int>());
  thrust::gather_if(thrust::make_transform_iterator(diffB.begin(), subtr<int>(B[0])), thrust::make_transform_iterator(diffB.end(), subtr<int>(B[0])), dB.begin(), dRed.begin(), dRes.begin());
  thrust::copy(dRes.begin(), dRes.end(), std::ostream_iterator<int>(std::cout, " "));
  std::cout  << std::endl;
  return 0;
}

Notes about the example:

1. reduce_by_key is generating reduced values (maximums) for each consecutive 0 sequence or 1 sequence in B. You only really need the maximums for the 1 sequences. We will discard the 0 sequence maximums via the gather_if function.
2. I allow for the possibility that the B vector may start with either a 1 sequence or a 0 sequence, by using the transform_iterator treatment of the vector result of step 2, subtracting the first value of the B vector from each gather index.
3. The adjacent_difference operation will produce either a 1 or -1 to delineate the start of a new sequence. I use the transform_inclusive_scan variant with the abs_val functor to treat these equally, for scan purposes (ie generation of gather indices).

4. The above code should produce results matching your desired C output vector, like this:

    $ nvcc -arch=sm_20 -o t53 t53.cu $ ./t53 764 764 764 0 7 7 0 0 $ 

We can use thrust::placeholders to further simplify the above code, eliminating the need for the extra functor definitions:

#include <iostream>
#include <thrust/device_vector.h>
#include <thrust/adjacent_difference.h>
#include <thrust/reduce.h>
#include <thrust/copy.h>
#include <thrust/transform_scan.h>
#include <thrust/iterator/discard_iterator.h>
#include <thrust/iterator/transform_iterator.h>
#include <thrust/functional.h>

#define DSIZE 2000000
using namespace thrust::placeholders;

typedef int mytype;

int main(){

  mytype *A = (mytype *)malloc(DSIZE*sizeof(mytype));
  int *B = (int *)malloc(DSIZE*sizeof(int));
  for (int i = 0; i < DSIZE; i++){
    A[i] = (rand()/(float)RAND_MAX)*10.0f;
    B[i] = rand()%2;}
  thrust::device_vector<mytype> dA(A, A+DSIZE);
  thrust::device_vector<int> dB(B, B+DSIZE);
  thrust::device_vector<mytype> dRed(DSIZE);
  thrust::device_vector<int> diffB(DSIZE);
  thrust::device_vector<mytype> dRes(DSIZE);

  cudaEvent_t start, stop;
  cudaEventCreate(&start);
  cudaEventCreate(&stop);
  cudaEventRecord(start);
  thrust::reduce_by_key(dB.begin(), dB.end(), dA.begin(), thrust::make_discard_iterator(), dRed.begin(), thrust::equal_to<mytype>(), thrust::maximum<mytype>());
  thrust::adjacent_difference(dB.begin(), dB.end(), diffB.begin());
  thrust::transform_inclusive_scan(diffB.begin(), diffB.end(), diffB.begin(), _1*_1, thrust::plus<int>());
  thrust::gather_if(thrust::make_transform_iterator(diffB.begin(), _1 - B[0]), thrust::make_transform_iterator(diffB.end(), _1 - B[0]), dB.begin(), dRed.begin(), dRes.begin());
  cudaEventRecord(stop);
  cudaEventSynchronize(stop);
  float et;
  cudaEventElapsedTime(&et, start, stop);
  std::cout<< "elapsed time: " << et << "ms " << std::endl;
  thrust::copy(dRes.begin(), dRes.begin()+10, std::ostream_iterator<mytype>(std::cout, " "));
  std::cout  << std::endl;
  return 0;
}

(I've modified the above placeholders code to also include generation of a larger size data set, as well as some basic timing apparatus.)