OpenCL( 一)

#include <CL/cl.h>
#include <iostream>
#include <string>
#include <fstream>
#pragma comment(lib, "OpenCL.lib")
const  char * loadfile(const char * fileName)
{
    std::ifstream fs(fileName, std::ios::binary);
    fs.seekg(, std::ios::end);

    int size = fs.tellg();
    char * data = new char[size + ];
    fs.seekg();
    fs.read(data, size);
    fs.close();
    data[size] = ;
    return data;
}

int main()
{
    cl_platform_id platform;
    clGetPlatformIDs(, &platform, NULL);

    cl_device_id   device;
    clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, , &device, NULL);

    cl_context context = clCreateContext(NULL, , &device, NULL, NULL, NULL);
    cl_command_queue queue = clCreateCommandQueue(context, device, , NULL);

    const  char * clSourceFile = loadfile("H:/QtTool/build/TritonRayTracing/kernel.txt");
    cl_program program = clCreateProgramWithSource(context, , &clSourceFile, NULL, NULL);
    cl_int result = clBuildProgram(program, , &device, NULL, NULL, NULL);
    if (result)
    {
        std::cout << "Error buring compilation" << std::endl;
    }
    cl_kernel kernel = clCreateKernel(program, "main", NULL);
    cl_mem output = clCreateBuffer(context, CL_MEM_WRITE_ONLY,  * sizeof(cl_int), NULL, );
    cl_mem buffer1 = clCreateBuffer(context, CL_MEM_READ_WRITE,  * sizeof(cl_int), NULL, );
    cl_mem buffer2 = clCreateBuffer(context, CL_MEM_READ_WRITE,  * sizeof(cl_int), NULL, );
    clSetKernelArg(kernel, , sizeof(output), (void *)&output);
    clSetKernelArg(kernel, , sizeof(buffer1), (void *)&buffer1);
    clSetKernelArg(kernel, , sizeof(buffer2), (void *)&buffer2);
    cl_int * buffer1Ptr = (cl_int *)clEnqueueMapBuffer(queue,
                                                        buffer1,
                                                        CL_TRUE,
                                                        CL_MAP_WRITE,
                                                        ,
                                                         * sizeof(cl_int),
                                                        , NULL, NULL, NULL);
    cl_int * buffer2Ptr = (cl_int *)clEnqueueMapBuffer(queue,
                                                       buffer2,
                                                       CL_TRUE,
                                                       CL_MAP_WRITE,
                                                       ,
                                                        * sizeof(cl_int),
                                                       , NULL, NULL, NULL);
    for (int i = ; i < ; ++i)
    {
        buffer1Ptr[i] = i;
        buffer2Ptr[i] = i;
    }
    clEnqueueUnmapMemObject(queue, buffer1, buffer1Ptr, , , );
    clEnqueueUnmapMemObject(queue, buffer2, buffer2Ptr, , , );
    size_t global_work_size = ;
    clEnqueueNDRangeKernel(queue,
                           kernel,
                           ,
                           NULL,
                           &global_work_size,
                           NULL, , NULL, NULL);
    cl_int * resultBufferPtr = (cl_int *)clEnqueueMapBuffer(queue,
                                                            output,
                                                            CL_TRUE,
                                                            CL_MAP_READ,
                                                            ,
                                                             * sizeof(cl_int),
                                                            , NULL, NULL, NULL);
    for (int i = ; i < ; i++)
    {
        std::cout << "ptr[" << i << "] = " << resultBufferPtr[i] << std::endl;
    }
    return ;
}