Question

我有一个存储在GPU全局内存中的几百万个值的数组。他们中的大多数都是零，除了几千。这些值是设备上的计算结果。

我想尽可能快地找到1024最大值及其指数。

有人有任何建议吗？

Answer 1

[此答案已根据Robert Crovella的评论进行了编辑]

对于要实施的简单方法，我建议按降序使用thrust::sort或thrust::sort_by_key。通过thrust::greater<int>()可以在两种情况下按降序排序。

最简单的方法是按降序使用thrust::sort，以便您可以按顺序访问从最大到最小的已排序元素。

如果要保留原始数据向量的副本以及排序过程的索引，可以按降序使用thrust::sort_by_key。假设您感兴趣的数组包含N个元素。您可以按thrust::sequence创建一系列递增指数。在您的情况下，键是N元素的数组，而值是由thrust::sequence生成的数组。在按降序使用thrust::sort_by_key之后，values数组将包含您可以访问第一大元素的索引。

请注意，当您的数据数组是稀疏时，您实际上感兴趣，因此您可能只想对数据数组的非消失值进行排序。如果您只想存储数组的非消失值，则不需要通过d_indices创建索引向量thrust::sequence，但它足以存储在索引中非消失的数据值。如果您已经有一个包含0的数组，那么您可以在thrust::partition执行排序操作之前提取非消失值。

以下是显示所有上述方法的完整示例。

#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
#include <thrust/reverse.h>
#include <thrust/copy.h>    
#include <thrust/sort.h>
#include <cstdlib>
#include <iostream>

using namespace std;

struct is_not_zero
{
    __host__ __device__ bool operator()(const int &x) { return x != 0; }
};

void main(void)
{

    const int N = 8;

    // --- Generate the data vector of random values on the host 
    thrust::host_vector<int> h_vec(N);
    thrust::generate(h_vec.begin(), h_vec.end(), rand);

    // --- Move the data vector to the device
    thrust::device_vector<int> d_vec=h_vec;

    // --- Make two copies of the data vector
    thrust::device_vector<int> d_vec_copy=d_vec;
    thrust::device_vector<int> d_vec_another_copy=d_vec;

    // --- Push back some zero to test thrust::partition
    d_vec_another_copy.push_back(0);
    d_vec_another_copy.push_back(0);
    d_vec_another_copy.push_back(0);

    // --- Display the result
    for(int i = 0; i<N+3; i++)
        cout << d_vec_another_copy[i] << endl;
    cout << endl;

    // --- Generate the indices vector
    thrust::device_vector<int> d_indices(N);
    thrust::sequence(d_indices.begin(), d_indices.end(), 0, 1);

    // --- Sort the indices vector by using the data vector as key in descending order
    thrust::sort_by_key(d_vec.begin(), d_vec.end(), d_indices.begin(),thrust::greater<int>());

    // --- Display the result
    for(int i = 0; i<N; i++) {
        int index = d_indices[i];
        cout << "Original: " << d_vec_copy[index] << " Sorted: " << d_vec[i] << endl;
    }
    cout << endl;

    // --- Use sort in descending order and forget the initial ordering
    thrust::sort(d_vec_copy.begin(), d_vec_copy.end(), thrust::greater<int>());

    // --- Display the result
    for(int i = 0; i<N; i++)
        cout << d_vec_copy[i] << endl;
    cout << endl;

    // --- Use partition prior to sort to extract the non-vanishing elements in descending order
    thrust::partition(d_vec_another_copy.begin(), d_vec_another_copy.end(), is_not_zero());     
    thrust::sort(d_vec_another_copy.begin(), d_vec_another_copy.end(), thrust::greater<int>());

    // --- Display the result
    for(int i = 0; i<N; i++)
        cout << d_vec_another_copy[i] << endl;
    cout << endl;

    getchar();

}

CUDA：查找稀疏数组的N个最大值

1 个答案: