我有一个相当简单的问题，但我想不出一个优雅的解决方案。

我有一个 Thrust 代码，它生成包含值的相同大小的 c vector 。假设这些 c vector 中的每一个都有一个索引。我想为每个 vector 位置获取值最低的 c vector 的索引:

例子:

C0 =     (0,10,20,3,40)
C1 =     (1,2 ,3 ,5,10)

作为结果，我会得到一个 vector ，其中包含具有最低值的 C vector 的索引:

result = (0,1 ,1 ,0,1)

我考虑过使用 thrust zip 迭代器来完成它，但遇到了一些问题:我可以压缩所有 c vector 并实现一个任意转换，它接受一个元组并返回其最低的索引值，但是:

1. 如何迭代元组的内容？
2. 据我所知，元组最多只能存储 10 个元素，而且 10 c 个 vector 可以更多。

然后我考虑过这样做:不是让 c 单独的 vector ，而是将它们全部附加到一个 vector C 中，然后生成引用位置和按键执行稳定排序，这会将来自同一位置的 vector 条目重新组合在一起。在将给出的示例中:

C =      (0,10,20,3,40,1,2,3,5,10)
keys =   (0,1 ,2 ,3,4 ,0,1,2,3,4 )
after stable sort by key:
output = (0,1,10,2,20,3,3,5,40,10)
keys =   (0,0,1 ,1,2 ,2,3,3,4 ,4 )

然后使用 vector 中的位置生成键，使用 c vector 的索引压缩输出，然后使用自定义仿函数执行键归约，每次归约输出索引与最低值。在示例中:

input =  (0,1,10,2,20,3,3,5,40,10)
indexes= (0,1,0 ,1,0 ,1,0,1,0 ,1)
keys =   (0,0,1 ,1,2 ,2,3,3,4 ,4)
after reduce by keys on zipped input and indexes:
output = (0,1,1,0,1)

但是，如何为 reduce by key 操作编写这样的仿函数？

最佳答案

因为 vector 的长度必须相同。最好将它们串联在一起，并将它们视为矩阵 C。

那么您的问题就变成了查找行主矩阵中每一列的最小元素的索引。可按如下方式解决。

1. 将行优先改为列优先；
2. 找到每列的索引。

在第1步中，您提出使用stable_sort_by_key重新排列元素顺序，这不是一个有效的方法。由于给定矩阵的#row 和#col 可以直接计算重排。总之，它可以用置换迭代器来完成:

thrust::make_permutation_iterator(
    c.begin(),
    thrust::make_transform_iterator(
        thrust::make_counting_iterator((int) 0),
        (_1 % row) * col + _1 / row)
)

在第 2 步中，reduce_by_key 可以完全按照您的意愿进行。在您的情况下，缩减二元运算仿函数很容易，因为已经定义了对元组(压缩 vector 的元素)的比较来比较元组的第一个元素，并且推力支持它作为

thrust::minimum< thrust::tuple<float, int> >()

整个程序如下所示。 Thrust 1.6.0+ 是必需的，因为我在花哨的迭代器中使用占位符。

#include <iterator>
#include <algorithm>

#include <thrust/device_vector.h>
#include <thrust/iterator/counting_iterator.h>
#include <thrust/iterator/transform_iterator.h>
#include <thrust/iterator/permutation_iterator.h>
#include <thrust/iterator/zip_iterator.h>
#include <thrust/iterator/discard_iterator.h>
#include <thrust/reduce.h>
#include <thrust/functional.h>

using namespace thrust::placeholders;

int main()
{

    const int row = 2;
    const int col = 5;
    float initc[] =
            { 0, 10, 20, 3, 40, 1, 2, 3, 5, 10 };
    thrust::device_vector<float> c(initc, initc + row * col);

    thrust::device_vector<float> minval(col);
    thrust::device_vector<int> minidx(col);

    thrust::reduce_by_key(
            thrust::make_transform_iterator(
                    thrust::make_counting_iterator((int) 0),
                    _1 / row),
            thrust::make_transform_iterator(
                    thrust::make_counting_iterator((int) 0),
                    _1 / row) + row * col,
            thrust::make_zip_iterator(
                    thrust::make_tuple(
                            thrust::make_permutation_iterator(
                                    c.begin(),
                                    thrust::make_transform_iterator(
                                            thrust::make_counting_iterator((int) 0), (_1 % row) * col + _1 / row)),
                            thrust::make_transform_iterator(
                                    thrust::make_counting_iterator((int) 0), _1 % row))),
            thrust::make_discard_iterator(),
            thrust::make_zip_iterator(
                    thrust::make_tuple(
                            minval.begin(),
                            minidx.begin())),
            thrust::equal_to<int>(),
            thrust::minimum<thrust::tuple<float, int> >()
    );

    std::copy(minidx.begin(), minidx.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
    return 0;
}

剩下的两个问题可能会影响性能。

1. 必须输出最小值，这不是必需的；
2. reduce_by_key 专为长度可变的段而设计，它可能不是减少相同长度段的最快算法。

编写自己的内核可能是获得最高性能的最佳解决方案。

关于c++ - 使用 CUDA Thrust 确定每个矩阵列中的最小元素及其位置，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17698969/