Question

我正在尝试在CUDA 7.5中实现并行减少总和。我一直在尝试按照NVIDIA PDF来引导您完成初始算法，然后逐步优化更多版本。我目前正在制作一个数组，其中填充1作为每个数组位置的值，以便我可以检查输出是否正确，但我得到的值为-842159451，对于大小为64的数组。我期待内核代码是正确的，因为我已经遵循了NVIDIA的确切代码，但这是我的内核：

__global__ void reduce0(int *input, int *output) {
    extern __shared__ int sdata[];

    unsigned int tid = threadIdx.x;
    unsigned int i = blockIdx.x * blockDim.x + threadIdx.x;

    sdata[tid] = input[i];

    __syncthreads();

    for (unsigned int s = 1; s < blockDim.x; s *= 2) {
        if (tid % (2 * s) == 0) {
            sdata[tid] += sdata[tid + s];
        }

        __syncthreads();
    }

    if (tid == 0) output[blockIdx.x] = sdata[0];
}

这是我的代码调用内核，这是我期望我的问题所在：

int main()
{
    int numThreadsPerBlock = 1024;

    int *hostInput;
    int *hostOutput; 
    int *deviceInput; 
    int *deviceOutput; 

    int numInputElements = 64;
    int numOutputElements; // number of elements in the output list, initialised below

    numOutputElements = numInputElements / (numThreadsPerBlock / 2);
    if (numInputElements % (numThreadsPerBlock / 2)) {
        numOutputElements++;
    }

    hostInput = (int *)malloc(numInputElements * sizeof(int));
    hostOutput = (int *)malloc(numOutputElements * sizeof(int));


    for (int i = 0; i < numInputElements; ++i) {
        hostInput[i] = 1;
    }

    const dim3 blockSize(numThreadsPerBlock, 1, 1);
    const dim3 gridSize(numOutputElements, 1, 1);

    cudaMalloc((void **)&deviceInput, numInputElements * sizeof(int));
    cudaMalloc((void **)&deviceOutput, numOutputElements * sizeof(int));

    cudaMemcpy(deviceInput, hostInput, numInputElements * sizeof(int), cudaMemcpyHostToDevice);

    reduce0 << <gridSize, blockSize >> >(deviceInput, deviceOutput);

    cudaMemcpy(hostOutput, deviceOutput, numOutputElements * sizeof(int), cudaMemcpyDeviceToHost);

    for (int ii = 1; ii < numOutputElements; ii++) {
        hostOutput[0] += hostOutput[ii]; //accumulates the sum in the first element
    }

    int sumGPU = hostOutput[0];

    printf("GPU Result: %d\n", sumGPU);

    std::string wait;
    std::cin >> wait;

    return 0;
}

我也为输入尝试了越来越大的数组大小，无论数组的大小如何，我得到的结果都是非常大的负值。

Answer 1

似乎您正在使用动态分配的共享阵列：

extern __shared__ int sdata[];

但是你没有在内核调用中分配它：

reduce0 <<<gridSize, blockSize >>>(deviceInput, deviceOutput);

您有两种选择：

选项1

在内核中静态分配共享内存，例如

constexpr int threadsPerBlock = 1024;
__shared__ int sdata[threadsPerBlock];

我经常发现这是最干净的方法，因为当共享内存中有多个数组时，它可以毫无问题地工作。缺点是虽然大小通常取决于块中的线程数，但您需要在编译时知道大小。

选项2

指定内核调用中动态分配的共享内存量。

reduce0 <<<gridSize, blockSize, numThreadsPerBlock*sizeof(int) >>>(deviceInput, deviceOutput);

这适用于numThreadsPerBlock的任何值（假设它在允许的范围内）。缺点是，如果你有多个extern共享数组，你需要弄清楚如何自己放入内存，这样就不会覆盖另一个。

请注意，您的代码中可能存在其他问题。我没有测试它。这是我在浏览你的代码后立即发现的。

CUDA - 平行减少总和

1 个答案: