在CUDA中获取多个数组的唯一元素

时间:2015-10-22 13:44:09

标签: cuda thrust

问题在于: 有多个数组,例如2000个数组,但每个数组只有256个整数。并且整数的范围相当大,例如[0,1000000]。

我想获取每个数组的唯一元素,换句话说,删除重复的元素。 我有两个解决方案:

  1. 使用Thrust为每个数组获取唯一元素,因此我必须执行2000次thrust::unique。但是每个阵列都很小,这种方式可能无法获得良好的性能。

  2. 在cuda内核中实现哈希表,在每个块中使用2000个块,256个线程。并利用共享内存实现哈希表,然后每个块都会产生一个元素唯一的数组。

  3. 以上两种方法看起来不专业,有没有优雅的方法来解决CUDA的问题?

2 个答案:

答案 0 :(得分:3)

如果修改数据的方式类似于此SO问题,则可以使用thrust::uniqueSegmented Sort with CUDPP/Thrust

为简化起见,我们假设每个数组包含per_array个元素,并且总共有array_num个数组。每个元素都在[0,max_element]范围内。

dataper_array=4array_num=3的演示max_element=2可能如下所示:

data = {1,0,1,2},{2,2,0,0},{0,0,0,0}

要表示每个元素对相应数组的成员资格,我们使用以下flags

flags = {0,0,0,0},{1 1 1 1},{2,2,2,2}

为了获得每个分段数据集数组的唯一元素,我们需要执行以下步骤:

  1. 转换data,以便每个数组i的元素都在唯一范围内[i*2*max_element,i*2*max_element+max_element]

    data = data + flags*2*max_element
    data = {1,0,1,2},{6,6,4,4},{8,8,8,8}
    
  2. 对转换后的数据进行排序:

    data = {0,0,1,2},{4,4,6,6},{8,8,8,8}
    
  3. 使用data作为键并flags作为值应用thrust::unique_by_key

    data  = {0,1,2}{4,6}{8}
    flags = {0,0,0}{1,1}{2}
    
  4. data转换回原始值:

    data  = data - flags*2*max_element
    data  = {0,1,2}{0,2}{0}
    
  5. max_element的最大值受用于表示data的整数的大小限制。如果它是带n位的无符号整数:

    max_max_element(n,array_num) = 2^n/(2*(array_num-1)+1)
    

    根据您的array_num=2000,您将获得32位和64位无符号整数的以下限制:

    max_max_element(32,2000) = 1074010
    max_max_element(64,2000) = 4612839228234447
    

    以下代码实现了上述步骤:

    <强> unique_per_array.cu

    #include <thrust/device_vector.h>
    #include <thrust/extrema.h>
    #include <thrust/transform.h>
    #include <thrust/iterator/counting_iterator.h>
    #include <thrust/functional.h>
    #include <thrust/sort.h>
    #include <thrust/unique.h>
    #include <thrust/copy.h>
    
    #include <iostream>
    #include <cstdint>
    
    #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;
    }
    
    int main()
    { 
        typedef uint32_t Integer;
    
        const std::size_t per_array = 4;
        const std::size_t array_num = 3;
    
        const std::size_t total_count = array_num * per_array;
    
        Integer demo_data[] = {1,0,1,2,2,2,0,0,0,0,0,0};
    
        thrust::device_vector<Integer> data(demo_data, demo_data+total_count);    
    
        PRINTER(data);
    
        // if max_element is known for your problem,
        // you don't need the following operation 
        Integer max_element = *(thrust::max_element(data.begin(), data.end()));
        std::cout << "max_element=" << max_element << std::endl;
    
        using namespace thrust::placeholders;
    
        // create the flags
    
        // could be a smaller integer type as well
        thrust::device_vector<uint32_t> flags(total_count);
    
        thrust::counting_iterator<uint32_t> flags_cit(0);
    
        thrust::transform(flags_cit,
                          flags_cit + total_count,
                          flags.begin(),
                          _1 / per_array);
        PRINTER(flags);
    
    
        // 1. transform data into unique ranges  
        thrust::transform(data.begin(),
                          data.end(),
                          thrust::counting_iterator<Integer>(0),
                          data.begin(),
                          _1 + (_2/per_array)*2*max_element);
        PRINTER(data);
    
        // 2. sort the transformed data
        thrust::sort(data.begin(), data.end());
        PRINTER(data);
    
        // 3. eliminate duplicates per array
        auto new_end = thrust::unique_by_key(data.begin(),
                                             data.end(),
                                             flags.begin());
    
        uint32_t new_size = new_end.first - data.begin();
        data.resize(new_size);
        flags.resize(new_size);
    
        PRINTER(data);
        PRINTER(flags);
    
        // 4. transform data back
        thrust::transform(data.begin(),
                          data.end(),
                          flags.begin(),
                          data.begin(),
                          _1 - _2*2*max_element);
    
        PRINTER(data);
    
    }    
    

    编译并运行产量:

    $ nvcc -std=c++11 unique_per_array.cu -o unique_per_array && ./unique_per_array
    
    data:   1   0   1   2   2   2   0   0   0   0   0   0   
    max_element=2
    flags:  0   0   0   0   1   1   1   1   2   2   2   2   
    data:   1   0   1   2   6   6   4   4   8   8   8   8   
    data:   0   1   1   2   4   4   6   6   8   8   8   8   
    data:   0   1   2   4   6   8   
    flags:  0   0   0   1   1   2   
    data:   0   1   2   0   2   0   
    

    还有一件事:

    thrust development version中,对thrust::unique*实施了improves performance by around 25 %的改进。如果您希望获得更好的性能,可能需要尝试此版本。

答案 1 :(得分:0)

我认为 thrust::unique_copy() 可以帮助您做到这一点。