openCL wrong result - opencl

Question

Could somebody explain me why is it happen?
I tought it'd increment the value of my array.
#include <iostream>
#pragma comment(lib, "OpenCL.lib")
#include <CL/cl.h>
const std::string source_str = R"(
__kernel void add(__global int* c) {
int i = get_global_id(0);
c[i]=c[i]+1;
})";
size_t source_size = source_str.length();
cl_platform_id platform_id = NULL;
cl_device_id device_id = NULL;
cl_uint ret_num_devices;
cl_uint ret_num_platforms;
cl_int ret;
cl_context context;
cl_command_queue command_queue;
cl_mem a_mem_obj;
cl_program program;
cl_kernel kernel;
int* a;
#define SIZE 100
// ## You may add your own initialization routines here ##
void init() {
ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);
if (ret != CL_SUCCESS)
std::cout << ret << 1;
ret = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_GPU, 1,
&device_id, &ret_num_devices);
if (ret != CL_SUCCESS)
std::cout << ret << 2;
// Create an OpenCL context
context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &ret);
if (ret != CL_SUCCESS)
std::cout << ret << 3;
// Create a command queue
command_queue = clCreateCommandQueue(context, device_id, 0, &ret);
if (ret != CL_SUCCESS)
std::cout << ret << 4;
a_mem_obj = clCreateBuffer(context, CL_MEM_READ_WRITE,
SIZE * sizeof(int), NULL, &ret);
if (ret != CL_SUCCESS)
std::cout << ret << 6;
// Create a program from the kernel source
program = clCreateProgramWithSource(context, 1,
(const char**)&source_str, (const size_t*)&source_size, &ret);
if (ret != CL_SUCCESS)
std::cout << ret << 9;
// Build the program
ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
if (ret != CL_SUCCESS)
std::cout << ret << 10;
// Create the OpenCL kernel
kernel = clCreateKernel(program, "add", &ret);
if (ret != CL_SUCCESS)
std::cout << ret << 11;
// Set the arguments of the kernel
ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void*)&a_mem_obj);
if (ret != CL_SUCCESS)
std::cout << ret << 13;
}
void KernelStart() {
// Copy to the memory buffers
ret = clEnqueueWriteBuffer(command_queue, a_mem_obj, CL_TRUE, 0,
SIZE * sizeof(int), a, 0, NULL, NULL);
if (ret != CL_SUCCESS)
std::cout << ret << 7;
// Execute the OpenCL kernel on the list
size_t static global_item_size = SIZE; // Process the entire lists
size_t static local_item_size = 64; // Divide work items into groups of 64
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL,
&global_item_size, &local_item_size, 0, NULL, NULL);
if (ret != CL_SUCCESS)
std::cout << ret << 14;
ret = clEnqueueReadBuffer(command_queue, a_mem_obj, CL_TRUE, 0,
SIZE * sizeof(int), a, 0, NULL, NULL);
if (ret != CL_SUCCESS)
std::cout << ret << 15;
}
int main() {
a = new int[SIZE];
for (size_t i = 0; i < SIZE; i++)
{
a[i] = 1;
}
for (size_t i = 0; i < SIZE; i++)
{
std::cout << a[i];
}
std::cout << std::endl;
init();
KernelStart();
for (size_t i = 0; i < SIZE; i++)
{
std::cout << a[i];
}
}
result:
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
-4913-54141111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

Answer 1

Your logging already shows you what's going on, albeit not particularly readably.
First Problem
Your program's output:
-4913
The corresponding code:
// Set the arguments of the kernel
ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void*)&a_mem_obj);
if (ret != CL_SUCCESS)
std::cout << ret << 13;
-49 is CL_INVALID_ARG_INDEX. Kernel arguments are numbered from 0, your kernel has 1 argument, so the only valid index is 0.
Second Problem
Your program's output:
-5414
The code:
#define SIZE 100
…
// Execute the OpenCL kernel on the list
size_t static global_item_size = SIZE; // Process the entire lists
size_t static local_item_size = 64; // Divide work items into groups of 64
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL,
&global_item_size, &local_item_size, 0, NULL, NULL);
if (ret != CL_SUCCESS)
std::cout << ret << 14;
-54 corresponds to CL_INVALID_WORK_GROUP_SIZE.
There are 3 possible reasons specified:
CL_INVALID_WORK_GROUP_SIZE if local_work_size is specified and number of work-items specified by global_work_size is not evenly divisable by size of work-group given by local_work_size or does not match the work-group size specified for kernel using the __attribute__((reqd_work_group_size(X, Y, Z))) qualifier in program source.
CL_INVALID_WORK_GROUP_SIZE if local_work_size is specified and the total number of work-items in the work-group computed as local_work_size[0] *... local_work_size[work_dim - 1] is greater than the value specified by CL_DEVICE_MAX_WORK_GROUP_SIZE in the table of OpenCL Device Queries for clGetDeviceInfo.
CL_INVALID_WORK_GROUP_SIZE if local_work_size is NULL and the __attribute__((reqd_work_group_size(X, Y, Z))) qualifier is used to declare the work-group size for kernel in the program source.
Your local size is 64, your global size is 100. This means you're running into the first condition: you'll need to make sure your global size is an integer multiple of the local size.