CUDA - 为什么基于warp的并行减少更慢？

问题描述

我有关于基于warp的并行缩减的想法，因为warp的所有线程都是按照定义同步的。

因此，我们的想法是输入数据可以减少64倍（每个线程减少两个元素），而不需要任何同步。

与Mark Harris的原始实现相同，减少应用于块级别，数据应用于共享内存。 http://gpgpu.org/static/sc2007/SC07_CUDA_5_Optimization_Harris.pdf

我创建了一个内核来测试他的版本和基于warp的版本。
内核本身完全相同地将BLOCK_SIZE元素存储在共享内存中，并将其结果输出到输出数组中的唯一块索引。

算法本身工作正常。 测试完整的一个数组以测试“计数”。

实现的功能体：

/**
 * Performs a parallel reduction with operator add 
 * on the given array and writes the result with the thread 0
 * to the given target value
 *
 * @param inValues T* Input float array, length must be a multiple of 2 and equal to blockDim.x
 * @param targetValue float 
 */
__device__ void reductionAddBlockThread_f(float* inValues,
    float &outTargetVar)
{
    // code of the below functions
}

1.执行他的版本：

if (blockDim.x >= 1024 && threadIdx.x < 512)
    inValues[threadIdx.x] += inValues[threadIdx.x + 512];
__syncthreads();
if (blockDim.x >= 512 && threadIdx.x < 256)
    inValues[threadIdx.x] += inValues[threadIdx.x + 256];
__syncthreads();
if (blockDim.x >= 256 && threadIdx.x < 128)
    inValues[threadIdx.x] += inValues[threadIdx.x + 128];
__syncthreads();
if (blockDim.x >= 128 && threadIdx.x < 64)
    inValues[threadIdx.x] += inValues[threadIdx.x + 64];
__syncthreads();

//unroll last warp no sync needed
if (threadIdx.x < 32)
{
    if (blockDim.x >= 64) inValues[threadIdx.x] += inValues[threadIdx.x + 32];
    if (blockDim.x >= 32) inValues[threadIdx.x] += inValues[threadIdx.x + 16];
    if (blockDim.x >= 16) inValues[threadIdx.x] += inValues[threadIdx.x + 8];
    if (blockDim.x >= 8) inValues[threadIdx.x] += inValues[threadIdx.x + 4];
    if (blockDim.x >= 4) inValues[threadIdx.x] += inValues[threadIdx.x + 2];
    if (blockDim.x >= 2) inValues[threadIdx.x] += inValues[threadIdx.x + 1];

    //set final value
    if (threadIdx.x == 0)
        outTargetVar = inValues[0];
}

Ressources：

使用4个syncthreads
如果使用了12个语句
11读取+添加+写入操作
1最后写操作
5注册用法

性能：

五次试运行平均值：~19.54 ms

2.基于Warp的方法:(与上面相同的功能体）

/*
 * Perform first warp based reduction by factor of 64
 *
 * 32 Threads per Warp -> LOG2(32) = 5
 *
 * 1024 Threads / 32 Threads per Warp = 32 warps
 * 2 elements compared per thread -> 32 * 2 = 64 elements per warp
 *
 * 1024 Threads/elements divided by 64 = 16
 * 
 * Only half the warps/threads are active
 */
if (threadIdx.x < blockDim.x >> 1)
{
    const unsigned int warpId = threadIdx.x >> 5;
    // alternative threadIdx.x & 31
    const unsigned int threadWarpId = threadIdx.x - (warpId << 5);
    const unsigned int threadWarpOffset = (warpId << 6) + threadWarpId;

    inValues[threadWarpOffset] += inValues[threadWarpOffset + 32];
    inValues[threadWarpOffset] += inValues[threadWarpOffset + 16];
    inValues[threadWarpOffset] += inValues[threadWarpOffset + 8];
    inValues[threadWarpOffset] += inValues[threadWarpOffset + 4];
    inValues[threadWarpOffset] += inValues[threadWarpOffset + 2];
    inValues[threadWarpOffset] += inValues[threadWarpOffset + 1];
}

// synchronize all warps - the local warp result is stored
// at the index of the warp equals the first thread of the warp
__syncthreads();

// use first warp to reduce the 16 warp results to the final one
if (threadIdx.x < 8)
{
    // get first element of a warp
    const unsigned int warpIdx = threadIdx.x << 6;

    if (blockDim.x >= 1024) inValues[warpIdx] += inValues[warpIdx + 512];
    if (blockDim.x >= 512) inValues[warpIdx] += inValues[warpIdx + 256];
    if (blockDim.x >= 256) inValues[warpIdx] += inValues[warpIdx + 128];
    if (blockDim.x >= 128) inValues[warpIdx] += inValues[warpIdx + 64];

    //set final value
    if (threadIdx.x == 0)
        outTargetVar = inValues[0];
}

Ressources：

使用了1个syncthread
7如果陈述
10读取添加写入操作
1最后写操作
5注册用法

5位移位
1加
1分

性能：

五次试运行平均值：~20.82 ms

在Geforce 8800 GT 512 mb上多次测试两个内核，浮点值为256 mb。 并运行每块256个线程的内核（100％占用率）。

基于warp的版本慢了约1.28毫秒。

如果未来的卡允许更大的块大小，基于warp的方法仍然不需要进一步的同步语句，因为最大值是4096，它减少到64，最终扭曲减少到1

为什么它不会更快？或者内核的缺陷在哪里？

从资源使用来看，warp方法应该领先？

Edit1：纠正了内核，只有一半的线程处于活动状态而不会导致绑定读取，添加了新的性能数据

您还应该检查SDK中的示例。 我记得一个非常好的例子，它实现了几种缩减方式。 其中至少有一个也使用基于经线的缩减。

（我现在无法查找名称，因为我只在其他机器上安装了它）