Question

编辑3： 我需要每个线程在全局内存中写入和读取私有位置。下面我发布一个显示我的问题的工作代码。在下文中，我将列出所涉及的主要变量和结构。

变量：

srcArr_h（主持人） - ＆gt; srcArr_d（设备）：[0，COLORLEVELS]范围内的随机浮点数组，其维度由ARRDIM
auxD（设备）：在设备中保存最终结果的维ARRDIM * ARRDIM数组
auxH（主持人）：维持最终结果在主机

ARRDIM

c_glob_d（device）：为每个线程保留COLORLEVELS个浮点的私有位置的数组，其大小由num_threads * COLORLEVELS
idx（设备）：当前线程的标识号

我的问题：在内核中，我为每个值c_glob[idx]更新ic（ic∈[0，COLORLEVELS]），即c_glob[idx][ic]。我使用c_glob[idx][COLORLEVELS]来计算g0中存储的最终结果auxD。我的问题是我的最终结果是错误的。复制到auxH的结果显示我得到的数字至少比预期的大一个数量级，甚至奇怪的数字表明我的操作可能会溢出。
帮助：我做错了什么？如何让每个线程写入和读取全局内存中的每个私有位置？现在我用ARRDIM = 512进行调试，但我的目标是让它适用于ARRDIM ~10 ^ 4，从而为10 ^ 4 *创建一个c_glob数组10 ^ 4个线程）。我想我每次运行允许的线程总数会有问题。所以我想知道你是否可以为我的问题建议任何其他解决方案。
谢谢。

#include <string>
#include <stdint.h>
#include <iostream>
#include <stdio.h>
#include "cuPrintf.cu"
using namespace std;

#define ARRDIM 512
#define COLORLEVELS 4

__global__ void gpuKernel
(
    float *sa, float *aux,
    size_t memPitchAux, int w,
    float *c_glob
)
{
    float sc_loc[COLORLEVELS];

    float g0=0.0f;

    int tidx = blockIdx.x * blockDim.x + threadIdx.x; 
    int tidy = blockIdx.y * blockDim.y + threadIdx.y; 

    int idx  = tidy * memPitchAux/4 + tidx;

    for(int ic=0; ic<COLORLEVELS; ic++)
    {
        sc_loc[ic] = ((float)(ic*ic));
    }

    for(int is=0; is<COLORLEVELS; is++)
    {
        int ic = fabs(sa[tidy*w +tidx]);
        c_glob[tidy * COLORLEVELS + tidx + ic] += 1.0f;
    }

    for(int ic=0; ic<COLORLEVELS; ic++)
    {
        g0 += c_glob[tidy * COLORLEVELS + tidx + ic]*sc_loc[ic];
    }

    aux[idx] = g0;
}

int main(int argc, char* argv[])
{
    /*
     * array src host and device
     */
    int heightSrc = ARRDIM;
    int widthSrc = ARRDIM;
    cudaSetDevice(0);

    float *srcArr_h, *srcArr_d;
    size_t nBytesSrcArr = sizeof(float)*heightSrc * widthSrc;

    srcArr_h = (float *)malloc(nBytesSrcArr); // Allocate array on host
    cudaMalloc((void **) &srcArr_d, nBytesSrcArr); // Allocate array on device
    cudaMemset((void*)srcArr_d,0,nBytesSrcArr); // set to zero

    int totArrElm = heightSrc*widthSrc;

    for(int ic=0; ic<totArrElm; ic++)
    {
        srcArr_h[ic] = (float)(rand() % COLORLEVELS);
    }

    cudaMemcpy( srcArr_d, srcArr_h,nBytesSrcArr,cudaMemcpyHostToDevice);

    /*
     * auxiliary buffer auxD to save final results
     */
    float *auxD;
    size_t auxDPitch;
    cudaMallocPitch((void**)&auxD,&auxDPitch,widthSrc*sizeof(float),heightSrc);
    cudaMemset2D(auxD, auxDPitch, 0, widthSrc*sizeof(float), heightSrc);

    /*
     * auxiliary buffer auxH allocation + initialization on host
     */
    size_t auxHPitch;
    auxHPitch = widthSrc*sizeof(float);
    float *auxH = (float *) malloc(heightSrc*auxHPitch);

    /*
     * kernel launch specs
     */
    int thpb_x = 16;
    int thpb_y = 16;

    int blpg_x = (int) widthSrc/thpb_x;
    int blpg_y = (int) heightSrc/thpb_y;
    int num_threads = blpg_x * thpb_x + blpg_y * thpb_y;

    /* 
     * c_glob: array that reserves a private location of COLORLEVELS floats for each thread
     */
    int cglob_w = COLORLEVELS;
    int cglob_h = num_threads;

    float *c_glob_d;
    size_t c_globDPitch;
    cudaMallocPitch((void**)&c_glob_d,&c_globDPitch,cglob_w*sizeof(float),cglob_h);
    cudaMemset2D(c_glob_d, c_globDPitch, 0, cglob_w*sizeof(float), cglob_h);

    /*
    * kernel launch
    */
    dim3 dimBlock(thpb_x,thpb_y, 1);
    dim3 dimGrid(blpg_x,blpg_y,1);

    gpuKernel<<<dimGrid,dimBlock>>>(srcArr_d,auxD, auxDPitch, widthSrc, c_glob_d);

    cudaThreadSynchronize();

    cudaMemcpy2D(auxH,auxHPitch, 
                 auxD,auxDPitch,  
                 auxHPitch, heightSrc,
                 cudaMemcpyDeviceToHost);
    cudaThreadSynchronize();

    float min = auxH[0];
    float max = auxH[0];
    float f;
    string str;

    for(int i=0; i<widthSrc*heightSrc; i++)
    {

        if(min > auxH[i])
            min = auxH[i];
        if(max < auxH[i])
            max = auxH[i];
    }
    cudaFree(srcArr_d);
    cudaFree(auxD);
    cudaFree(c_glob_d);

}

Answer 1

您决定既不显示整个代码也不减小尺寸以重现您的问题。因此，无法进行测试并验证下面的可能解决方案。

我认为您已经发现了问题的根源：多个线程正在尝试并行写入相同的内存位置。这是导致竞争条件的情况。有关示例，请参阅演示文稿的第四张幻灯片"CUDA C: race conditions, atomics, locks, mutex, and warps"。

竞争条件有一个强力解决方案：原子功能。它们在CUDA C编程指南的B.12节中描述。因此，您可以尝试通过更改行来解决问题

c[ic] += 1.0f;

到

atomicAdd(&c[ic],1);

您将使用性能支付此修复：原子操作序列化代码以避免竞争条件。

我已经提到原子函数是解决问题的一种强力解决方案，因为通过正确地重新思考实现，您可以找到一种方法来避免它们。但由于您提供的细节很少，目前无法说明这一点。

CUDA线程在全局内存中的私有位置上写入错误的结果

1 个答案: