Question

我是 C ++ / CUDA 的新手。我尝试实现并行算法＆＃34; reduce ＆＃34;能够处理任何类型的inputize和threadsize，而不会通过递归内核的输出（在内核包装器中）来增加渐近并行运行时。

e.g。 Implementing Max Reduce in Cuda这个问题的最佳答案，当线程化足够小时，他/她的实现基本上是顺序的。

但是，我不断收到＆＃34; 细分错误＆＃34;当我编译并运行它..？

>> nvcc -o mycode mycode.cu
>> ./mycode
Segmentail fault.

使用cuda 6.5在K40上编译

这是内核，与SO帖子基本相同，我将检查器链接到＆＃34;越界＆＃34;与众不同：

#include <stdio.h>

/* -------- KERNEL -------- */
__global__ void reduce_kernel(float * d_out, float * d_in, const int size)
{
  // position and threadId
  int pos = blockIdx.x * blockDim.x + threadIdx.x;
  int tid = threadIdx.x;

  // do reduction in global memory
  for (unsigned int s = blockDim.x / 2; s>0; s>>=1)
  {
    if (tid < s)
    {
      if (pos+s < size) // Handling out of bounds
      {
        d_in[pos] = d_in[pos] + d_in[pos+s];
      }
    }
  }

  // only thread 0 writes result, as thread
  if (tid==0)
  {
    d_out[blockIdx.x] = d_in[pos];
  }
}

内核包装器我提到要处理1个块不包含所有数据的时间。

/* -------- KERNEL WRAPPER -------- */
void reduce(float * d_out, float * d_in, const int size, int num_threads)
{
  // setting up blocks and intermediate result holder
  int num_blocks = ((size) / num_threads) + 1;
  float * d_intermediate;
  cudaMalloc(&d_intermediate, sizeof(float)*num_blocks);

  // recursively solving, will run approximately log base num_threads times.
  do
  {
    reduce_kernel<<<num_blocks, num_threads>>>(d_intermediate, d_in, size);

    // updating input to intermediate
    cudaMemcpy(d_in, d_intermediate, sizeof(float)*num_blocks, cudaMemcpyDeviceToDevice);

    // Updating num_blocks to reflect how many blocks we now want to compute on
      num_blocks = num_blocks / num_threads + 1;

    // updating intermediate
    cudaMalloc(&d_intermediate, sizeof(float)*num_blocks);
  }
  while(num_blocks > num_threads); // if it is too small, compute rest.

  // computing rest
  reduce_kernel<<<1, num_blocks>>>(d_out, d_in, size);

}

初始化输入/输出并创建虚假数据以进行测试的主程序。

/* -------- MAIN -------- */
int main(int argc, char **argv)
{
  // Setting num_threads
  int num_threads = 512;
  // Making bogus data and setting it on the GPU
  const int size = 1024;
  const int size_out = 1;
  float * d_in;
  float * d_out;
  cudaMalloc(&d_in, sizeof(float)*size);
  cudaMalloc((void**)&d_out, sizeof(float)*size_out);
  const int value = 5;
  cudaMemset(d_in, value, sizeof(float)*size);

  // Running kernel wrapper
  reduce(d_out, d_in, size, num_threads);

  printf("sum is element is: %.f", d_out[0]);
}

Answer 1

我会用你的代码指出一些事情。

作为一般规则/样板文件，我始终建议您使用proper cuda error checking，并在遇到cuda代码时遇到问题时使用cuda-memcheck运行代码。然而，这些方法对seg故障没有多大帮助，尽管它们可能会有所帮助（见下文）。
实际的seg故障发生在这一行：
```
printf("sum is element is: %.f", d_out[0]);
```
你破坏了一个基本的CUDA编程规则：不能在设备代码中取消引用主机指针，并且不得在主机代码中取消引用设备指针。后一种情况适用于此。 d_out是设备指针（通过cudaMalloc分配）。如果您尝试在主机代码中取消引用它们，则此类指针无意义，这样做会导致seg错误。

解决方案是在打印出来之前将数据复制回主机：
```
float result;
cudaMemcpy(&result, d_out, sizeof(float), cudaMemcpyDeviceToHost);
printf("sum is element is: %.f", result);
```
在循环中使用cudaMalloc，在同一个变量上，不进行任何cudaFree操作，这不是一个好习惯，并且可能导致长时间运行时出现内存不足错误循环，并且如果在更大的程序中使用这样的构造，也可能导致具有内存泄漏的程序：
```
do
{
  ...

  cudaMalloc(&d_intermediate, sizeof(float)*num_blocks);
}
while...
```
在这种情况下，我认为在您重新分配之前，更好的方法和简单的解决方法是cudaFree d_intermediate：
```
do
{
  ...
  cudaFree(d_intermediate);
  cudaMalloc(&d_intermediate, sizeof(float)*num_blocks);
}
while...
```
这可能不是你想象的那样：
```
const int value = 5;
cudaMemset(d_in, value, sizeof(float)*size);
```
可能您已经意识到这一点，但cudaMemset与memset一样，对字节数量进行操作。因此，您使用与d_in对应的值填充0x05050505数组（当解释为float数量时，我不知道该位模式对应于什么）。既然你提到虚假价值，你可能已经认识到了这一点。但这是一个常见错误（例如，如果您实际上尝试在每个float位置初始化值为5的数组），那么我想我会指出它。

您的代码也有其他问题（如果您进行上述修复，则会发现，然后使用cuda-memcheck运行代码）。要了解如何进行良好的并行缩减，我建议研究CUDA并行缩减sample code和presentation。出于性能原因，不建议平行减少全局内存。

为了完整起见，我发现了以下一些其他问题：

您的内核代码需要一个适当的__syncthreads()语句，以确保在任何线程进入for循环的下一次迭代之前，块中所有线程的工作都已完成。
< / LI>
您对内核中的全局内存的最终写入也需要以读取位置为入口。否则，您始终启动额外块的策略将允许从此行读取超出范围（cuda-memcheck将显示此内容。）
reduce函数循环中的缩减逻辑通常搞砸了，需要以多种方式重新处理。

我不是说这段代码没有缺陷，但它似乎适用于给定的测试用例并产生正确的答案（1024）：

#include <stdio.h>

/* -------- KERNEL -------- */
__global__ void reduce_kernel(float * d_out, float * d_in, const int size)
{
  // position and threadId
  int pos = blockIdx.x * blockDim.x + threadIdx.x;
  int tid = threadIdx.x;

  // do reduction in global memory
  for (unsigned int s = blockDim.x / 2; s>0; s>>=1)
  {
    if (tid < s)
    {
      if (pos+s < size) // Handling out of bounds
      {
        d_in[pos] = d_in[pos] + d_in[pos+s];
      }
    }
    __syncthreads();
  }

  // only thread 0 writes result, as thread
  if ((tid==0) && (pos < size))
  {
    d_out[blockIdx.x] = d_in[pos];
  }
}

/* -------- KERNEL WRAPPER -------- */
void reduce(float * d_out, float * d_in, int size, int num_threads)
{
  // setting up blocks and intermediate result holder
  int num_blocks = ((size) / num_threads) + 1;
  float * d_intermediate;
  cudaMalloc(&d_intermediate, sizeof(float)*num_blocks);
  cudaMemset(d_intermediate, 0, sizeof(float)*num_blocks);
  int prev_num_blocks;
  // recursively solving, will run approximately log base num_threads times.
  do
  {
    reduce_kernel<<<num_blocks, num_threads>>>(d_intermediate, d_in, size);

    // updating input to intermediate
    cudaMemcpy(d_in, d_intermediate, sizeof(float)*num_blocks, cudaMemcpyDeviceToDevice);

    // Updating num_blocks to reflect how many blocks we now want to compute on
      prev_num_blocks = num_blocks;
      num_blocks = num_blocks / num_threads + 1;

    // updating intermediate
    cudaFree(d_intermediate);
    cudaMalloc(&d_intermediate, sizeof(float)*num_blocks);
    size = num_blocks*num_threads;
  }
  while(num_blocks > num_threads); // if it is too small, compute rest.

  // computing rest
  reduce_kernel<<<1, prev_num_blocks>>>(d_out, d_in, prev_num_blocks);

}

/* -------- MAIN -------- */
int main(int argc, char **argv)
{
  // Setting num_threads
  int num_threads = 512;
  // Making non-bogus data and setting it on the GPU
  const int size = 1024;
  const int size_out = 1;
  float * d_in;
  float * d_out;
  cudaMalloc(&d_in, sizeof(float)*size);
  cudaMalloc((void**)&d_out, sizeof(float)*size_out);
  //const int value = 5;
  //cudaMemset(d_in, value, sizeof(float)*size);
  float * h_in = (float *)malloc(size*sizeof(float));
  for (int i = 0; i <  size; i++) h_in[i] = 1.0f;
  cudaMemcpy(d_in, h_in, sizeof(float)*size, cudaMemcpyHostToDevice);

  // Running kernel wrapper
  reduce(d_out, d_in, size, num_threads);
  float result;
  cudaMemcpy(&result, d_out, sizeof(float), cudaMemcpyDeviceToHost);
  printf("sum is element is: %.f\n", result);
}

CUDA：减少算法

1 个答案: