Question

我在cuda_computation.cu

中有以下代码

#include <iostream>
#include <stdio.h>
#include <cuda.h>
#include <assert.h>

void checkCUDAError(const char *msg);

__global__ void euclid_kernel(float *x, float* y, float* f)
{
  int idx = blockIdx.x*blockDim.x + threadIdx.x;
  int i = blockIdx.x;
  int j = threadIdx.x;
  f[idx] = sqrt((x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]));
}
int main()
{
  float *xh;
  float *yh;
  float *fh;
  float *xd;
  float *yd;
  float *fd;

  size_t n = 256;
  size_t numBlocks = n;
  size_t numThreadsPerBlock = n;

  size_t memSize = numBlocks * numThreadsPerBlock * sizeof(float);
  xh = (float *) malloc(n * sizeof(float));
  yh = (float *) malloc(n * sizeof(float));
  fh = (float *) malloc(memSize);

  for(int ii(0); ii!=n; ++ii)
    {
      xh[ii] = ii;
      yh[ii] = ii;
    }

  cudaMalloc( (void **) &xd, n * sizeof(float) );
  cudaMalloc( (void **) &yd, n * sizeof(float) );
  cudaMalloc( (void **) &fd, memSize );
  for(int run(0); run!=10000; ++run)
    {
      //change value to avoid optimizations
      xh[0] = ((float)run)/10000.0;
      cudaMemcpy( xd, xh, n * sizeof(float), cudaMemcpyHostToDevice );
      checkCUDAError("cudaMemcpy");
      cudaMemcpy( yd, yh, n * sizeof(float), cudaMemcpyHostToDevice );
      checkCUDAError("cudaMemcpy");
      dim3 dimGrid(numBlocks);
      dim3 dimBlock(numThreadsPerBlock);
      euclid_kernel<<< dimGrid, dimBlock >>>( xd, yd, fd );
      cudaThreadSynchronize();
      checkCUDAError("kernel execution");
      cudaMemcpy( fh, fd, memSize, cudaMemcpyDeviceToHost );
      checkCUDAError("cudaMemcpy");
    }
  cudaFree(xd);
  cudaFree(yd);
  cudaFree(fd);
  free(xh);
  free(yh);
  free(fh);
  return 0;
}

void checkCUDAError(const char *msg)
{
  cudaError_t err = cudaGetLastError();
  if( cudaSuccess != err) 
    {
      fprintf(stderr, "Cuda error: %s: %s.\n", msg, cudaGetErrorString( err) );
      exit(-1);
    }                         
}

在FX QUADRO 380上运行需要大约6英寸，而使用一个i7-870核心的相应串行版本只需要大约3英寸。我错过了什么吗？代码是否在某些方面得到优化？或者只是预期的行为，对于简单的计算（比如这对全欧几里德距离），移动内存所需的开销超过计算增益？

Answer 1

我认为你被移动数据的时间所杀。特别是因为您使用单个值调用CUDA内核，所以将一大组值作为一维数组上传并对它们进行操作可能会更快。

此外，在Cuda上的HW中没有完成sqrt（至少不在我的GPU上），而CPU为此优化了FPU HW，并且可能比GPU快10倍，对于像这样的小型工作可能保留所有在timign运行之间缓存的结果。

Answer 2

减少全局内存读取，因为它们很昂贵。每个线程有4个全局内存读取，使用共享内存可以减少到2个。

__global__ void euclid_kernel(const float * inX_g, const float* inY_g, float * outF_g)
{
    const unsigned int threadId = blockIdx.x * blockDim.x + threadIdx.x;

    __shared__ float xBlock_s;
    __shared__ float yBlock_s;

    if(threadIdx.x == 0)
    {
        xBlock_s = inX_g[blockIdx.x];
        yBlock_s = inY_g[blockIdx.x];
    }
    __syncthreads();

    float xSub = xBlock_s - inX_g[threadIdx.x];
    float ySub = yBlock_s - inY_g[threadIdx.x];

    outF_g[threadId] = sqrt(xSub * xSub + ySub * ySub);
}

您还应该使用不同的块大小进行测试（只要您有100％的占用率）。

Answer 3

您正在拆分问题，以便每个块负责单个i对所有256个j。这是不好的局部性，因为必须为每个块重新加载256个j，总共2 * 256 *（256 + 1）个负载。相反，拆分您的网格，以便每个块负责一系列，例如16个i和16个j，这仍然是256个块* 256个线程。但是现在每个块仅加载2 *（16 + 16）个值，总加载量为2 * 256 * 32。我们的想法是，尽可能多地重复使用每个加载的值。这可能不会对256x256产生巨大影响，但随着尺寸的扩大变得越来越重要。

此优化用于有效的矩阵乘法，其具有类似的局部性问题。有关更多详细信息，请参阅http://en.wikipedia.org/wiki/Loop_tiling或谷歌搜索“优化矩阵乘法”。也许NVIDIA SDK中的矩阵乘法内核提供了一些细节和想法。

CUDA加速进行简单计算

3 个答案: