通过 NVIDIA Quadro M4000 获得较低的主机设备传输速率

Question

我正在PCIe 3x16上安装的NVIDIA Quadro M4000上做OpenCL。在卡文档中，据说 CPU->GPU 的传输速率可以达到 15.7Gb/s，而在我的基准测试中，它只能产生 ~2.4Gb/s。我知道有效传输速率可能与理论传输速率有很大差异，但我没想到差异会那么大。

任何人都有四边形 CPU->GPU 数据传输的经验。

谢谢

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<CL/cl.h>
#include <Windows.h>
using namespace std;
SYSTEMTIME last_call;
cl_platform_id platform_id = NULL;
cl_uint ret_num_platform;
cl_device_id device_id = NULL;
cl_uint ret_num_device;
cl_context context = NULL;
cl_command_queue command_queue = NULL;
cl_program program = NULL;
cl_kernel kernel = NULL;
cl_int err;
void _profile(char* msg){
SYSTEMTIME tmp;
clFinish(command_queue);
GetSystemTime(&tmp);
printf("__Profile --- %s --- : %d : %d : %dn", msg, (tmp.wMinute - last_call.wMinute),
    (tmp.wSecond - last_call.wSecond),
    (tmp.wMilliseconds - last_call.wMilliseconds));
    last_call = tmp;
}
int main()
{
// Reading Kernel Program
char *kernel_src_std = "__kernel void copy(__global const uchar *x,  __global uchar *z){
                       const int id = get_global_id(0);
                       z[id] = x[id];   
                       }";
size_t kernel_src_size = strlen(kernel_src_std);
// Create Input data
int w = 1920;
int h = 1080;
int c = 3;
float* input = (float*)malloc(w * h * c * sizeof(float));   
for(int i=0;i<w*h*c;i++)
    input[i] = (float)rand()/RAND_MAX;

// getting platform ID
err = clGetPlatformIDs(1, &platform_id, &ret_num_platform);
// Get Device ID
err = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_GPU, 1, &device_id, &ret_num_device );
// Create Context
context = clCreateContext(NULL,1,&device_id,NULL,NULL,&err);
// Create Command Queue
command_queue =  clCreateCommandQueue(context, device_id, 0, &err);
// Create buffer Object
cl_mem buf_in = clCreateBuffer(context,CL_MEM_READ_ONLY, sizeof(float) * w*h*c,
    0, &err);
cl_mem buf_out = clCreateBuffer(context,CL_MEM_WRITE_ONLY, sizeof(float) * w*h*c,
    0, &err);
_profile("Start transfer input...");
// Copy Data from Host to Device
cl_event event[5];
err = clEnqueueWriteBuffer(command_queue,buf_in,CL_TRUE, 0, sizeof(float)*w*h*c,input,0,NULL, NULL);
_profile("End transfer input...");
// Create and Build Program
program = clCreateProgramWithSource(context, 1, (const char **)&kernel_src_std, 0, &err);
// Create Kernel
kernel = clCreateKernel(program,"copy",&err );
// Set Kernel Arguments
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&buf_in);
err = clSetKernelArg(kernel, 1,sizeof(cl_mem), (void *)&buf_out);
// Execute Kernel 
size_t ws[]={h*w*c};
size_t lws[]={100};
err = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, ws, lws, 0, NULL, NULL);
// Create output buf
float* output = (float*)malloc(sizeof(float)*w*h*c);
// Read output Data, from Device to Host
err = clEnqueueReadBuffer(command_queue, buf_out, CL_TRUE, 0, sizeof(float)*w*h*c, output,NULL,NULL,NULL);

//Release Objects
clReleaseMemObject(buf_in);
clReleaseMemObject(buf_out);
clReleaseKernel(kernel);
clReleaseProgram(program);
clReleaseCommandQueue(command_queue);
clReleaseContext(context);
free(input);
free(output);
while(1);
return(0);
}

Answer 1

由于您的问题含糊不清，因此很难确定性能不佳的确切原因。一些具体的代码可能会有所帮助。

但是，在您的评论中，您说您转移了一个 6220800 浮点数的数组。这大约是200兆比特的传输。在最大传输速率（15.7Gb/s）下，应该提供大约12ms。

但是，对于每个新的传输请求，还会增加延迟，这对于小型传输------会有效地降低传输速率。

您是否尝试过对明显更大的阵列（例如，100 倍的大小）进行基准测试？

Answer 2

您正在使用阻塞传输，这意味着您在读/写请求上会导致停滞（此外，您没有使用固定内存，但您解决了这个问题）。目前，您的代码正在

开始计时 -> 写入 -> 停止 -> 内核 -> 读取 -> 停止 ->结束计时。如果您的传输规模约为 2 毫秒，这将极大地影响内存带宽传输的时间，因为停顿的大小与此相当。如果您想准确测量带宽，则需要消除这些停顿