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(0, std::ios::end);

int size = fs.tellg();

    char * data = new char[size + 1];

    fs.seekg(0);

    fs.read(data, size);

    fs.close();

    data[size] = 0;

    return data;

}
int main()

{

    cl_platform_id platform;

    clGetPlatformIDs(1, &platform, NULL);
cl_device_id   device;

    clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);
cl_context context = clCreateContext(NULL, 1, &device, NULL, NULL, NULL);

    cl_command_queue queue = clCreateCommandQueue(context, device, 0, NULL);
const  char * clSourceFile = loadfile("H:/QtTool/build/TritonRayTracing/kernel.txt");

    cl_program program = clCreateProgramWithSource(context, 1, &clSourceFile, NULL, NULL);

    cl_int result = clBuildProgram(program, 1, &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, 10 * sizeof(cl_int), NULL, 0);

    cl_mem buffer1 = clCreateBuffer(context, CL_MEM_READ_WRITE, 10 * sizeof(cl_int), NULL, 0);

    cl_mem buffer2 = clCreateBuffer(context, CL_MEM_READ_WRITE, 10 * sizeof(cl_int), NULL, 0);

    clSetKernelArg(kernel, 0, sizeof(output), (void *)&output);

    clSetKernelArg(kernel, 1, sizeof(buffer1), (void *)&buffer1);

    clSetKernelArg(kernel, 2, sizeof(buffer2), (void *)&buffer2);

    cl_int * buffer1Ptr = (cl_int *)clEnqueueMapBuffer(queue,

                                                        buffer1,

                                                        CL_TRUE,

                                                        CL_MAP_WRITE,

                                                        0,

                                                        10 * sizeof(cl_int),

                                                        0, NULL, NULL, NULL);

    cl_int * buffer2Ptr = (cl_int *)clEnqueueMapBuffer(queue,

                                                       buffer2,

                                                       CL_TRUE,

                                                       CL_MAP_WRITE,

                                                       0,

                                                       10 * sizeof(cl_int),

                                                       0, NULL, NULL, NULL);

    for (int i = 0; i < 10; ++i)

    {

        buffer1Ptr[i] = i;

        buffer2Ptr[i] = i;

    }

    clEnqueueUnmapMemObject(queue, buffer1, buffer1Ptr, 0, 0, 0);

    clEnqueueUnmapMemObject(queue, buffer2, buffer2Ptr, 0, 0, 0);

    size_t global_work_size = 10;

    clEnqueueNDRangeKernel(queue,

                           kernel,

                           1,

                           NULL,

                           &global_work_size,

                           NULL, 0, NULL, NULL);

    cl_int * resultBufferPtr = (cl_int *)clEnqueueMapBuffer(queue,

                                                            output,

                                                            CL_TRUE,

                                                            CL_MAP_READ,

                                                            0,

                                                            10 * sizeof(cl_int),

                                                            0, NULL, NULL, NULL);

    for (int i = 0; i < 10; i++)

    {

        std::cout << "ptr[" << i << "] = " << resultBufferPtr[i] << std::endl;

    }

    return 0;

}

OpenCL( 一),布布扣,bubuko.com