使用CUDA在GPU上并行处理简单算法

Question

我有一个CUDA函数，可以在GPU上计算本地二进制模式 。 基本上，LBP是对图像像素进行的计算，其中任何给定像素（i，j）的值都取决于其8个邻居的强度。

到目前为止，代码如下：

//The kernel
__global__ void LBP(unsigned char *in, unsigned char *out, const int w, const int h)
{
    const unsigned int i = (blockIdx.x * blockDim.x) + threadIdx.x;

    //Don't do edges!
    if(
             i < w              //first row
        ||   i >= (w * (h - 1)) // last row
        || !(i % w)             // first column
        ||  (i % w + 1 == w)    // last column
    )
    {
        out[i] = 0;
        return;
    }

    unsigned char
        code = 0,
        center = in[i];

    code |= (in[i-w-1] > center) << 7;
    code |= (in[i-w  ] > center) << 6;
    code |= (in[i-w+1] > center) << 5;
    code |= (in[i  +1] > center) << 4;
    code |= (in[i+w+1] > center) << 3;
    code |= (in[i+w  ] > center) << 2;
    code |= (in[i+w-1] > center) << 1;
    code |= (in[i  -1] > center) << 0;

    out[i] = code;
}

// A proxi function
void DoLBP(unsigned char *in, unsigned char *out, const int w, const int h)
{
    const int
        sz = w * h * sizeof(unsigned char);
    unsigned char
        *in_gpu,
        *out_gpu;

    cudaMalloc((void**)&in_gpu,  sz);
    cudaMalloc((void**)&out_gpu, sz);

    cudaMemcpy(in_gpu,  in,  sz, cudaMemcpyHostToDevice);
    cudaMemcpy(out_gpu, out, sz, cudaMemcpyHostToDevice);

    dim3 threadsPerBlock(1024); //Max
    dim3 numBlocks(w*h/threadsPerBlock.x + 1);
    LBP<<<numBlocks,threadsPerBlock>>>(in_gpu, out_gpu, w, h);

    cudaMemcpy(out, out_gpu, sz, cudaMemcpyDeviceToHost);

    cudaFree(in_gpu);
    cudaFree(out_gpu);
}

//The caller
int main()
{
    printf("Starting\n");

    const int
        w = 4000,
        h = 2000;
    unsigned char
        in[w*h],
        out[w*h];

    // Fill [in] with some data 

    DoLBP(in, out, w, h);


    // Use [out] data

    return 0;
}

图像作为* 无符号字符 * s的一维数组（ array = [[row 1] [row 2] [row 3] ... [row n]] ）传递到GPU（从OpenCV的垫）

问题

该代码在相对较小的图像上可以正常工作，并且返回使用正确值填充的输出数组， 但是当图像大小增大时，输出数组全部归零！

我怀疑图像数据溢出了一些GPU缓冲区或类似的东西。

我还不清楚numberOfBlocks和threadsPerBlock部分是如何工作的！ 如果您能提供一些对此的基本了解，将不胜感激。

（我在CUDA中就像1天大的孩子，所以可能有太多方法可以改善这段代码！）

Answer 1

1. 我建议在代码中添加适当的cuda错误检查 。 我相信您的内核正在进行越界访问并失败。
2. 使用cuda-memcheck运行您的代码，因为它将有助于确定内核失败的原因。

3. 这些是要在堆栈上进行的相当大的分配：

    const int w = 4000, h = 2000; unsigned char in[w*h], out[w*h]; 

   每个大约8MB。 那可能是个问题； 它可能取决于系统。 通常最好通过动态分配（例如malloc进行大分配。 在我的特定系统上，由于这些大型堆栈变量未正确分配，导致出现段错误。

4. 您的内核缺少适当的“线程检查”。 起初我以为您在此方面做得很好：

    if( i < w //first row || i >= (w * (h - 1)) // last row || !(i % w) // first column || (i % w + 1 == w) // last column ) 

   但这是一个问题：

    out[i] = 0; return; 

   如果您注释掉out out[i] = 0; 行，您会得到更好的运气。 或者，如果您不喜欢将其注释掉，则可以执行以下操作：

    if (i < (w*h)) out[i] = 0; 

   问题是您的网格启动参数必然会创建“额外线程”：

    dim3 threadsPerBlock(1024); //Max dim3 numBlocks(w*h/threadsPerBlock.x + 1); 

   如果您有正确的线程检查（您几乎可以做...），那么这不是问题。 但是您不能让那些多余的线程写入无效的位置。

为了解释每个块的线程和块数，通过算术运算可能会很有用。 cuda内核启动具有关联的网格 。 网格只是与内核启动关联的所有线程。 线程将分为多个块。 因此，网格等于启动的块数乘以每个块的线程数。 您的情况是多少？ 这行代码表示您要求每个块1024个线程：

    dim3 threadsPerBlock(1024); //Max

您要启动的块数由下式给出：

    dim3 numBlocks(w*h/threadsPerBlock.x + 1);

该算法是：

    (w=4000)*(h=2000)/1024 = 7812.5 = 7812   (note this is an *integer* divide)

然后添加1。因此，您正在启动7813块。 那是多少个线程？

    (7813 blocks)*(1024 threads per block) = 8000512 threads

但是您只需要（并且只想要）8000000个线程（= w * h），因此您需要进行线程检查以防止多余的512个线程尝试访问out[i] 。 但是您的线程检查在这方面被破坏了。

最后一点，对我来说，使此代码运行更快的最明显方法是通过共享内存利用相邻操作中的数据重用。 但是先让您的代码正确运行。