8

我想将单个 Intel CPU 内核的速度与单个 nVidia GPU 内核的速度（即：单个 CUDA 代码、单个线程）进行比较。我确实实现了以下简单的二维图像卷积算法：

void convolution_cpu(uint8_t* res, uint8_t* img, uint32_t img_width, uint32_t img_height, uint8_t* krl, uint32_t krl_width, uint32_t krl_height)
{
    int32_t center_x = krl_width  / 2;
    int32_t center_y = krl_height / 2;
    int32_t sum;
    int32_t fkx,fky;
    int32_t xx,yy;

    float krl_sum = 0;
    for(uint32_t i = 0; i < krl_width*krl_height; ++i)
        krl_sum += krl[i];
    float nc = 1.0f/krl_sum;

    for(int32_t y = 0; y < (int32_t)img_height; ++y)
    {
        for(int32_t x = 0; x < (int32_t)img_width; ++x)
        {
            sum = 0;

            for(int32_t ky = 0; ky < (int32_t)krl_height; ++ky)
            {
                fky = krl_height - 1 - ky;

                for(int32_t kx = 0; kx < (int32_t)krl_width; ++kx)
                {
                    fkx = krl_width - 1 - kx;

                    yy = y + (ky - center_y);
                    xx = x + (kx - center_x);

                    if( yy >= 0 && yy < (int32_t)img_height && xx >= 0 && xx < (int32_t)img_width )
                    {
                        sum += img[yy*img_width+xx]*krl[fky*krl_width+fkx];
                    }
                }
            }
            res[y*img_width+x] = sum * nc;
        }
    }
}

CPU 和 GPU 的算法相同。我还制作了另一个与上面几乎相同的 GPU 版本。唯一的区别是我在使用它们之前将imgandkrl数组传输到共享内存。

我使用了 2 张尺寸为 52x52 的图像，我得到了以下性能：

  • 中央处理器：10 毫秒
  • 图形处理器：1338 毫秒
  • GPU (smem): 1165ms

CPU 是 Intel Xeon X5650 2.67GHz，GPU 是 nVidia Tesla C2070。

为什么我会得到这样的性能差异？对于这个特定的代码，单个 CUDA 内核看起来要慢 100 倍！有人可以向我解释为什么吗？我能想到的原因是

  1. CPU的更高频率
  2. CPU 进行分支预测。
  3. CPU可能有更好的缓存机制？

您认为造成这种巨大性能差异的主要问题是什么？

请记住，我想比较单个 CPU 线程和单个 GPU 线程之间的速度。我并不是要评估 GPU 的计算性能。我知道这不是在 GPU 上进行卷积的正确方法。

4

1 回答 1

9

我试图解释，可能它会为你工作。

CPU 充当主机，GPU 充当设备。

为了在 GPU 上运行线程，CPU 将所有数据（计算 + 将在其上执行计算的数据）复制到 GPU。这个复制时间总是大于计算时间。因为计算是在 ALU-算术和逻辑单元中执行的。这只是一些说明。但是复制需要更多时间。

因此，当您在 CPU 中只运行一个线程时，CPU 将所有数据都保存在自己的内存中，拥有自己的缓存以及分支预测、预取、微操作重排序，L1 快 10 倍，L2 快 10 倍，能够调度 6 倍以上的指令每个周期，核心频率快 4.6 倍。

但是当你想在 GPU 上运行线程时，它首先将数据复制到 GPU 内存上。这一次需要更多的时间。其次，GPU 内核在一个时钟周期内运行线程网格。但为此我们需要对数据进行分区，以便每个线程都可以访问一个数组项。在您的示例中，它是 img 和 krl 数组。

还有一个可用于 nvidia GPU 的分析器。删除代码中的打印输出或打印等代码（如果存在）并尝试分析您的 exe。它将以毫秒为单位显示复制时间和计算时间。

循环并行化：当您使用 image_width 和 image_height 运行两个循环来计算图像时，需要更多的时钟周期来执行，因为它在指令级运行通过计数器。但是当您将它们移植到 GPU 上时，您使用 threadid.x 和 threadid.y 以及 16 或 32 个线程的网格，这些线程仅在 GPU 的一个核心中运行一个时钟周期。这意味着它在一个时钟周期内计算 16 或 32 个数组项，因为它有更多的 ALU。（如果不存在依赖关系并且数据分区良好）

在您的卷积算法中，您在 CPU 中维护了循环，但在 GPU 中，如果您运行相同的循环，它将不会受益，因为 GPU 1 线程将再次充当 CPU 1 线程。还有内存缓存、内存复制、数据分区等的开销。

我希望这会让你明白...

于 2014-03-10T06:31:53.450 回答