C++ OpenCL矩阵乘法速度

我编写了一个小型OpenCL应用程序，用于计算两个矩阵的乘积。现在我注意到，如果矩阵的大小超过8192 x 8192，则性能会显著下降（16384 x 16384的计算速度大约慢80倍），甚至串行实现速度也会快5倍以上。以下是主机代码：

/*Make some includes and definitions here*/
#include "stdafx.h"
#include <CL/cl.hpp>

#include <vector>
#include <iostream>

#include "util.hpp" // utility library

#define __CL_ENABLE_EXCEPTIONS
#define ROWS (16384)    // ROWS of vectors a, b, and c
#define COLUMNS (16384)

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include "metrics.h"

/*Start main()*/

int main(void)
{
    int A;

    // Fill vectors X and Y with random float values

    float* h_x = new float[ROWS*COLUMNS];
    for (int i = 0; i < ROWS; ++i){
        for (int j = 0; j < COLUMNS; ++j){
            h_x[j + i*COLUMNS] = rand() / (float)RAND_MAX;;
        }
    }
    float* h_y = new float[ROWS*COLUMNS];
    for (int i = 0; i < ROWS; ++i){
        for (int j = 0; j < COLUMNS; ++j){
            h_y[j + i*COLUMNS] = rand() / (float)RAND_MAX;;
        }
    }
    float* h_s = new float[ROWS*COLUMNS];
    for (int i = 0; i < ROWS; ++i){
        for (int j = 0; j < COLUMNS; ++j){
            h_s[j + i*COLUMNS] = 0.0;
        }
    }

    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

    // Get all platforms (drivers)

    std::vector<cl::Platform> all_platforms;
    cl::Platform::get(&all_platforms);


    if (all_platforms.size() == 0){ // Check for issues
        std::cout << " No platforms found. Check OpenCL installation!\n";
        exit(1);
    }

    cl::Platform default_platform = all_platforms[0];
    std::cout << "Using platform: " << default_platform.getInfo<CL_PLATFORM_NAME>() << "\n";

    // Get default device of the default platform

    std::vector<cl::Device> all_devices;
    default_platform.getDevices(CL_DEVICE_TYPE_ALL, &all_devices);

    if (all_devices.size() == 0){ // Check for issues
        std::cout << " No devices found. Check OpenCL installation!\n";
        exit(1);
    }

    cl::Device default_device = all_devices[0];
    std::cout << "Using device: " << default_device.getInfo<CL_DEVICE_NAME>() << "\n";

    // Create an OpenCL context

    cl::Context context({ default_device });

    cl::Program program(context, util::loadProgram("saxy_kernel.cl"), true);

    if (program.build({ default_device }) != CL_SUCCESS){
        std::cout << " Error building: " << program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(default_device) << "\n";
        getchar();
        exit(1);
    }

    // create buffers on the device
    cl::Buffer buffer_X(context, CL_MEM_READ_WRITE, sizeof(float)* ROWS*COLUMNS);
    cl::Buffer buffer_Y(context, CL_MEM_READ_WRITE, sizeof(float)* ROWS*COLUMNS);
    cl::Buffer buffer_S(context, CL_MEM_READ_WRITE, sizeof(float)* ROWS*COLUMNS);
    cl::Buffer buffer_A(context, CL_MEM_READ_WRITE, sizeof(int));

    //create queue to which we will push commands for the device.
    cl::CommandQueue queue(context, default_device);

    //write arrays A and B to the device
    queue.enqueueWriteBuffer(buffer_X, CL_TRUE, 0, sizeof(float)* ROWS*COLUMNS, &h_x[0]);
    queue.enqueueWriteBuffer(buffer_Y, CL_TRUE, 0, sizeof(float)* ROWS*COLUMNS, &h_y[0]);
    queue.enqueueWriteBuffer(buffer_A, CL_TRUE, 0, sizeof(int), &A);

    StartCounter();
    //run the kernel
    cl::Kernel kernel_add = cl::Kernel(program, "simple_add");
    kernel_add.setArg(0, buffer_X);
    kernel_add.setArg(1, buffer_Y);
    kernel_add.setArg(2, buffer_S);
    kernel_add.setArg(3, buffer_A);

    cl::NDRange global(ROWS*COLUMNS);
    queue.enqueueNDRangeKernel(kernel_add, cl::NullRange, global, cl::NullRange);
    queue.finish();

    std::cout << "Kernel execution time: " << GetCounter() << "ms \n";

    //read result C from the device to array C
    queue.enqueueReadBuffer(buffer_S, CL_TRUE, 0, sizeof(float)*ROWS*COLUMNS, &h_s[0]);



    /*Print vectors
    std::cout << "\nMatrix #1: \n";
    for (int i = 0; i<ROWS*COLUMNS; i++){


            std::cout << "" << h_x[i] << "\t ";

    }

    std::cout << "\n\nMatrix #2: \n";
    for (int i = 0; i<ROWS*COLUMNS; i++){


            std::cout << "" << h_y[i] << "\t ";

    }

    std::cout << "\n\nResult: \n";
    for (int i = 0; i<ROWS*COLUMNS; i++){


            std::cout << "" << h_s[i] << "\t ";

    }*/
    getchar();
    return 0;
}

你能给我解释一下原因吗？我知道，如果我执行一些算法优化，我可以获得更好的性能，但我正在尝试找出这是“幼稚”实现的阈值，还是我做了一些错误的事情（不正确地将工作分配给组）

编辑：因为有人在评论中要求我，所以我运行内核的GPU是AMD R9 270/2GB RAM。CPU是一个i7-4771，系统有8GB RAM。

写一个关于“如何在每个线程上进行更多计算”的答案，因为注释中不存在代码格式，而且还涉及一些内存使用

因此，大多数OpenCL实现需要在每个线程（以及正确数量的线程）上运行多条指令才能获得高效性能。但正如我在评论中所说，这在很大程度上取决于处理单元的实际架构（GPU、CPU或由独角兽毛发编织而成的具有OpenCL功能的魔法单元，无论是什么）——每个GPU、CPU和独角兽编织者的制造商对于如何制造一个非常高效的单元都有自己的想法，随着时间的流逝，他们也都会改变主意……；）

要在一个线程中完成更多的工作，您只需执行以下操作：

#define NUM_PER_THREAD 16
__kernel void kernel simple_add(
 __global float* X, 
 __global float* Y, 
 __global float* S, 
 __global int *A)
{

   for(i = 0; i < NUM_PER_THREAD; i++)
   {
      size_t index = get_global_id(0)*NUM_PER_THREAD + i;
      S[index] = X[index] * Y[index];
   }
}

#定义每个线程的数量16
__内核无效内核简单添加(
__全局浮点*X，
__全球浮动*Y，
__全球浮动*S，
__全局整数*A）
{
对于（i=0；i

[这将执行1 x 16块。尝试执行16 x 16或类似操作会更有趣，但如果您知道矩阵的大小（宽度），则可以执行]

关于内存：如果所有数据都放在图形内存中，具有专用本地内存（换句话说，大多数图形卡）的GPU将工作得更快。访问“主”内存涉及两种方法之一：

当GPU通过PCI express总线（或使用的任何基础设施）读取数据时，每个缓存线的访问时间都很长—这可能比“本地”内存慢100或1000倍。GPU还（很可能）必须询问CPU内存内容是否在缓存中，如果是，则进一步等待CPU将数据复制到主内存中

“页面输入/输出”，GPU停止，向CPU发送中断， CPU从GPU中“移除”一些合适的内存块[这里的“块”是指“最有可能在4K左右的内存量或其倍数”]的技术术语 内存，并将其复制到主内存，然后复制到 GPU内存所需的其他内存块-类似于操作系统与硬盘交换内存时的情况。如果您运气不好，GPU还必须进行一些有趣的缓存或TLB刷新，以确保使用正确的数据

---

请注意，我（在过去的一个小时左右）仍然没有对AMD/ATI GPU的工作方式，或者他们的OpenCL驱动程序的工作方式有任何特别的了解。以上内容包括猜测/了解GPU的总体工作原理，了解OpenCL的总体工作原理，以及使用

float

计算存储三个不同的16K x 16K阵列所需的内存。虽然OpenCL非常便携，但并不总是“性能可移植”，因此，您可能应该告诉我们您正在运行什么硬件。在大多数体系结构中，每个内核线程执行一次乘法可能相当慢。我会做一些像16 x 16，4 x 32或256 x 256的事情。“正确”的大小取决于您的硬件，但每个线程中的线程数量稍微少一点可能更好。检查OpenCL实现的文档中是否有关于“调整内核”等主题的内容。因此，如果您有2GB的专用图形内存，则不会存储3 x sizeof（float）x 16384 x 16384，因为这将占用3GB的空间。这可以解释为什么它非常慢——我不确定AMD/ATI OpenCL驱动程序在这种情况下会做什么，但无论如何，它必须在主内存中存储至少一些分配，或者使用GPU分页来成批地来回交换，或者使用某种总线来访问CPU内存空间中的数据。这两种方法都会使它变得相当缓慢，我希望[我不知道ATI/AMD在他们的产品中做了什么]@Matsbeterson谢谢你的建议。我很想知道这是因为内存问题还是因为每个线程的计算量很少。但是，为了改变每个线程的计算，我应该做些什么呢？您的主机代码还对从设备返回的数据传输进行计时，这可能是您正在测量的运行时的主要部分。为了对这类事情进行基准测试，我通常会在一个循环中多次运行内核，然后取平均值，这给了设备一个预热的机会。是的，我已经看到并纠正了这一点——我应该在这里也纠正这一点。对于8192x8192（大约50毫秒的内核执行时间），整个过程大约快几毫秒；对于更大的16384x16384（大约7秒的内核执行时间），整个过程大约快0.5秒。现在，关于你的建议，我将测试它，看看会发生什么。有趣的是，我没有看到任何性能提高。我尝试过许多“构造”，比如不同的全局和局部工作大小、不同的线程数量和每个线程的元素计算，但没有任何显著的结果。所以我认为，正如你指出的，可能是内存不足的问题。是的，几乎可以肯定，“GPU内存不足”是问题所在，当然，如果你有2GB的GPU内存

#define NUM_PER_THREAD 16
__kernel void kernel simple_add(
 __global float* X, 
 __global float* Y, 
 __global float* S, 
 __global int *A)
{

   for(i = 0; i < NUM_PER_THREAD; i++)
   {
      size_t index = get_global_id(0)*NUM_PER_THREAD + i;
      S[index] = X[index] * Y[index];
   }
}