在GPU和CPU上添加2D阵列的性能

Question

我目前正在尝试使用GPU和CPU上的C ++来测试OpenCL代码的性能。 我编写了一些计算总和z = x + y的程序，其中z，x和y是GPU和CPU的二维数组（矩阵）。 在测试了这些程序之后，我发现，由于GPU与CPU之间的PCI总线中的数据传输速度较慢，因此CPU在计算此总和方面比GPU效率更高。 现在，我想确定需要更多的总和才能使使用GPU比使用CPU更高效。 我计划通过将z = x + y的总和增加到z = x + y + y + y + y + ...来做到这一点，依此类推。

仅通过增加针对此特定问题的总和数，是否有可能使使用GPU比使用CPU更高效？

就像供参考：我正在使用nVIDIA GeForce GT 640显卡和i5 Intel核心CPU。

任何帮助将不胜感激。

编辑：

下面，我将代码附加到了CPU上：

int main(int argc, const char * argv[])
{

    //This value determines the size of the nxn (square array)             
    int n = 1000;

    //Allocating the memory for the nxn arrays of floats.
    float **x = (float**)malloc(sizeof(float*)*n);
    float **y = (float**)malloc(sizeof(float*)*n);
    float **z = (float**)malloc(sizeof(float*)*n);


    //Initializing the arrays.
    for(int i = 0; i<n; i++){
        x[i] = (float*)malloc(sizeof(float)*n);
        y[i] = (float*)malloc(sizeof(float)*n);
        z[i] = (float*)malloc(sizeof(float)*n);

        for(int j = 0; j<n; j++){
            x[i][j] = i+j;
            y[i][j] = i+j;

        }
    }

    for(int i = 0; i<n; i++){
        for(int j = 0; j<n; j++){

            z[i][j] = x[i][j] + y[i][j];
            for(int k = 0; k < 100; k++){
                z[i][j] += y[i][j];
            }
        }
    }

    return 0;

}

这是使用OpenCL的C ++ ：（用于复制数据并在GPU上执行内核）

int n = 1000;

for(int i = 0; i<n; i++)
    {
        //Writing the data from the host to the device
        err = clEnqueueWriteBuffer(queue, d_xx, CL_TRUE, 0, sizeof(float)*n, h_xx[i], 0, NULL, NULL);
        if(err != CL_SUCCESS){
            std::cout << "Error: Could not write to buffer d_xx" << std::endl;
            exit(1);
        }

        err = clEnqueueWriteBuffer(queue, d_yy, CL_TRUE, 0, sizeof(float)*n, h_yy[i], 0, NULL, NULL);
        if(err != CL_SUCCESS){
            std::cout << "Error: Could not write to buffer d_yy" << std::endl;
            exit(1);
        }

        //Setting the Kernel Arguments
        err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &d_xx);
        if(err != CL_SUCCESS){
            std::cout << "Error: Could not set kernel argument h_xx." << std::endl;
            exit(1);
        }

        err = clSetKernelArg(kernel, 1, sizeof(cl_mem), &d_yy);
        if(err != CL_SUCCESS){
            std::cout << "Error: Could not set kernel argument h_yy." << std::endl;
            exit(1);
        }

        err = clSetKernelArg(kernel, 2, sizeof(cl_mem), &d_zz);
        if(err != CL_SUCCESS){
            std::cout << "Error: Could not set kernel argument h_zz." << std::endl;
        }

        work_units_per_kernel = n;

        //Executing the Kernel
        err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &work_units_per_kernel, NULL, 0, NULL, NULL);
        if(err != CL_SUCCESS){
            std::cout << "Error: Could not execute kernel." << std::endl;
            exit(1);
        }

        //Reading the Data from the Kernel
        err = clEnqueueReadBuffer(queue, d_zz, CL_TRUE, 0, n*(sizeof(float)), h_zz[i], 0, NULL, NULL);
        if(err != CL_SUCCESS){
            std::cout << "Error: Could not read data from kernel." << std::endl;
            exit(1);
        }

    }

最后，在GPU上执行的内核代码：

__kernel void arraysum(__global const float *d_aa, __global const float *d_bb, __global float *d_cc)
{

    int i = get_global_id(0);

    d_cc[i] = d_aa[i] + d_bb[i];


    for(int j = 0; j < 100; j++){
        d_cc[i] += d_bb[i];
    }


}

Answer 1

许多事情使您减速：

1-滥用全局存储器。 每次全局内存访问速度要慢400倍，并且您只能使用全局内存（例如200次读/写）。 全局存储器必须仅在开始时使用，而在结束时使用，而不能用作中间值。

2-您的N长度很短。 CPU仅将完成1000条指令，而GPU中的所有延迟都比这慢得多。 因为100MB副本比1字节副本要高效得多，所以复制操作会产生开销。

3-可能是编译器将CPU代码优化为乘法，而GPU代码却无法访问，因为它正在访问诸如全局变量之类的易变变量。

4-内存对设备的读/写操作非常昂贵，如果将其包括在计算中，CPU会轻易获胜。 而且OpenCL缓冲区和内核的创建非常昂贵。 请注意，您还使用了阻塞写调用，这比非阻塞调用要慢得多。

Answer 2

对于n = 1000 * 1000，您将获得值得进行复制，操作和复制的地步。 正如DarkZero所指出的那样，全局内​​存并不是最佳选择，因此，如果您可以将全局内存缓存到本地内存或线程内存中并使用本地工作组，则这将对CPU和GPU都大有帮助。

让我们从内核开始。 从全局内存中引用d_cc 100次。 在这种情况下，一个简单的更改是将全局内存缓存到线程内存中，然后最后将本地复制回全局。

 __kernel void arraysum(__global const float *d_aa, __global const float *d_bb, __global float *d_cc)
{

     int i = get_global_id(0);

     float t_d_cc = d_aa[i] + d_bb[i]; //make a thread only version of d_cc

     for(int j = 0; j < 100; j++){
         t_d_cc += d_bb[i];
     }

     d_cc[i] = t_d_cc; //copy the thread only back to global
} 

取决于硬件的另一项更改是将d_aa和d_bb缓存到本地内存中。 这使OpenCL可以利用全局内存中的批量副本。 这可能更具挑战性，因为每个OpenCL设备具有不同的大小以及可以使用的本地工作组大小的倍数。

例如，我的i5的最大工作组大小为1024，工作组倍数为1，因此我的本地工作组可以是1到1024之间的任何值。我的ATI-7970的值分别为256和64，因此我的本地工作组需要可以是64、128等。这要严格得多。

 __kernel void arraysum(__global const float *d_aa, 
                        __local float *l_d_aa,
                        __global const float *d_bb,
                        __local float *l_d_bb, 
                        __global float *d_cc,
                        __local float *l_d_cc)
{

//In this example, the global_id(1) is the number of rows and global_id(0) is the columns
//So when the kernel is called, the local work group size needs to be the size of the 
//number of columns

int i = get_global_id(1)*get_global_size(0) + get_global_id(0); //Index of the row
int j = get_local_id(0); 

l_d_aa[get_local_id(0)] = d_aa[i];
l_d_bb[get_local_id(0)] = d_bb[i];

read_mem_fence(CLK_LOCAL_MEM_FENCE);

float l_d_cc[get_local_id(0)] = l_d_aa[get_local_id(0)] + l_d_bb[get_local_id(0)]; 

for(int j = 0; j < get_global_size(0); j++){
    l_d_cc[get_local_id(0)] += l_d_bb[j];
}

d_cc[i] = l_d_cc[get_local_id(0)]; //copy the thread only back to global

}

如果算法有误，我深表歉意，但希望它能传达如何将全局内存缓存到本地内存。 同样，在i5上，本地工作组的大小可以为1到1024，但是ATI7970限于列大小为64、128等。

从概念上讲，这要困难得多，但是使用这种方法时，OpenCL的性能要好得多。

社区，请随时清理内核。