GPU 在 Julia 集计算中没有提高性能答案

【问题标题】：GPU gives no performance improvement in Julia set computationGPU 在 Julia 集计算中没有提高性能
【发布时间】：2013-01-30 21:12:39
【问题描述】：

我正在尝试比较 CPU 和 GPU 的性能。我有

CPU : Intel® Core™ i5 CPU M 480 @ 2.67GHz × 4
GPU：英伟达 GeForce GT 420M

我可以确认 GPU 已配置并与 CUDA 一起正常工作。

我正在实现 Julia 集计算。 http://en.wikipedia.org/wiki/Julia_set 基本上对于每个像素，如果坐标在集合中，它将把它涂成红色否则把它涂成白色。

虽然，我在 CPU 和 GPU 上都得到了相同的答案，但没有得到性能提升，使用 GPU 会降低性能。

运行时间

CPU : 0.052s
GPU : 0.784s

我知道将数据从设备传输到主机可能需要一些时间。但是，我怎么知道使用 GPU 是否真的有益？

这里是相关的GPU代码

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

    __device__ bool isJulia( float x, float y, float maxX_2, float maxY_2 )
    {
        float z_r = 0.8 * (float) (maxX_2 - x) / maxX_2;
        float z_i = 0.8 * (float) (maxY_2 - y) / maxY_2;

        float c_r = -0.8;
        float c_i = 0.156;
        for( int i=1 ; i<100 ; i++ )
        {
        float tmp_r = z_r*z_r - z_i*z_i + c_r;
        float tmp_i = 2*z_r*z_i + c_i;

        z_r = tmp_r;
        z_i = tmp_i;

        if( sqrt( z_r*z_r + z_i*z_i ) > 1000 )
            return false;
        }
        return true;
    }

    __global__ void kernel( unsigned char * im, int dimx, int dimy )
    {
        //int tid = blockIdx.y*gridDim.x + blockIdx.x;
        int tid = blockIdx.x*blockDim.x + threadIdx.x;
        tid *= 3;
        if( isJulia((float)blockIdx.x, (float)threadIdx.x, (float)dimx/2, (float)dimy/2)==true )
        {
        im[tid] = 255;
        im[tid+1] = 0;
        im[tid+2] = 0;
        }
        else
        {
        im[tid] = 255;
        im[tid+1] = 255;
        im[tid+2] = 255;
        }

    }

    int main()
    {
        int dimx=768, dimy=768;

        //on cpu
        unsigned char * im = (unsigned char*) malloc( 3*dimx*dimy );

        //on GPU
        unsigned char * im_dev;

        //allocate mem on GPU
        cudaMalloc( (void**)&im_dev, 3*dimx*dimy ); 

        //launch kernel. 
**for( int z=0 ; z<10000 ; z++ ) // loop for multiple times computation**
{
        kernel<<<dimx,dimy>>>(im_dev, dimx, dimy);
}

        cudaMemcpy( im, im_dev, 3*dimx*dimy, cudaMemcpyDeviceToHost );

        writePPMImage( im, dimx, dimy, 3, "out_gpu.ppm" ); //assume this writes a ppm file

        free( im );
        cudaFree( im_dev );
    }

这是CPU代码

    bool isJulia( float x, float y, float maxX_2, float maxY_2 )
    {
        float z_r = 0.8 * (float) (maxX_2 - x) / maxX_2;
        float z_i = 0.8 * (float) (maxY_2 - y) / maxY_2;

        float c_r = -0.8;
        float c_i = 0.156;
        for( int i=1 ; i<100 ; i++ )
        {
        float tmp_r = z_r*z_r - z_i*z_i + c_r;
        float tmp_i = 2*z_r*z_i + c_i;

        z_r = tmp_r;
        z_i = tmp_i;

        if( sqrt( z_r*z_r + z_i*z_i ) > 1000 )
            return false;
        }
        return true;
    }


    #include <stdlib.h>
    #include <stdio.h>

    int main(void)
    {
      const int dimx = 768, dimy = 768;
      int i, j;

      unsigned char * data = new unsigned char[dimx*dimy*3];

**for( int z=0 ; z<10000 ; z++ ) // loop for multiple times computation**
{
      for (j = 0; j < dimy; ++j)
      {
        for (i = 0; i < dimx; ++i)
        {
          if( isJulia(i,j,dimx/2,dimy/2) == true )
          {
          data[3*j*dimx + 3*i + 0] = (unsigned char)255;  /* red */
          data[3*j*dimx + 3*i + 1] = (unsigned char)0;  /* green */
          data[3*j*dimx + 3*i + 2] = (unsigned char)0;  /* blue */
          }
          else
          {
          data[3*j*dimx + 3*i + 0] = (unsigned char)255;  /* red */
          data[3*j*dimx + 3*i + 1] = (unsigned char)255;  /* green */
          data[3*j*dimx + 3*i + 2] = (unsigned char)255;  /* blue */
          }
        }
      }
}

      writePPMImage( data, dimx, dimy, 3, "out_cpu.ppm" ); //assume this writes a ppm file
      delete [] data


      return 0;
    }

此外，根据@hyde 的建议，我循环了仅计算部分以生成 10,000 张图像。不过，我并不费心写所有这些图像。我正在做的只是计算。

这是运行时间

CPU：超过 10 分钟，代码仍在运行
GPU：1m 14.765s

【问题讨论】：

你当然应该做一个测试，它计算出 1000 张图像，而不是一张。也许这样做并更新您的问题...并将保存排除在内部循环之外，计算可能价值 100 兆字节的图像。
“并将保存排除在内部循环之外”。请澄清
我的意思是，如果你想测量 CPU-GPU 的性能差异，那么最好不要在同一个循环中做其他事情......至少除非你可以在另一个线程中保存 PPM，同时开始计算下一个图像，在这种情况下，您可能会从增加的并行度中受益。
按照您的建议，我已经遍历了计算循环。我想我很满意 GPU 确实运行得更快。推理是否正确？
@mkuse：GTX420M 是一个小芯片——它只有 48 个内核。相比之下，GTX480 的核心数量是后者的 10 倍。您可能最终无法弥补将数据从设备复制到主机的开销。 Here 是我做的一个项目中的一些基准，其中涉及 Mandelbrot 计算。

标签： cuda gpgpu gpu

【解决方案1】：

转动cmets来回答：

要得到相关的数字，你需要计算不止一张图像，这样执行时间至少是几秒或几十秒。此外，在结果中包含文件保存时间会增加噪音并隐藏实际的 CPU 与 GPU 差异。

另一种获得真实结果的方法是选择一个 Julia 集，其中包含属于该集的很多点，然后将迭代次数提高到如此之高，以至于只计算一张图像就需要很多秒。那么只有一个计算设置，所以这可能是 GPU/CUDA 最有利的场景。

要测量有多少开销，请将图像大小更改为 1x1 和迭代限制 1，然后计算至少需要几秒钟的足够图像。在这种情况下，GPU 可能会明显变慢。

要获得与您的用例最相关的时间，请选择您真正要使用的图像大小和迭代计数，然后测量图像计数，这两个版本的速度相同。这会给你一个粗略的经验法则来决定你应该在什么时候使用。

实际结果的替代方法，如果您只想获得一张图像：找到单个最坏情况图像的迭代限制，其中 CPU 和 GPU 速度相同。如果这么多或更多的迭代是有利的，请选择 GPU，否则选择 CPU。

【讨论】：