OpenCL program not executing - c++

Question

I modified slightly this program for my understanding, but now it is not running.
This is my code:
#include <iostream>
#include "CL/cl.h"
#include <math.h>
using namespace std;
#define MYSIZE 1000
#if defined(cl_khr_fp64) //Khronos extension available
#pragma OPENCL EXTENSION cl_khr_fp64 : enable
#define DOUBLE_SUPPORT_AVAILABLE
#elif defined(cl_amd_fp64) //AMD extension available
#pragma OPENCL EXTENSION cl_amd_fp64 : enable
#define DOUBLE_SUPPORT_AVAILABLE
#endif
#ifdef DOUBLE_SUPPORT_AVAILABLE
//double
typedef double myreal;
const char *SOURCE = "\n" \
"__kernel void addArray(__global double *A, __global double *B, __global double *C, const unsigned int size) \n" \
"{ \n" \
"int i = get_global_id(0); \n" \
"if(i < size) \n" \
" C[i] = A[i] + B[i]; \n" \
"} \n" \
"\n";
#else
//float
typedef float myreal;
const char *SOURCE = "\n" \
"__kernel void addArray(__global float *A, __global float *B, __global float *C, const unsigned int size) \n" \
"{ \n" \
"int i = get_global_id(0); \n" \
"if(i < size) \n" \
" C[i] = A[i] + B[i]; \n" \
"} \n" \
"\n";
#endif
int main(int argc, char *argv[])
{
int devType = CL_DEVICE_TYPE_GPU;
unsigned int count = MYSIZE;
cl_int err;//err returned from API
size_t global;//global size
size_t local;//local size
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_command_queue commands;
cl_program program;
cl_kernel kernel;
//connect to a compute device
err = clGetPlatformIDs(1, &platform, NULL);
if(err != CL_SUCCESS)
{
cerr << "ERROR: Could not find a platform" << endl;
return -1;
}
//get a device of the appropriate type
err = clGetDeviceIDs(platform, devType, 1, &device, NULL);
if(err != CL_SUCCESS)
{
cerr << "ERROR: Could not find a device" << endl;
return -1;
}
//create a context
context = clCreateContext(0, 1, &device, NULL, NULL, &err);
if(!context || (err != CL_SUCCESS))
{
cerr << "ERROR: Could not create a context" << endl;
return -1;
}
//create a command queue
commands = clCreateCommandQueue(context, device, 0, &err);
if(!commands || (err != CL_SUCCESS))
{
cerr << "ERROR: Could not create a command queue" << endl;
return -1;
}
//create the compute program from source
program = clCreateProgramWithSource(context, 1, (const char **) &SOURCE, NULL, &err);
if(!program || (err != CL_SUCCESS))
{
cerr << "ERROR: Could not create a program from source" << endl;
return -1;
}
//build the program executable
err = clBuildProgram(program, NULL, NULL, NULL, NULL, NULL);
if(err != CL_SUCCESS)
{
size_t len;
char buffer[2048];
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
cerr << "ERROR: Could not build the program executable" << endl;
cerr << buffer << endl;
return -1;
}
//create the kernel
kernel = clCreateKernel(program, "addArray", &err);
if(!kernel || (err != CL_SUCCESS))
{
cerr << "Could not create the kernel" << endl;
return -1;
}
myreal *A = new myreal[MYSIZE];
myreal *B = new myreal[MYSIZE];
myreal *C = new myreal[MYSIZE];
for(int i = 0; i < MYSIZE; i++)
{
A[i] = sqrt(i);
B[i] = -sqrt(i);
}
unsigned int correct = 0;//correct answers
cl_mem A_cl;
cl_mem B_cl;
cl_mem C_cl;
//create device memory buffer
A_cl = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(myreal) * count, NULL, NULL);
B_cl = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(myreal) * count, NULL, NULL);
C_cl = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(myreal) * count, NULL, NULL);
if(!A_cl || !B_cl || !C_cl)
{
cerr << "Could not create device memory buffer" << endl;
return -1;
}
//transfer data to device
err = clEnqueueWriteBuffer(commands, A_cl, CL_TRUE, 0, sizeof(myreal) * count, A, 0, NULL, NULL);
if(err != CL_SUCCESS)
{
cerr << "Could not transfer data to device" << endl;
return -1;
}
err = clEnqueueWriteBuffer(commands, B_cl, CL_TRUE, 0, sizeof(myreal) * count, B, 0, NULL, NULL);
if(err != CL_SUCCESS)
{
cerr << "Could not transfer data to device" << endl;
return -1;
}
//set the arguments to the compute kernel
err = 0;
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &A_cl);
err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &B_cl);
err |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &C_cl);
err |= clSetKernelArg(kernel, 3, sizeof(unsigned int), &count);
if(err != CL_SUCCESS)
{
cerr << "Could not set args for kernel" << endl;
return -1;
}
//get max work group size
err = clGetKernelWorkGroupInfo(kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(local), &local, NULL);
if(err != CL_SUCCESS)
{
cerr << "Could not get the kernel work group size" << endl;
return -1;
}
//execute the kernel using max work group size
global = count;
err = clEnqueueNDRangeKernel(commands, kernel, 1, NULL, &global, &local, 0, NULL, NULL);
if(err != CL_SUCCESS)
{
cerr << "Could not enqueue the kernel for execution: " << err << endl;
return -1;
}
//wait for all commands to finish
clFinish(commands);
//read back the results to C
err = clEnqueueReadBuffer(commands, C_cl, CL_TRUE, 0, sizeof(myreal) * count, C, 0, NULL, NULL);
if(err != CL_SUCCESS)
{
cerr << "Could not read data from C" << endl;
return -1;
}
//validate the results
correct = 0;
myreal check = 0;
for(int i = 0; i < MYSIZE; i++)
{
check = A[i] + B[i] - C[i];
if((check < 1e-14) && (check > -1e-14))
correct++;
}
cout << "Computed " << correct << " correct results with " << ((correct / MYSIZE) * 100) << "% success rate!" << endl;
delete[] A;
delete[] B;
delete[] C;
clReleaseMemObject(A_cl);
clReleaseMemObject(B_cl);
clReleaseMemObject(C_cl);
clReleaseProgram(program);
clReleaseKernel(kernel);
clReleaseCommandQueue(commands);
clReleaseContext(context);
return 0;
return 0;
}
The output I am getting is:
Could not enqueue the kernel for execution: -54
What does this error -54 mean?
I am using MinGW 4.4 32 bit compiler on Windows7 64 bit.
My GPU is ATI Radeon 7670m which has OpenCL 1.1 drivers.
I am using APP SDK 2.9 for 64 bit.

Answer 1

In Khronos reference cl.h, -54 means CL_INVALID_WORK_GROUP_SIZE, which is quite self explicative.
Tip: if you don't have a bound on workgroup size, then you can pass NULL instead of local and let the enqueue function figure it out for you.