Question

我写了一个小的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;
}

这是内核：

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

   S[get_global_id(0)] = X[get_global_id(0)] * Y[get_global_id(0)];

}

你可以解释一下原因吗？我知道如果我执行一些算法优化，我可以获得更好的性能，但我想弄清楚这是否是“天真”实现的阈值，或者我做错了什么（错误的工作分配到基团）。

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

Answer 1

写一个关于＆＃34;如何为每个线程做更多计算的答案＆＃34;因为在评论中不存在代码格式，并且在内存使用方面也略有不足......

因此，大多数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];
   }
}

[这将做1 x 16块。尝试16 x 16或类似的东西会更有趣，但如果你知道矩阵的大小（宽度）就可以完成了。

关于内存：如果所有数据都适合图形内存，拥有专用本地内存（换言之，大多数图形卡）的GPU将更快地工作。访问＆＃34; main＆＃34;记忆涉及两种方法之一：

当GPU通过PCI-express总线[或任何使用的基础设施]读取时，每个缓存行的访问时间很长 - 这可能比本地＆＃34;本地＆＃34;记忆。 GPU（最有可能）还要询问CPU内存是否在缓存中，如果是，请再等待CPU将数据复制到主内存中......
＆＃34; page in / out＆＃34; GPU停止的地方，向CPU发送中断， CPU发现了一些合适的块[在这种情况下是一个技术术语，对于＆＃34;一些内存很可能是4K或其中的多个内存＆＃34;]内存到＆＃34;删除＆＃34;来自GPU 内存，并复制到主内存，然后复制到需要将其他内存块存储到GPU内存中 - 类似于操作系统将内存交换到硬盘或从硬盘交换内存时的内存。如果你运气不好，GPU还必须做一些有趣的缓存或TLB刷新，以确保使用正确的数据。

请注意，我仍然（在最后一个小时左右）对AMD / ATI GPU的工作原理或OpenCL驱动程序的工作方式有所了解。以上是猜测/了解GPU如何工作，理解OpenCL如何工作，以及计算使用float存储三个不同16K x 16K阵列所需的内存的混合。

OpenCL矩阵乘法速度

1 个答案: