Results 1 to 2 of 2

Thread: Why failed to create kernel?

  1. #1
    Junior Member
    Join Date
    Apr 2012
    Posts
    1

    Why failed to create kernel?

    I am a beginner with OpenCL, and I am trying to run a basic kernel.

    The problem is the program stop at " failed to create kernel". I checked the code witout finding the solution.
    Sorry for my poor english, I hope you can understand.
    Here is the kernel which is stored in HelloWorld.cl
    Code :
    __kernel void hello_kernel(__global const float *a,
                                                    __global const float *b,
                                                    __global float *result)
    {
        int gid = get_global_id(0);
     
        result[gid] = a[gid] + b[gid];
    }

    The host program
    Code :
    #include <iostream>
    #include <fstream>
    #include <sstream>
     
    #ifdef __APPLE__
    #include <OpenCL/cl.h>
    #else
    #include <CL/cl.h>
    #endif
     
    ///
    //  Constants
    //
    const int ARRAY_SIZE = 1000;
     
    ///
    //  Create an OpenCL context on the first available platform using
    //  either a GPU or CPU depending on what is available.
    //
    cl_context CreateContext()
    {
        cl_int errNum;
        cl_uint numPlatforms;
        cl_platform_id firstPlatformId;
        cl_context context = NULL;
     
        // First, select an OpenCL platform to run on.  For this example, we
        // simply choose the first available platform.  Normally, you would
        // query for all available platforms and select the most appropriate one.
        errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
        if (errNum != CL_SUCCESS || numPlatforms <= 0)
        {
            std::cerr << "Failed to find any OpenCL platforms." << std::endl;
            return NULL;
        }
     
        // Next, create an OpenCL context on the platform.  Attempt to
        // create a GPU-based context, and if that fails, try to create
        // a CPU-based context.
        cl_context_properties contextProperties[] =
        {
            CL_CONTEXT_PLATFORM,
            (cl_context_properties)firstPlatformId,
            0
        };
        context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
                                          NULL, NULL, &errNum);
        if (errNum != CL_SUCCESS)
        {
            std::cout << "Could not create GPU context, trying CPU..." << std::endl;
            context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,
                                              NULL, NULL, &errNum);
            if (errNum != CL_SUCCESS)
            {
                std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
                return NULL;
            }
        }
     
        return context;
    }
     
    ///
    //  Create a command queue on the first device available on the
    //  context
    //
    cl_command_queue CreateCommandQueue(cl_context context, cl_device_id *device)
    {
        cl_int errNum;
        cl_device_id *devices;
        cl_command_queue commandQueue = NULL;
        size_t deviceBufferSize = -1;
     
        // First get the size of the devices buffer
        errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &deviceBufferSize);
        if (errNum != CL_SUCCESS)
        {
            std::cerr << "Failed call to clGetContextInfo(...,GL_CONTEXT_DEVICES,...)";
            return NULL;
        }
     
        if (deviceBufferSize <= 0)
        {
            std::cerr << "No devices available.";
            return NULL;
        }
     
        // Allocate memory for the devices buffer
        devices = new cl_device_id[deviceBufferSize / sizeof(cl_device_id)];
        errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, deviceBufferSize, devices, NULL);
        if (errNum != CL_SUCCESS)
        {
            delete [] devices;
            std::cerr << "Failed to get device IDs";
            return NULL;
        }
     
        // In this example, we just choose the first available device.  In a
        // real program, you would likely use all available devices or choose
        // the highest performance device based on OpenCL device queries
        commandQueue = clCreateCommandQueue(context, devices[0], 0, NULL);
        if (commandQueue == NULL)
        {
            delete [] devices;
            std::cerr << "Failed to create commandQueue for device 0";
            return NULL;
        }
     
        *device = devices[0];
        delete [] devices;
        return commandQueue;
    }
     
    ///
    //  Create an OpenCL program from the kernel source file
    //
    cl_program CreateProgram(cl_context context, cl_device_id device, const char* fileName)
    {
        cl_int errNum;
        cl_program program;
     
        std::ifstream kernelFile(fileName, std::ios::in);
        if (!kernelFile.is_open())
        {
            std::cerr << "Failed to open file for reading: " << fileName << std::endl;
            return NULL;
        }
     
        std::ostringstream oss;
        oss << kernelFile.rdbuf();
     
        std::string srcStdStr = oss.str();
        const char *srcStr = srcStdStr.c_str();
        program = clCreateProgramWithSource(context, 1,
                                            (const char**)&srcStr,
                                            NULL, NULL);
        if (program == NULL)
        {
            std::cerr << "Failed to create CL program from source." << std::endl;
            return NULL;
        }
     
     
     
     
     
     
     
     
     
     
        return program;
    }
     
    ///
    //  Create memory objects used as the arguments to the kernel
    //  The kernel takes three arguments: result (output), a (input),
    //  and b (input)
    //
    bool CreateMemObjects(cl_context context, cl_mem memObjects[3],
                          float *a, float *b)
    {
        memObjects[0] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
                                       sizeof(float) * ARRAY_SIZE, a, NULL);
        memObjects[1] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
                                       sizeof(float) * ARRAY_SIZE, b, NULL);
        memObjects[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                       sizeof(float) * ARRAY_SIZE, NULL, NULL);
     
        if (memObjects[0] == NULL || memObjects[1] == NULL || memObjects[2] == NULL)
        {
            std::cerr << "Error creating memory objects." << std::endl;
            return false;
        }
     
        return true;
    }
     
    ///
    //  Cleanup any created OpenCL resources
    //
    void Cleanup(cl_context context, cl_command_queue commandQueue,
                 cl_program program, cl_kernel kernel, cl_mem memObjects[3])
    {
        for (int i = 0; i < 3; i++)
        {
            if (memObjects[i] != 0)
                clReleaseMemObject(memObjects[i]);
        }
        if (commandQueue != 0)
            clReleaseCommandQueue(commandQueue);
     
        if (kernel != 0)
            clReleaseKernel(kernel);
     
        if (program != 0)
            clReleaseProgram(program);
     
        if (context != 0)
            clReleaseContext(context);
     
    }
     
    ///
    //	main() for HelloWorld example
    //
    int main(int argc, char** argv)
    {
        cl_context context = 0;
        cl_command_queue commandQueue = 0;
        cl_program program = 0;
        cl_device_id device = 0;
        cl_kernel kernel = 0;
        cl_mem memObjects[3] = { 0, 0, 0 };
        cl_int errNum;
     
        // Create an OpenCL context on first available platform
        context = CreateContext();
        if (context == NULL)
        {
            std::cerr << "Failed to create OpenCL context." << std::endl;
            return 1;
        }
     
        // Create a command-queue on the first device available
        // on the created context
        commandQueue = CreateCommandQueue(context, &device);
        if (commandQueue == NULL)
        {
            Cleanup(context, commandQueue, program, kernel, memObjects);
            return 1;
        }
     
        // Create OpenCL program from HelloWorld.cl kernel source
        program = CreateProgram(context, device, "HelloWorld.cl");
        if (program == NULL)
        {
            Cleanup(context, commandQueue, program, kernel, memObjects);
            return 1;
        }
     
        // Create OpenCL kernel
        kernel = clCreateKernel(program, "hello_kernel", 0);
        if (kernel == NULL)
        {
            std::cerr << "Failed to create kernel" << std::endl;
    		system("pause");
            Cleanup(context, commandQueue, program, kernel, memObjects);
            return 1;
        }
     
        // Create memory objects that will be used as arguments to
        // kernel.  First create host memory arrays that will be
        // used to store the arguments to the kernel
        float result[ARRAY_SIZE];
        float a[ARRAY_SIZE];
        float b[ARRAY_SIZE];
        for (int i = 0; i < ARRAY_SIZE; i++)
        {
            a[i] = (float)i;
            b[i] = (float)(i * 2);
        }
     
        if (!CreateMemObjects(context, memObjects, a, b))
        {
            Cleanup(context, commandQueue, program, kernel, memObjects);
            return 1;
        }
     
        // Set the kernel arguments (result, a, b)
        errNum = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObjects[0]);
        errNum |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObjects[1]);
        errNum |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObjects[2]);
        if (errNum != CL_SUCCESS)
        {
            std::cerr << "Error setting kernel arguments." << std::endl;
            Cleanup(context, commandQueue, program, kernel, memObjects);
            return 1;
        }
     
        size_t globalWorkSize[1] = { ARRAY_SIZE };
        size_t localWorkSize[1] = { 1 };
     
        // Queue the kernel up for execution across the array
        errNum = clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL,
                                        globalWorkSize, localWorkSize,
                                        0, NULL, NULL);
        if (errNum != CL_SUCCESS)
        {
            std::cerr << "Error queuing kernel for execution." << std::endl;
            Cleanup(context, commandQueue, program, kernel, memObjects);
            return 1;
        }
     
        // Read the output buffer back to the Host
        errNum = clEnqueueReadBuffer(commandQueue, memObjects[2], CL_TRUE,
                                     0, ARRAY_SIZE * sizeof(float), result,
                                     0, NULL, NULL);
        if (errNum != CL_SUCCESS)
        {
            std::cerr << "Error reading result buffer." << std::endl;
            Cleanup(context, commandQueue, program, kernel, memObjects);
            return 1;
        }
     
        // Output the result buffer
        for (int i = 0; i < ARRAY_SIZE; i++)
        {
            std::cout << result[i] << " ";
        }
        std::cout << std::endl;
        std::cout << "Executed program succesfully." << std::endl;
        Cleanup(context, commandQueue, program, kernel, memObjects);
     
        return 0;
    }

  2. #2
    Junior Member
    Join Date
    Jan 2011
    Posts
    29

    Re: Why failed to create kernel?

    Try passing an int* as the last argument to clCreateKernel to obtain the error code. Also, on Mac, you can set the CL_LOG_ERRORS=stderr environment variable and a more verbose message will be printed if an error occurs.

Similar Threads

  1. Can I only Create a Pbuffer without create a window surface
    By sunim in forum Cross API and window system integration
    Replies: 3
    Last Post: 02-04-2012, 12:14 PM
  2. clBuildProgram failed
    By akhal in forum OpenCL
    Replies: 1
    Last Post: 10-12-2011, 10:06 AM

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •