內核沒有給出每個核心的預期結果

Question

我處於OpenCl的學習階段。

問題：創建兩個數組：輸入和輸出50個元素，初始化值爲「-1」。

我將兩個數組作爲輸入和輸出緩衝區傳遞給GPU並解決（遞增數組的每個元素）5次迭代。因此， 所有元素的值應該增加到4.如，我除以10個核心此工作通過

size_t global_work_size[1] = {10}; 

和我的內核是根據get_global_id解決所有陣列（0）值，這意味着，解決每個核心中的每個5個元素。

所以，我最後的輸出應該是：

output[0] = 4.0000 
output[1] = 4.0000 
... 
... 
output[48] = 4.0000 
output[49] = 4.0000 

但是，我的輸出來了：

output[0] = 9.0000 
output[1] = 9.0000 
output[2] = 9.0000 
output[3] = 9.0000 
output[4] = 9.0000 
output[5] = 4.0000 
output[6] = 4.0000 
output[7] = 4.0000 
output[8] = 4.0000 
output[9] = 4.0000 
... 
... 
output[48] = 4.0000 
output[49] = 4.0000 

我們可以看到，在輸出差是前10個元素。這可能是因爲我的第一個內核運行兩次。 但是，我不明白確切的原因。請建議我，我哪裏錯了？可能是邏輯錯誤，或者我錯過了OpenCl中的一件大事？

program.c文件：

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

#define MEM_SIZE (50) 
#define MAX_SOURCE_SIZE (0x100000) 

int main() { 
    float input[MEM_SIZE], output[MEM_SIZE]; 
    int go, i; 
    for (i = 0; i < MEM_SIZE; i++) { 
     input[i] = -1.0; 
     output[i] = -1.0; 
    } 
    FILE *fp; 
    cl_device_id device_id = NULL; 
    cl_context context = NULL; 
    cl_command_queue command_queue = NULL; 
    cl_program program = NULL; 
    cl_kernel kernel = NULL; 
    cl_platform_id platform_id = NULL; 
    cl_uint ret_num_devices; 
    cl_uint ret_num_platforms; 
    cl_int ret; 
    size_t source_size; 
    cl_event event; 
    char *source_str; 
    fp = fopen("algebra.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); 

    /*Initialization*/ 
    /* Get Platform and Device Info */ 
    ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms); 
    ret = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_DEFAULT, 1, &device_id, &ret_num_devices); 

    /* Create OpenCL context */ 
    context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &ret); 

    /* Create Command Queue */ 
    command_queue = clCreateCommandQueue(context, device_id, 0, &ret); 

    /*Initialization complete*/ 

    cl_mem inputBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR, MEM_SIZE * sizeof(float),(void *) input, NULL); 
    cl_mem outputBuffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY , MEM_SIZE * sizeof(float), NULL, NULL); 



    ret = clEnqueueWriteBuffer(command_queue, 
            inputBuffer, 
            CL_FALSE, 
            0, 
            MEM_SIZE * sizeof(float), 
            input, 
            0, 
            NULL, 
            &event); 
    ret = clWaitForEvents(1, &event); 
    clReleaseEvent(event); 

    ret = clEnqueueWriteBuffer(command_queue, 
            outputBuffer, 
            CL_FALSE, 
            0, 
            MEM_SIZE * sizeof(float), 
            output, 
            0, 
            NULL, 
            &event); 

    ret = clWaitForEvents(1, &event); 
    clReleaseEvent(event); 

    /* Create Kernel Program from the source */ 
    program = clCreateProgramWithSource(context, 1, (const char **)&source_str,(const size_t *)&source_size, &ret); 

    /* Build Kernel Program */ 
    ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL); 

    /* Create OpenCL Kernel */ 
    kernel = clCreateKernel(program, "calc", &ret); 

    /* Set OpenCL Kernel Parameters */ 
    ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&inputBuffer); 
    ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&outputBuffer); 

    /* Execute OpenCL Kernel*/ 
    ret = clEnqueueTask(command_queue, kernel, 0, NULL,NULL); 
    double io; 
    size_t global_work_size[1] = {10}; 
    inputBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR, MEM_SIZE * sizeof(float),(void *) output, NULL); 
    ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&inputBuffer); 
    ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, global_work_size, NULL, 0, NULL, NULL); 
    ret = clEnqueueReadBuffer(command_queue, outputBuffer, CL_TRUE, 0, MEM_SIZE * sizeof(float), output, 0, NULL, NULL); 

    for (go = 0; go < MEM_SIZE; go++) { 
     printf("output[%d] = %f\n", go, output[go]); 
    } 
    printf("\n\n"); 

    /* Finalization */ 
    ret = clFlush(command_queue); 
    ret = clFinish(command_queue); 
    ret = clReleaseKernel(kernel); 
    ret = clReleaseProgram(program); 
    ret = clReleaseMemObject(inputBuffer); 
    ret = clReleaseMemObject(outputBuffer); 
    ret = clReleaseCommandQueue(command_queue); 
    ret = clReleaseContext(context); 
    return 1; 
} 

algebra.cl（內核文件）：

__kernel void euler(__global float* in, __global float* out) 
{ 
    int idx = get_global_id(0) * 5; 
    int end_idx = idx + 5; 
    double j = 0; 
    int i; 
    while (j < 5.0) { 
     j++; 
     for (i = idx; i < end_idx; i++) { 
      out[i] = out[i] + 1; 
     } 
    } 
} 

GCC編譯：

gcc program.c -o test -l OpenCL -I /usr/local/opencl/AMD-APP-SDK-v2.9-RC-lnx32/include/ -L /usr/local/opencl/AMD-APP-SDK-v2.9-RC-lnx32/lib/x86 

Answer 1

你有一個完全錯誤的瞭解你是什麼樣的人因此，你期待着一種永不會發生的行爲。

1. clEnqueueTask(command_queue, kernel, 0, NULL,NULL);這將只運行內核1工作項目，所以，是的。第一個工作項目正在運行兩次。這是你的主要問題。
2. size_t global_work_size[1] = {10};確實意味着10個工作項目。但這不是使用OpenCL的方式。你不應該放置10M物品來處理和運行10個工作物品。你應該放置10M物品，並且儘可能多的工作物品（例如：10M以及1 work-item -> 1 simple action），否則GPU將空閒99％。此外，這將更容易理解和編程，因爲在內核代碼中幾乎沒有循環。
3. 通常，您不應該重複使用輸出或增加輸出值out[i] = out[i] +1;。因爲如果許多工作項目改變相同的值，它可能會導致競爭條件或錯誤的結果。請記住，所有的工作項目可能在同一時間和獨立運行。