OpenCL限制循环大小？

Question

更新：clEnqueueReadBuffer(command_queue, c_mem_obj, CL_TRUE, 0, LIST_SIZE * sizeof(double), C, 0, NULL, NULL);正在返回-5,CL_OUT_OF_RESOURCES。这个功能/调用不应该返回这个！

我已经开始使用OpenCL并遇到了问题。如果我允许一个for循环（在内核中）运行10000次，如果我允许循环运行8000次，则所有C都为0，结果都是正确的。

我已经添加了围绕内核的等待以确保它完成，认为我在完成前拉出数据并尝试了Clwaitforevent和CLFinish。任何通话都不会发出错误信号。当我使用ints for循环将工作在4000000的大小。浮动和双打有同样的问题，但浮动工作在10000，但不是在20000，当我使用浮动我删除#pragma OPENCL EXTENSION cl_khr_fp64 : enable检查是不是问题。

这是一些奇怪的记忆事情，我使用OpenCL错了吗？我意识到在大多数内核中，我没有为这样的循环实现，但这似乎是一个问题。我也删除__private，看看这是不是问题，没有改变。那么OpenCL内核中for循环的大小是否有限制？具体是硬件吗？或者这是一个错误？内核是一个简单的内核，它将两个数组（A + B）加在一起并输出另一个（C）。为了获得性能感觉，我在每次计算中都放了一个for循环来减慢/增加每次运行的操作次数。

为内核的代码如下：

#pragma OPENCL EXTENSION cl_khr_fp64 : enable 

__kernel void vector_add(__global double *A, __global double *B, __global double *C) 
{ 

    // Get the index of the current element 
    int i = get_global_id(0); 

    // Do the operation 

    for (__private unsigned int j = 0; j < 10000; j++) 
    { 
     C[i] = A[i] + B[i]; 
    } 
} 

我跑的代码如下：（我保证，当我float和double之间切换的变量的代码两片之间保持一致）

#include <stdio.h> 
#include <stdlib.h> 
#include <iostream> 

#ifdef __APPLE__ 
#include <OpenCL/opencl.h> 
#else 
#include <CL/cl.h> 
#endif 

#define MAX_SOURCE_SIZE (0x100000) 

int main(void) { 
    // Create the two input vectors 
    int i; 
    const int LIST_SIZE = 4000000; 
    double *A = (double*)malloc(sizeof(double)*LIST_SIZE); 
    double *B = (double*)malloc(sizeof(double)*LIST_SIZE); 
    for(i = 0; i < LIST_SIZE; i++) { 
     A[i] = static_cast<double>(i); 
     B[i] = static_cast<double>(LIST_SIZE - i); 
    } 

    // Load the kernel source code into the array source_str 
    FILE *fp; 
    char *source_str; 
    size_t source_size; 

    fp = fopen("vector_add_kernel.cl", "r"); 
    if (!fp) { 
     fprintf(stderr, "Failed to load kernel.\n"); 
     exit(1); 
    } 
    source_str = (char*)malloc(MAX_SOURCE_SIZE); 
    source_size = fread(source_str, 1, MAX_SOURCE_SIZE, fp); 
    fclose(fp); 

    // Get platform and device information 
    cl_platform_id platform_id = NULL; 
    cl_device_id device_id = NULL; 
    cl_uint ret_num_devices; 
    cl_uint ret_num_platforms; 
// clGetPlatformIDs(1, &platform_id, NULL); 
//clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_GPU, 1, &device_id, ret_num_devices); 


    cl_int ret = clGetPlatformIDs(1, &platform_id, NULL); 
       if (ret != CL_SUCCESS) { 
printf("Error: Failed to get platforms! (%d) \n", ret); 
return EXIT_FAILURE; 
} 
    ret = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_GPU, 1, &device_id, &ret_num_devices); 
      if (ret != CL_SUCCESS) { 
printf("Error: Failed to query platforms to get devices! (%d) \n", ret); 
return EXIT_FAILURE; 
} 
/* 
    cl_int ret = clGetPlatformIDs(1, &platform_id, NULL); 
       if (ret != CL_SUCCESS) { 
printf("Error: Failed to get platforms! (%d) \n", ret); 
return EXIT_FAILURE; 
} 
    ret = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_CPU, 1, 
      &device_id, &ret_num_devices); 
      if (ret != CL_SUCCESS) { 
printf("Error: Failed to query platforms to get devices! (%d) \n", ret); 
return EXIT_FAILURE; 
} 
*/ 
    // Create an OpenCL context 
    cl_context context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &ret); 

    // Create a command queue 
    cl_command_queue command_queue = clCreateCommandQueue(context, device_id, 0, &ret); 

    // Create memory buffers on the device for each vector 
    cl_mem a_mem_obj = clCreateBuffer(context, CL_MEM_READ_ONLY, 
      LIST_SIZE * sizeof(double), NULL, &ret); 
    cl_mem b_mem_obj = clCreateBuffer(context, CL_MEM_READ_ONLY, 
      LIST_SIZE * sizeof(double), NULL, &ret); 
    cl_mem c_mem_obj = clCreateBuffer(context, CL_MEM_WRITE_ONLY, 
      LIST_SIZE * sizeof(double), NULL, &ret); 
      if (ret != CL_SUCCESS) { 
printf("Error: Buffer Fail! (%d) \n", ret); 
return EXIT_FAILURE; 
} 

    // Copy the lists A and B to their respective memory buffers 
    ret = clEnqueueWriteBuffer(command_queue, a_mem_obj, CL_TRUE, 0, 
      LIST_SIZE * sizeof(double), A, 0, NULL, NULL); 
    ret = clEnqueueWriteBuffer(command_queue, b_mem_obj, CL_TRUE, 0, 
      LIST_SIZE * sizeof(double), B, 0, NULL, NULL); 

    std::cout << "Begin Compile" << "\n"; 
    // Create a program from the kernel source 
    cl_program program = clCreateProgramWithSource(context, 1, 
      (const char **)&source_str, (const size_t *)&source_size, &ret); 
      if (ret != CL_SUCCESS) { 
printf("Error: Program Fail! (%d) \n", ret); 
return EXIT_FAILURE; 
} 

    // Build the program 
    ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL); 
    if (ret != CL_SUCCESS) { 
printf("Error: ProgramBuild Fail! (%d) \n", ret); 
return EXIT_FAILURE; 
} 

    // Create the OpenCL kernel 
    cl_kernel kernel = clCreateKernel(program, "vector_add", &ret); 
    if (ret != CL_SUCCESS) { 
printf("Error: Kernel Build Fail! (%d) \n", ret); 
return EXIT_FAILURE; 
} 
    std::cout << "End Compile" << "\n"; 

    std::cout << "Begin Data Move" << "\n"; 
    // Set the arguments of the kernel 
    ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&a_mem_obj); 
    ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&b_mem_obj); 
    ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&c_mem_obj); 
    std::cout << "End Data Move" << "\n"; 

    // Execute the OpenCL kernel on the list 
    size_t global_item_size = LIST_SIZE; // Process the entire lists 
    size_t local_item_size = 64; // Process in groups of 64 

    std::cout << "Begin Execute" << "\n"; 
    cl_event event; 
    ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, 
      &global_item_size, &local_item_size, 0, NULL, &event); 
      clFinish(command_queue); 
      //clWaitForEvents(1, &event); 
    std::cout << "End Execute" << "\n"; 
    if (ret != CL_SUCCESS) { 
printf("Error: Execute Fail! (%d) \n", ret); 
return EXIT_FAILURE; 
} 

    // Read the memory buffer C on the device to the local variable C 
    std::cout << "Begin Data Move" << "\n"; 

    double *C = (double*)malloc(sizeof(double)*LIST_SIZE); 
    ret = clEnqueueReadBuffer(command_queue, c_mem_obj, CL_TRUE, 0, 
      LIST_SIZE * sizeof(double), C, 0, NULL, NULL); 
      if (ret != CL_SUCCESS) { 
      printf("Error: Read Fail! (%d) \n", ret); 
      return EXIT_FAILURE; 
      } 
      clFinish(command_queue); 
    std::cout << "End Data Move" << "\n"; 

    std::cout << "Done" << "\n"; 
    std::cin.get(); 
    // Display the result to the screen 
    for(i = 0; i < LIST_SIZE; i++) 
     printf("%f + %f = %f \n", A[i], B[i], C[i]); 

    // Clean up 
    ret = clFlush(command_queue); 
    ret = clFinish(command_queue); 
    ret = clReleaseKernel(kernel); 
    ret = clReleaseProgram(program); 
    ret = clReleaseMemObject(a_mem_obj); 
    ret = clReleaseMemObject(b_mem_obj); 
    ret = clReleaseMemObject(c_mem_obj); 
    ret = clReleaseCommandQueue(command_queue); 
    ret = clReleaseContext(context); 
    free(A); 
    free(B); 
    free(C); 
    std::cout << "Number of Devices: " << ret_num_devices << "\n"; 
    std::cin.get(); 
    return 0; 
} 

我已经在互联网上一看，并不能找到有类似问题的人来说，这是一个问题，因为它可能会导致该直到扩大行之有效代码...

我正在运行Ubuntu 14.04，并且有一台笔记本电脑显卡，用于与大黄蜂/ optirun一起运行的RC520。如果这个错误在其他机器上无法重现，最大4000000的循环大小，那么我将记录一个bug，使用bumblebee/optirun。

干杯

Answer 1

我发现了问题，连接到显示器/主动的VGA /等的GPU有一个看门狗定时器，该超时后〜5秒。这种情况对于不是特斯拉的卡片来说，它具有关闭此功能的功能。在辅助卡上运行是一种解决方法。这很糟糕，需要尽快修复。这绝对是一个NVidia问题，无论如何，对AMD都不确定，这太可怕了。

解决方法是在Windows和注册表的变化，在Linux的/ Ubuntu的，改变X的conf和配售：

选项 “互动”， “0”

与显卡的差距，但是X的conf现在不在以后的版本中生成，可能需要手动创建。如果任何人有复制和粘贴控制台代码修复，这将是一个伟大的和更好的答案。