减少CUDA：经线展开（学校）

Question

我目前正在开展一个项目，在该项目中，我将展开最后的减少。 我已经完成了上面的代码； 但是，通过猜测进行了一些修改，我想解释一个原因。 我写的代码只是功能kernel4

// in is input array, out is where to store result, n is number of elements from in
// T is a float (32bit)
__global__ void kernel4(T *in, T *out, unsigned int n)

这是一种归约算法，其余代码已提供。

码：

#include <stdlib.h>
#include <stdio.h>

#include "timer.h"
#include "cuda_utils.h"

typedef float T;

#define N_ (8 * 1024 * 1024)
#define MAX_THREADS 256
#define MAX_BLOCKS 64

#define MIN(x,y) ((x < y) ? x : y)
#define tid threadIdx.x 
#define bid blockIdx.x 
#define bdim blockDim.x
#define warp_size 32

unsigned int nextPow2( unsigned int x ) {
    --x;
    x |= x >> 1;
    x |= x >> 2;
    x |= x >> 4;
    x |= x >> 8;
    x |= x >> 16;
    return ++x;
}

void getNumBlocksAndThreads(int whichKernel, int n, int maxBlocks, int maxThreads, int &blocks, int &threads)
{
    if (whichKernel < 3) {
        threads = (n < maxThreads) ? nextPow2(n) : maxThreads;
        blocks = (n + threads - 1) / threads;
    } else {
        threads = (n < maxThreads*2) ? nextPow2((n + 1)/ 2) : maxThreads;
        blocks = (n + (threads * 2 - 1)) / (threads * 2);
    }
    if (whichKernel == 5)
        blocks = MIN(maxBlocks, blocks);
}

T reduce_cpu(T *data, int n) {
    T sum = data[0];
    T c = (T) 0.0;
    for (int i = 1; i < n; i++)
    {
        T y = data[i] - c;
        T t = sum + y;
        c = (t - sum) - y;
        sum = t;
    } 
    return sum;
}

__global__ void
kernel4(T *in, T *out, unsigned int n)
{
    __shared__ volatile T d[MAX_THREADS];

    unsigned int i = bid * bdim + tid;

    n >>= 1;
    d[tid] = (i < n) ? in[i] + in[i+n] : 0;
    __syncthreads ();

    for(unsigned int s = bdim >> 1; s > warp_size; s >>= 1) {
        if(tid < s)
            d[tid] += d[tid + s];
        __syncthreads ();
    }

    if (tid < warp_size) {
        if (n > 64) d[tid] += d[tid + 32];
        if (n > 32) d[tid] += d[tid + 16];
        d[tid] += d[tid + 8];
        d[tid] += d[tid + 4];
        d[tid] += d[tid + 2];
        d[tid] += d[tid + 1];
    }

    if(tid == 0)
        out[bid] = d[0];
}

int main(int argc, char** argv)
{
    T *h_idata, h_odata, h_cpu;
    T *d_idata, *d_odata;   

    struct stopwatch_t* timer = NULL;
    long double t_kernel_4, t_cpu;

    int whichKernel = 4, threads, blocks, N, i;
    if(argc > 1) {
        N = atoi (argv[1]);
        printf("N: %d\n", N);
    } else {
        N = N_;
        printf("N: %d\n", N);
    }

    getNumBlocksAndThreads (whichKernel, N, MAX_BLOCKS, MAX_THREADS, blocks, threads);

    stopwatch_init ();
    timer = stopwatch_create ();

    h_idata = (T*) malloc (N * sizeof (T));
    CUDA_CHECK_ERROR (cudaMalloc (&d_idata, N * sizeof (T)));
    CUDA_CHECK_ERROR (cudaMalloc (&d_odata, blocks * sizeof (T)));

    srand48(time(NULL));
    for(i = 0; i < N; i++)
        h_idata[i] = drand48() / 100000;
    CUDA_CHECK_ERROR (cudaMemcpy (d_idata, h_idata, N * sizeof (T), cudaMemcpyHostToDevice));

    dim3 gb(blocks, 1, 1);
    dim3 tb(threads, 1, 1);

    kernel4 <<<gb, tb>>> (d_idata, d_odata, N);
    cudaThreadSynchronize ();

    stopwatch_start (timer);

    kernel4 <<<gb, tb>>> (d_idata, d_odata, N);
    int s = blocks;
    while(s > 1) {
        threads = 0;
        blocks = 0;
        getNumBlocksAndThreads (whichKernel, s, MAX_BLOCKS, MAX_THREADS, blocks, threads);

        dim3 gb(blocks, 1, 1);
        dim3 tb(threads, 1, 1);

        kernel4 <<<gb, tb>>> (d_odata, d_odata, s);
        s = (s + threads * 2 - 1) / (threads * 2);
    }
    cudaThreadSynchronize ();

    t_kernel_4 = stopwatch_stop (timer);
    fprintf (stdout, "Time to execute unrolled GPU reduction kernel: %Lg secs\n", t_kernel_4);

    double bw = (N * sizeof(T)) / (t_kernel_4 * 1e9);   // total bits / time
    fprintf (stdout, "Effective bandwidth: %.2lf GB/s\n", bw);
    CUDA_CHECK_ERROR (cudaMemcpy (&h_odata, d_odata, sizeof (T), cudaMemcpyDeviceToHost));

    stopwatch_start (timer);
    h_cpu = reduce_cpu (h_idata, N);
    t_cpu = stopwatch_stop (timer);
    fprintf (stdout, "Time to execute naive CPU reduction: %Lg secs\n", t_cpu);

    if(abs (h_odata - h_cpu) > 1e-5)
        fprintf(stderr, "FAILURE: GPU: %f  CPU: %f\n", h_odata, h_cpu);
    else
        printf("SUCCESS: GPU: %f  CPU: %f\n", h_odata, h_cpu);
    return 0;
}

我的第一个问题是：在声明时

__shared__ volatile T d[MAX_THREADS];

我想验证一下我对volatile的理解。 易失性可防止编译器错误地优化我的代码，并保证加载/存储通过高速缓存完成，而不仅仅是寄存器（如果出错，请更正我）。 对于归约，如果部分归约总和仍存储在寄存器中，为什么会有这个问题？

我的第二个问题是：实际减少翘曲时

    if (tid < warp_size) { // Final log2(32) = 5 strides
        if (n > 64) d[tid] += d[tid + 32];
        if (n > 32) d[tid] += d[tid + 16];
        d[tid] += d[tid + 8];
        d[tid] += d[tid + 4];
        d[tid] += d[tid + 2];
        d[tid] += d[tid + 1];
    }

如果没有（n> 64）和（n> 32）条件，则减少的总和将产生错误的结果。 我得到的结果是：

FAILURE: GPU: 41.966557  CPU: 41.946209

经过5次试验，减少GPU的误差始终为0.0204。 我很谨慎地认为这是一个浮点运算错误。

老实说，我的老师的助手建议进行此更改以添加（n> 64）和（n> 32）条件，但是没有解释为什么它会修复代码。

由于我的试验中的n超过64，为什么有条件地改变结果。 我很难找到问题所在，因为我无法像在CPU中那样使用打印功能。

Answer 1

在解决您的两个问题之前，让我们从一些序言开始：

• 我鼓励您阅读NVIDIA的规范化简化教程
• 像这样写出的约简作几个假设，其中之一是块大小为2的幂（表示“正确性”）。
• 您的代码在最后的缩减阶段使用了扭曲同步编程。 您似乎知道自己在做什么，所以我将不对此做详细描述，但这当然与此处的理解有关。 您可以在Google上搜索它，并在需要时获取描述。 这与下面的讨论有关，但我不会在每种情况下都说出它的重要性。

好的，现在您的问题是：

我想验证一下我对volatile的理解。 易失性可防止编译器错误地优化我的代码，并保证加载/存储通过高速缓存完成，而不仅仅是寄存器（如果出错，请更正我）。 对于归约，如果部分归约总和仍存储在寄存器中，为什么会有这个问题？

关于volatile的定义，请参考CUDA编程指南 。 我已经看到了将其称为防止寄存器优化或防止装入和存储重新排序的摘要描述。 我更喜欢前者，并将其用作有效定义。

基本思想是volatile强制对该变量的任何引用（读或写） 实际上进入内存子系统 。 我的意思是它将执行读取或写入操作，并且不会尝试使用先前加载到寄存器中的值。 如果没有此限定符，则编译器可以从实际的内存位置中随意加载一次（例如）一次值，然后将该值（及其任何更新）保存在寄存器中，只要它认为合适即可。 编译器这样做时着眼于性能。 （顺便说一句，请注意，您在此处使用了“缓存”一词。在这里我会避免这种用法。共享内存与处理器加载/存储机制之间没有缓存。）

如果没有这种类型的扭曲同步编码中的volatile ，那么如果我们允许编译器将中间值“优化”（即维护）到寄存器中，就会遇到问题。 这主要是由于线程间通信引起的 。 为了清楚地了解原因，让我们看一下最终缩减的最后两个步骤：

    d[tid] += d[tid + 2];
    d[tid] += d[tid + 1];

让我们只考虑其tid值为0-1的线程。 在倒数第二个步骤中，线程0将拾取d[2]值并将其添加到d[0]值，而线程1将拾取d[3]值并将其添加到d[1]值。 在这一点上，如果我们不使用volatile ，则编译器没有义务将线程1累积的d[1]值写回共享内存。 允许将其保存在寄存器中。 因此，在共享内存中看到的d[1]值不是“最新的”。

现在让我们转到最后一步。 在此步骤中，线程0 从共享内存中读取d[1]值，并将其添加到d[0]值。 但是在没有volatile ，我们在上一步中看到d[1]的共享内存内容不再准确。 OTOH，如果我们使用volatile ，则实际上将在上一步中写入共享内存，并且在最后一步中，线程0在读取d[1]时将选择正确的值。 CUDA线程是独立模型。 这样，我的意思是一个线程不能直接访问属于另一个线程的寄存器中包含的值。 因此，通常通过共享内存或通过warp-shuffle操作来完成warp级别的线程间通信。

__syncthreads()具有类似的行为：强制将所有这样的寄存器优化值写入内存，以使它们对块中的其他线程“可见”。 因此，更复杂的优化将是仅在减少量从基于循环驱动的__syncthreads()的减少量转换为最终的warp同步减少量时才切换到volatile合格指针。 您可以在此答案开头链接的教程幻灯片中看到一个示例。

另外，在CUDA 9中（更正式地）不赞成使用这种经向同步编程。相反，您应该使用协作组 。

如果没有（n> 64）和（n> 32）条件，则减少的总和将产生错误的结果。

主要使用这些条件，因为该代码被设计为对于具有2幂幂的任何块配置都是“正确的”。 如果我们假设块大小（每个块的线程数）是2的幂且大于64，则它必须为128或更大。 您的n变量以块大小开始，然后乘以2：

n >>= 1;

因此，如果我们要确保这一行代码的正确性：

d[tid] += d[tid + 32];

那么我们应该仅在线程块大小为64（至少）时应用该操作，这就像说n大于64：

    if (n > 64) d[tid] += d[tid + 32];

关于这个问题，声称if (n > 64)包含或不包含if (n > 64) ，则发布的代码的行为会有所不同。 这样做的原因是，发布的代码包含一个循环，该循环随着减少的进行重新计算线程数和块数：

int s = blocks;
while(s > 1) {
    threads = 0;
    blocks = 0;
    getNumBlocksAndThreads (whichKernel, s, MAX_BLOCKS, MAX_THREADS, blocks, threads);

最终，该循环导致块大小小于128，这意味着如果if条件丢失，则会导致损坏。 （只需在此循环中打印出threads变量）。

关于此：

我很难找到问题所在，因为我无法像在CPU中那样使用打印功能。

我不确定问题出在哪里。 printf应该在内核代码中运行。

Answer 2

根据此答案， 共享变量不能在其声明中包含初始化。 因此，如果n <64，我们将一些随机共享内存数组数据添加到总和中，这将导致错误。