Question

我需要创建一个OpenCL内核函数，该函数使用并行算法对数组n中的numbers个整数求和。

我应该使用类似于以下的算法：

parallel_summation(A):
    # ASSUME n = |A| is a power of 2 for simplicity

    # level 0:
    in parallel do:
      s[i] = A[i]                 for i = 0, 1, 2, ..., n-1

    # level 1:
    in parallel do:
      s[i] = s[i] + s[i+1]        for i = 0, 2, 4, ...

    # level 2:
    in parallel do:
      s[i] = s[i] + s[i+2]        for i = 0, 4, 8, ...

    # level 3:
    in parallel do:
      s[i] = s[i] + s[i+4]        for i = 0, 8, 16, ...

    # ...
    # level log_2( n ):
    s[0] = s[0] + s[n/2]

    return s[0]

所以，我提出了以下内核代码：

kernel void summation(global uint* numbers,
                      global uint* sum,
                      const  uint  n,
                      const  uint  work_group_size,
                      local  uint* work_group_buf,
                      const  uint  num_of_levels) {

    // lets assume for now that the workgroup's size is 16,
    // which is a power of 2.


    int i = get_global_id(0);

    if(i >= n)
        return;

    int local_i = get_local_id(0);

    uint step = 1;
    uint offset = 0;

    for(uint k = 0; k < num_of_levels; ++k) {

        if(k == 0) {

            work_group_buf[local_i] = numbers[i];

        }  else {

            if(local_i % step == 0) {
                work_group_buf[local_i] += work_group_buf[local_i + offset];
            }

        }

        if(offset == 0) {
            offset = 1;
        } else {
            offset *= 2;
        }

        step *= 2;

        barrier(CLK_LOCAL_MEM_FENCE);

    }

     atomic_add(sum, work_group_buf[0]);

}

但是有一个错误，因为我没有收到预期的结果。 numbers是一个缓冲区，其中包含从1到n的数字。 num_of_levels是log ₂（每个工作组的工作项数），在我当前的例子中是4（log ₂（16））。

我做错了什么？

注意：我没有收到任何错误，只是错误的结果。例如，我有一个从0到999999的1000000个元素的数组，这些元素的总和应该是1783293664，但我得到的是1349447424。

Answer 1

我修复了一些错误。有一些错误，我错过了这部分s[0] = s[0] + s[n/2]，正如你可以从这个新版本中看到的那样。

kernel void summation(global uint* numbers,
                          global uint* sum,
                          const  uint  n,
                          local  uint* work_group_buf,
                          const  uint  num_of_levels) {

        const int i = get_global_id(0);
        const int local_i = get_local_id(0);

        private uint step = 2;
        private uint offset = 1;


        if(i < n)
            work_group_buf[local_i] = numbers[i];

        barrier(CLK_LOCAL_MEM_FENCE);

        for(uint k = 1; k < num_of_levels; ++k) {

            if((local_i % step) == 0) {
                work_group_buf[local_i] += work_group_buf[local_i + offset];
            }

            offset *= 2;
            step *= 2;

            barrier(CLK_LOCAL_MEM_FENCE);
        }

        work_group_buf[0] += work_group_buf[get_local_size(0) / 2];

        if(local_i == 0)
            atomic_add(sum, work_group_buf[0]);

}

请注意，现在我只在sum的{{1}}中添加work_group_buf的第一个元素，因为只有work_group_buf[0] position将包含工作组中所有元素的总和。

这实际上似乎适用于大小高达32的工作组（功率为2）。换句话说，这个内核似乎只适用于大小为2,4,8,16和32个工作项的工作组。

Answer 2

您可能会更简单。它的速度非常快，但仅适用于OpenCL 1.2 +。

inline void sum(__global int* a, int v)
{
    int s = +1 * v;
    int n = 0;
    int o = 0;
    do {
        n = s + atom_xchg(a, o);
        s = o + atom_xchg(a, n);
    }
    while (s != o);
}

__kernel void sum_kernel(__global int *set, __global int* out)
{
    int i = (get_group_id(0) + get_group_id(1)*get_num_groups(0)) * get_local_size(0) + get_local_id(0);

    sum(out, set[i]);
}

来自：GitHub - Hello GPU Compute World!

谢谢！

OpenCL：并行n个整数

2 个答案: