Cuda Thrust获取细分中的上一个元素

Question

I've a vector of values and a vector of keys(indicating a segment)

v = [1, 1, 1, 2, 3, 5, 6]
k = [0, 0, 1, 1, 0, 2, 2]

For each element I want to know its previous element(in the same segment). It could be value or an index in the original vector doesn't matter.

So result should be(in case of value)

r = [nan, 1, nan, 1, 1, nan, 5]

you can use any element instead of nan , for remaining part of an algorithm no matters.

Probably I can archive it with exclusive segmented scan and max operation instead of sum . So two questions:

1. Is my approach correct?
2. Is any more elegant or efficient solution?

Answer 1

The desired functionality can be implemented using the following steps:

1. sort v by k to get equal key values next to each other; this has to be done through stable_sort_by_key as you want to retrieve the "previous" element, so ordering among elements with equal keys has to be preserved.

2. apply the following transformation to the sorted data:

if (previous element has the same key) then return value of previous element else return -1

---

The following code implements those steps:

#include <cstdint>
#include <iostream>

#include <thrust/host_vector.h>
#include <thrust/device_vector.h>  
#include <thrust/sort.h>
#include <thrust/transform.h>
#include <thrust/iterator/counting_iterator.h>
#include <thrust/iterator/zip_iterator.h>

#define PRINTER(name) print(#name, (name))
template <template <typename...> class V, typename T, typename ...Args>
void print(const char* name, const V<T,Args...> & v)
{
    std::cout << name << ":\t";
    thrust::copy(v.begin(), v.end(), std::ostream_iterator<T>(std::cout, "\t"));
    std::cout << std::endl;
}
template<typename... Iterators>
__host__ __device__
thrust::zip_iterator<thrust::tuple<Iterators...>> zip(Iterators... its)
{
    return thrust::make_zip_iterator(thrust::make_tuple(its...));
}

template <typename IteratorType, typename Integer>
struct prev_value
{
    prev_value(IteratorType first) : first(first){}

   template <typename Tuple>
   __host__ __device__
   Integer operator()(const Tuple& t)
   {
      const auto& index = thrust::get<0>(t);
      const auto& previousValue = thrust::get<1>(t);

      Integer result = -1;
      const auto& currentKey = *(first+index);
      const auto& previousKey = *(first+index-1);
      if(currentKey == previousKey)
      {
          result = previousValue;
      }

      return result;
   }

   IteratorType first;
};

template <typename Integer, typename IteratorType>
prev_value<IteratorType, Integer> make_prev_value(IteratorType first)
{
  return prev_value<IteratorType, Integer>(first);
}


int main(int argc, char** argv)
{
    using Integer = std::int32_t;
    using HostVec = thrust::host_vector<Integer>;
    using DeviceVec = thrust::device_vector<Integer>;

    Integer v[] = {1, 1, 1, 2, 3, 5, 6};
    Integer k[] = {0, 0, 1, 1, 0, 2, 2};

    Integer size = sizeof(k)/sizeof(k[0]);

    HostVec h_k(k, k+size);
    HostVec h_v(v, v+size);

    // copy data to device
    DeviceVec d_k = h_k;
    DeviceVec d_v = h_v;

    std::cout << "---- input data ----" << std::endl;
    PRINTER(d_k);    
    PRINTER(d_v);

    thrust::stable_sort_by_key(d_k.begin(), d_k.end(), d_v.begin());
    std::cout << "---- after sorting ----" << std::endl;
    PRINTER(d_k);    
    PRINTER(d_v);

    DeviceVec d_r(size, -1);
    auto op = make_prev_value<Integer>(d_k.begin());
    thrust::transform(zip(thrust::make_counting_iterator(Integer(1)), d_v.begin()),
                      zip(thrust::make_counting_iterator(size), d_v.end()),
                      d_r.begin()+1,
                      op);
    std::cout << "---- result ----" << std::endl;
    PRINTER(d_r);

    return 0;
}

output:

---- input data ----
d_k:    0   0   1   1   0   2   2   
d_v:    1   1   1   2   3   5   6   
---- after sorting ----
d_k:    0   0   0   1   1   2   2   
d_v:    1   1   3   1   2   5   6   
---- result ----
d_r:    -1  1   1   -1  1   -1  5