Question

我有一个线性化矩阵存储为thrust::device_vector<int>

基本上，它是一个维数为nc x nv的矩阵，存储在这个大小的线性数组中。

我想从这个矩阵中获取唯一的行。如果至少有一个元素不同，则两行是唯一的。

我想使用CUDA thrust::sort和thrust::unique函数来执行此操作。我相信我需要构造一个对应于每一行的迭代器，然后使用一个比较行元素的仿函数调用sort。但我不清楚如何做到这一点。

使用跨步范围迭代器将允许我指定每行的开始但是函数的实现不清楚。

这似乎是一个应该可以通过推力解决的问题。还有更好的方法吗？

Answer 1

我认为你的方法是可行的。我建议排序一个单独的行索引数组，以便生成的行索引按矩阵行的排序顺序排序，而不是直接对矩阵进行排序。

我们将创建一个排序函子，它接受两个行索引，并使用它们索引到矩阵的适当行。然后，该排序仿函数将使用逐个元素的比较来对两个指示的行进行排序。

我们将使用类似的方法（传递两个行索引）来实现＆＃34;相等＆＃34;仿函数传递给thrust::unique。然后，相等函数将测试两个指示的行是否相等。我可以像在排序函数中一样使用for循环，逐个元素地测试相等，但是选择使用嵌套的thrust::mismatch算法来进行变换。

这是一个有效的例子：

$ cat t1033.cu
#include <thrust/device_vector.h>
#include <thrust/sort.h>
#include <thrust/unique.h>
#include <thrust/sequence.h>
#include <assert.h>
#include <iostream>
#include <thrust/execution_policy.h>
#include <thrust/mismatch.h>


typedef int mytype;

struct my_sort_func
{
  int cols;
  mytype *data;
  my_sort_func(int _cols, mytype *_data) : cols(_cols),data(_data) {};
  __host__ __device__
  bool operator()(int r1, int r2){
    for (int i = 0; i < cols; i++){
      if (data[cols*r1+i] < data[cols*r2+i])
        return true;
      else if (data[cols*r1+i] > data[cols*r2+i])
        return false;}
    return false;
    }
};

struct my_unique_func
{
  int cols;
  mytype *data;
  my_unique_func(int _cols, mytype *_data) : cols(_cols),data(_data) {};
  __device__
  bool operator()(int r1, int r2){
    thrust::pair<mytype *, mytype *> res = thrust::mismatch(thrust::seq, data+(r1*cols), data+(r1*cols)+cols, data+(r2*cols));
    return (res.first == data+(r1*cols)+cols);
    }
};

int main(){

  const int ncols = 3;
  mytype data[] = { 1, 2, 3, 1, 2, 3, 1, 3, 5, 2, 3, 4, 1, 2, 3, 1, 3, 5};
  size_t dsize = sizeof(data)/sizeof(mytype);
  assert ((dsize % ncols) == 0);
  int nrows = dsize/ncols;
  thrust::device_vector<mytype> d_data(data, data+dsize);
  thrust::device_vector<int> rowidx(nrows);  // reference rows by their index
  thrust::sequence(rowidx.begin(), rowidx.end());
  thrust::sort(rowidx.begin(), rowidx.end(), my_sort_func(ncols, thrust::raw_pointer_cast(d_data.data())));
  int rsize = thrust::unique(rowidx.begin(), rowidx.end(), my_unique_func(ncols, thrust::raw_pointer_cast(d_data.data()))) - rowidx.begin();
  thrust::host_vector<int> h_rowidx = rowidx;
  std::cout << "Unique rows: " << std::endl;
  for (int i = 0; i < rsize; i++){
    for (int j = 0; j < ncols; j++) std::cout << data[h_rowidx[i]*ncols+j] << ",";
    std::cout << std::endl;}
  return 0;
}
$ nvcc -o t1033 t1033.cu
$ ./t1033
Unique rows:
1,2,3,
1,3,5,
2,3,4,
$

注意：

我怀疑如果输入矩阵被转置，整体性能会提高，我们正在比较列（在转置矩阵中）而不是行。它可能为排序操作提供一些好处，我怀疑它也可能为独特的操作提供一些好处。然而，给定的代码与您在问题中的描述相匹配，如果在列案例中如何执行它，它应该是一个非常好的路线图，尽管它必须为此重构。
此方法实际上并未重新排序矩阵行。为了提高效率，我想避免做大量的数据移动，因为问题陈述似乎并不依赖于它。如果你确实想要一个按排序顺序排列矩阵行的中间数据集，我仍然会建议进行上面的排序操作，然后使用结果在一个操作中重新排序矩阵，使用两种可能的方法之一：分散/收集操作，或thrust::permuation_iterator与thrust::copy操作相结合。
稍微聪明一点，也可以在排序仿函数中使用嵌套的thrust::mismatch操作，代替for循环。

Linearized Matrix CUDA的独特行

1 个答案: