OpenCL/C: results always zero - c

Question

I’m using Ubntu 20.04 to run my Opencl program with C but whatever the function i execute the results is always zero or other
illogical results, it’s like kernel not working,
Please if anyone has OpenCL, please try this program i want to know if the problem is in the program or in the installation of OpenCL.
This is the programme i use.
#define CL_USE_DEPRECATED_OPENCL_1_2APIS
#include <stdio.h>
#include <stdlib.h>
#include <CL/cl.h>
#define MAX_SOURCE_SIZE (0x100000)
int main(void) {
// Create the two input vectors
int i;
const int LIST_SIZE = 10;
int* A = (int*)malloc(sizeof(int)*LIST_SIZE);
int* B = (int*)malloc(sizeof(int)*LIST_SIZE);
int* C = (int*)malloc(sizeof(int)*LIST_SIZE);
for(i = 0; i < LIST_SIZE; i++) {
A[i] = i;
B[i] = LIST_SIZE - i;
C[i] = 0;
}
// Load the kernel source code into the array source_str
/*FILE *fp;
char *source_str;
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);
size_t source_size;
source_size = fread( source_str, 1, MAX_SOURCE_SIZE, fp);
fclose( fp );*/
//size_t source_size;
const char* source_str =
"__kernel void vector_add(__global int *A, __global int *B, __global int *C) {\n"
" int i = get_global_id(0);\n"
" if(i>=10) return;\n"
" C[i] = A[i]+B[i];\n"
"}"
;
// 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;
cl_int ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);
ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_ALL, 1,
&device_id, &ret_num_devices);
// Create an OpenCL context
cl_context context = clCreateContext( NULL, 1, &device_id, NULL, NULL, &ret);
// Create a command queue
cl_command_queue command_queue = clCreateCommandQueueWithProperties(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(int), NULL, &ret);
cl_mem b_mem_obj = clCreateBuffer(context, CL_MEM_READ_ONLY,
LIST_SIZE * sizeof(int), NULL, &ret);
cl_mem c_mem_obj = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
LIST_SIZE * sizeof(int), NULL, &ret);
// Copy the lists A and B to their respective memory buffers
ret = clEnqueueWriteBuffer(command_queue, a_mem_obj, CL_TRUE, 0,
LIST_SIZE * sizeof(int), A, 0, NULL, NULL);
ret = clEnqueueWriteBuffer(command_queue, b_mem_obj, CL_TRUE, 0,
LIST_SIZE * sizeof(int), B, 0, NULL, NULL);
// Create a program from the kernel source
cl_program program = clCreateProgramWithSource(context, 1,
(const char **)&source_str, NULL, &ret);
// Build the program
ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
// Create the OpenCL kernel
cl_kernel kernel = clCreateKernel(program, "vector_add", &ret);
// 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);
// Execute the OpenCL kernel on the list
size_t local_item_size = 64; // Divide work items into groups of 64
size_t global_item_size = ((LIST_SIZE+local_item_size-1)/local_item_size)*local_item_size; // Process the entire lists
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL,
&global_item_size, &local_item_size, 0, NULL, NULL);
clFinish(command_queue);
// Read the memory buffer C on the device to the local variable C
ret = clEnqueueReadBuffer(command_queue, c_mem_obj, CL_TRUE, 0,
LIST_SIZE * sizeof(int), C, 0, NULL, NULL);
// Display the result to the screen
for(i = 0; i < LIST_SIZE; i++)
printf("%d + %d = %d\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);
return 0;
}

Answer 1

The code looks oddly familiar to me...
With my PC it works as intended. I suppose the issue is that on your system no OpenCL device is detected. With this code snippet, you can select a platform and device:
// Get platform and device information
const int select_platform = 0;
const int select_device = 0;
cl_platform_id* platform_ids = NULL;
cl_uint nr_platforms = 0;
cl_device_id* device_ids = NULL;
cl_uint nr_devices = 0;
cl_device_id device_id = NULL;
cl_int ret = clGetPlatformIDs(0, NULL, &nr_platforms);
if(ret!=CL_SUCCESS || nr_platforms==0) std::cerr << "no OpenCL platforms found" << std::endl;
platform_ids = (cl_platform_id*)malloc(nr_platforms * sizeof(*platform_ids));
ret = clGetPlatformIDs(nr_platforms, platform_ids, &nr_platforms);
ret = clGetDeviceIDs(platform_ids[select_platform], CL_DEVICE_TYPE_ALL, 0, device_ids, &nr_devices);
if(ret!=CL_SUCCESS || nr_devices==0) std::cerr << "no OpenCL devices found on that platform" << std::endl;
device_ids = (cl_device_id*)malloc(nr_devices * sizeof(*device_ids));
ret = clGetDeviceIDs(platform_ids[select_platform], CL_DEVICE_TYPE_ALL, nr_devices, device_ids, &nr_devices);
device_id = device_ids[select_device];
char name[1024];
clGetDeviceInfo(device_id, CL_DEVICE_NAME, 1024, name, NULL);
std::cout << "selected device: " << name << std::endl;
Check different values of select_platform and select_device. If there is no device found on any platform, make sure to have compatible hardware and the latest graphics drivers or CPU runtime installed.
To make OpenCL development much less painful, consider this OpenCL-Wrapper. This automatically selects the fastest available OpenCL device for you in 1 line of code:
Device device(select_device_with_most_flops());
Alternatively, you can autiomatically select the device with most memory
Device device(select_device_with_most_memory());
or a device with specified ID:
Device device(select_device_with_id(1));