Question

上下文

我正在尝试使用CUDA实现Boruvka MST算法，但是根本不需要理解算法来帮助我。

问题

所以，让我来描述一下这个问题：我有一个图表，存储在边缘格式列表中（一个边缘数组，每个边缘用2个相邻的顶点ID表示，它的重量）。

但是，（非常重要！）优化对设备内存的访问我不是将边存储为单个结构数组，而是存储为三个独立的数组：

int * src_ids
int * dst_ids
float * weights

要访问单个边，可以使用与此数组相同的索引进行迭代：

src_ids [I]
dst_ids [I]
权重[I]

现在，当我描述数据格式时，问题是

我想从以下条件中删除这三个数组元素（边）：

1）如果src_id [i] == dst_id [i]，则删除第i个边

2）如果src_id [i]！= dst_id [i]，但是有另一个边缘j具有相同的src_id [j]和dst_id [j]，但权重较小[j] ，而不是删除第i个边缘

换句话说，我想：

删除边缘
连接相同的顶点
并复制非最小边

第一个很简单：我可以使用thrust :: remove_if或扫描，如parallel removal of elements from an array所述，删除具有相同ID的边。（我已经通过扫描实现了第二个变体。）

但是我没有实现第二部分，删除重复的边缘。我有一个想法，但不确定这种方法是否有效。让我来形容一下吧。

首先，我们将按以下方式重新排序（或排序）这三个数组：

首先按第一个（src_id）ID对边进行排序。
然后使用相同的第一个ID和第二个（dst_id）id对边进行排序。
最后，根据权重对两个相等的ID进行排序。

当所有边缘都以这种方式排序时，删除重复的非最小边缘相对容易：

我们只看前一个边缘（i-1）-th，
如果它具有相同的ID，但重量较轻，则标记要移除的当前边缘。
然后我们只需要应用扫描，类似于（1 src_id [i] == dst_id [i]）条件。

问题*

但问题是我不知道如何有效地对这三种数组进行排序。（可能我可以在转换后的数据，单个数组结构上使用thrust :: sort，但它似乎会非常慢，最好不要删除重复的边缘）

或者有人可以建议更好的方法来删除重复的边缘而不用这种方式对它们进行排序。

感谢您阅读本文，任何建议表示赞赏！

Answer 1

您可以使用thrust::zip_iterator轻松地在一个thrust::sort来电中对多个向量进行排序。

主要思想是：

auto z = thrust::make_zip_iterator(thrust::make_tuple(d_src_ids.begin(),d_dst_ids.begin(), d_weights.begin()));
thrust::sort(z,z+N);

这将首先按照第一个向量对三个向量进行排序，然后按第二个向量排序，然后按第三个向量排序。

以下代码显示了如何在完全解决的示例中使用它。它使用自定义仿函数（从thrust::detail复制）在单个调用中执行remove_if步骤，而无需存储中间结果。

#include <thrust/sort.h>
#include <thrust/iterator/zip_iterator.h>
#include <iostream>
#include <thrust/copy.h>
#include <thrust/device_vector.h>
#include <thrust/remove.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;
}

// copied from https://github.com/thrust/thrust/blob/master/thrust/detail/range/head_flags.h

#include <thrust/iterator/transform_iterator.h>
#include <thrust/iterator/zip_iterator.h>
#include <thrust/iterator/counting_iterator.h>
#include <thrust/tuple.h>
#include <thrust/functional.h>

template<typename RandomAccessIterator,
         typename BinaryPredicate = thrust::equal_to<typename thrust::iterator_value<RandomAccessIterator>::type>,
         typename ValueType = bool,
         typename IndexType = typename thrust::iterator_difference<RandomAccessIterator>::type>
  class head_flags
{
  // XXX WAR cudafe issue
  //private:
  public:
    struct head_flag_functor
    {
      BinaryPredicate binary_pred; // this must be the first member for performance reasons
      IndexType n;

      typedef ValueType result_type;

      __host__ __device__
      head_flag_functor(IndexType n)
        : binary_pred(), n(n)
      {}

      __host__ __device__
      head_flag_functor(IndexType n, BinaryPredicate binary_pred)
        : binary_pred(binary_pred), n(n)
      {}

      template<typename Tuple>
      __host__ __device__ __thrust_forceinline__
      result_type operator()(const Tuple &t)
      {
        const IndexType i = thrust::get<0>(t);

        // note that we do not dereference the tuple's 2nd element when i <= 0
        // and therefore do not dereference a bad location at the boundary
        return (i == 0 || !binary_pred(thrust::get<1>(t), thrust::get<2>(t)));
      }
    };

    typedef thrust::counting_iterator<IndexType> counting_iterator;

  public:
    typedef thrust::transform_iterator<
      head_flag_functor,
      thrust::zip_iterator<thrust::tuple<counting_iterator,RandomAccessIterator,RandomAccessIterator> >
    > iterator;

    __host__ __device__
    head_flags(RandomAccessIterator first, RandomAccessIterator last)
      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
                                                head_flag_functor(last - first))),
        m_end(m_begin + (last - first))
    {}

    __host__ __device__
    head_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
                                                head_flag_functor(last - first, binary_pred))),
        m_end(m_begin + (last - first))
    {}

    __host__ __device__
    iterator begin() const
    {
      return m_begin;
    }

    __host__ __device__
    iterator end() const
    {
      return m_end;
    }

    template<typename OtherIndex>
    __host__ __device__
    typename iterator::reference operator[](OtherIndex i)
    {
      return *(begin() + i);
    }

  private:
    iterator m_begin, m_end;
};

template<typename RandomAccessIterator>
__host__ __device__
head_flags<RandomAccessIterator>
  make_head_flags(RandomAccessIterator first, RandomAccessIterator last)
{
  return head_flags<RandomAccessIterator>(first, last);
}

int main()
{
  const int N = 6;
  int src_ids[] = {3,1,2,2,3,3};
  int dst_ids[] = {2,2,3,3,1,1};
  float weights[] = {1,2,8,4,5,6};

  thrust::device_vector<int> d_src_ids(src_ids,src_ids+N);
  thrust::device_vector<int> d_dst_ids(dst_ids,dst_ids+N);
  thrust::device_vector<float> d_weights(weights,weights+N); 

  std::cout << "--- initial values ---" << std::endl;
  PRINTER(d_src_ids);
  PRINTER(d_dst_ids);
  PRINTER(d_weights);


  auto z = thrust::make_zip_iterator(thrust::make_tuple(d_src_ids.begin(),d_dst_ids.begin(), d_weights.begin()));

  thrust::sort(z,z+N);

  std::cout << "--- after sort ---" << std::endl;
  PRINTER(d_src_ids);
  PRINTER(d_dst_ids);
  PRINTER(d_weights);

  auto z2 = thrust::make_zip_iterator(thrust::make_tuple(d_src_ids.begin(),d_dst_ids.begin()));


  auto t = make_head_flags(z2,z2+N);
  using namespace thrust::placeholders;
  auto end = thrust::remove_if(z,z+N, t.begin(), !_1);
  int new_size = thrust::get<0>(end.get_iterator_tuple()) - d_src_ids.begin();

  d_src_ids.resize(new_size);
  d_dst_ids.resize(new_size);
  d_weights.resize(new_size);

  std::cout << "--- after remove_if ---" << std::endl;
  PRINTER(d_src_ids);
  PRINTER(d_dst_ids);
  PRINTER(d_weights);


  return 0;
}

<强>输出：

--- initial values ---
d_src_ids:  3   1   2   2   3   3   
d_dst_ids:  2   2   3   3   1   1   
d_weights:  1   2   8   4   5   6   
--- after sort ---
d_src_ids:  1   2   2   3   3   3   
d_dst_ids:  2   3   3   1   1   2   
d_weights:  2   4   8   5   6   1   
--- after remove_if ---
d_src_ids:  1   2   3   3   
d_dst_ids:  2   3   1   2   
d_weights:  2   4   5   1

从CUDA数组中删除元素

1 个答案: