Kernel 内核没有给出每个内核的预期结果

我正处于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中遗漏了一件大事

程序.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;
}

---

你对自己正在做的事情有着完全错误的理解，因此，你期待着一种永远不会发生的行为

clEnqueueTask（命令队列，内核，0，NULL，NULL）这将仅使用1个工作项运行内核，因此，是的。第一个工作项正在运行两次。这是你的主要问题

size\u t global\u work\u size[1]={10}确实意味着10个工作项。但这不是使用OpenCL的方式。您不应该将1000万个项目放入处理并运行10个工作项目。您应该处理1000万个项目，并尽可能多地处理工作项目（即：10万个，
1个工作项目->1个简单操作），否则GPU将处于99%的空闲状态。此外，这将更容易理解和编程，因为内核代码中几乎没有循环

通常，您不应该重用输出，或者增加输出值

out[i]=out[i]+1。因为如果许多工作项更改相同的值，可能会导致竞争条件或错误结果。请记住，所有工作项可能同时独立运行

---

这句话正确吗？还有10000的用途。谢谢你指出@SagarKotecha。我发错代码了。更新了正确的一个。请检查。是的@DarkZeros-clenqueetask被添加了两次，因为它是在调试不同版本的代码时添加的，后来我忘了删除它。这完全解决了我的问题。但是，由于我现在已经正确地更新了我的代码。。。除了clEnqueueTask问题，还有什么地方我会出错吗？好吧，我建议你，如果你真的想做（在最终的实际实现中）一个由ie:200M操作组成的操作。然后，您应该运行2亿个工作项。调度程序将处理它。（我更新了我的答案）。除此之外，我没有其他真正的建议，除非你明确说明你想用OpenCL做什么。

__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 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