1 #ifndef TOOLH
 2 #define TOOLH
 3
 4 #include <CL/cl.h>
 5 #include <string.h>
 6 #include <stdio.h>
 7 #include <stdlib.h>
 8 #include <iostream>
 9 #include <string>
10 #include <fstream>
11 using namespace std;
12
13 /** convert the kernel file into a string */
14 int convertToString(const char *filename, std::string& s);
15
16 /**Getting platforms and choose an available one.*/
17 int getPlatform(cl_platform_id &platform);
18
19 /**Step 2:Query the platform and choose the first GPU device if has one.*/
20 cl_device_id *getCl_device_id(cl_platform_id &platform);
21
22 #endif

 1 #include <CL/cl.h>
 2 #include <string.h>
 3 #include <stdio.h>
 4 #include <stdlib.h>
 5 #include <iostream>
 6 #include <string>
 7 #include <fstream>
 8 #include "tool.h"
 9 using namespace std;
10
11 /** convert the kernel file into a string */
12 int convertToString(const char *filename, std::string& s)
13 {
14     size_t size;
15     char*  str;
16     std::fstream f(filename, (std::fstream::in | std::fstream::binary));
17
18     if(f.is_open())
19     {
20         size_t fileSize;
21         f.seekg(0, std::fstream::end);
22         size = fileSize = (size_t)f.tellg();
23         f.seekg(0, std::fstream::beg);
24         str = new char[size+1];
25         if(!str)
26         {
27             f.close();
28             return 0;
29         }
30
31         f.read(str, fileSize);
32         f.close();
33         str[size] = '\0';
34         s = str;
35         delete[] str;
36         return 0;
37     }
38     cout<<"Error: failed to open file\n:"<<filename<<endl;
39     return -1;
40 }
41
42 /**Getting platforms and choose an available one.*/
43 int getPlatform(cl_platform_id &platform)
44 {
45     platform = NULL;//the chosen platform
46
47     cl_uint numPlatforms;//the NO. of platforms
48     cl_int    status = clGetPlatformIDs(0, NULL, &numPlatforms);
49     if (status != CL_SUCCESS)
50     {
51         cout<<"Error: Getting platforms!"<<endl;
52         return -1;
53     }
54
55     /**For clarity, choose the first available platform. */
56     if(numPlatforms > 0)
57     {
58         cl_platform_id* platforms =
59             (cl_platform_id* )malloc(numPlatforms* sizeof(cl_platform_id));
60         status = clGetPlatformIDs(numPlatforms, platforms, NULL);
61         platform = platforms[0];
62         free(platforms);
63     }
64     else
65         return -1;
66 }
67
68 /**Step 2:Query the platform and choose the first GPU device if has one.*/
69 cl_device_id *getCl_device_id(cl_platform_id &platform)
70 {
71     cl_uint numDevices = 0;
72     cl_device_id *devices=NULL;
73     cl_int    status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &numDevices);
74     if (numDevices > 0) //GPU available.
75     {
76         devices = (cl_device_id*)malloc(numDevices * sizeof(cl_device_id));
77         status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numDevices, devices, NULL);
78     }
79     return devices;
80 }

1 __kernel void helloworld(__global double* in, __global double* out)
2 {
3     int num = get_global_id(0);
4     out[num] = in[num] / 2.4 *(in[num]/6) ;
5 }

 1 //For clarity,error checking has been omitted.
 2 #include <CL/cl.h>
 3 #include "tool.h"
 4 #include <string.h>
 5 #include <stdio.h>
 6 #include <stdlib.h>
 7 #include <iostream>
 8 #include <string>
 9 #include <fstream>
10 using namespace std;
11
12 int main(int argc, char* argv[])
13 {
14     cl_int    status;
15     /**Step 1: Getting platforms and choose an available one(first).*/
16     cl_platform_id platform;
17     getPlatform(platform);
18
19     /**Step 2:Query the platform and choose the first GPU device if has one.*/
20     cl_device_id *devices=getCl_device_id(platform);
21
22     /**Step 3: Create context.*/
23     cl_context context = clCreateContext(NULL,1, devices,NULL,NULL,NULL);
24
25     /**Step 4: Creating command queue associate with the context.*/
26     cl_command_queue commandQueue = clCreateCommandQueue(context, devices[0], 0, NULL);
27
28     /**Step 5: Create program object */
29     const char *filename = "HelloWorld_Kernel.cl";
30     string sourceStr;
31     status = convertToString(filename, sourceStr);
32     const char *source = sourceStr.c_str();
33     size_t sourceSize[] = {strlen(source)};
34     cl_program program = clCreateProgramWithSource(context, 1, &source, sourceSize, NULL);
35
36     /**Step 6: Build program. */
37     status=clBuildProgram(program, 1,devices,NULL,NULL,NULL);
38
39     /**Step 7: Initial input,output for the host and create memory objects for the kernel*/
40     const int NUM=512000;
41     double* input = new double[NUM];
42     for(int i=0;i<NUM;i++)
43         input[i]=i;
44     double* output = new double[NUM];
45
46     cl_mem inputBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR, (NUM) * sizeof(double),(void *) input, NULL);
47     cl_mem outputBuffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY , NUM * sizeof(double), NULL, NULL);
48
49     /**Step 8: Create kernel object */
50     cl_kernel kernel = clCreateKernel(program,"helloworld", NULL);
51
52     /**Step 9: Sets Kernel arguments.*/
53     status = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&inputBuffer);
54     status = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&outputBuffer);
55
56     /**Step 10: Running the kernel.*/
57     size_t global_work_size[1] = {NUM};
58     cl_event enentPoint;
59     status = clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL, global_work_size, NULL, 0, NULL, &enentPoint);
60     clWaitForEvents(1,&enentPoint); ///wait
61     clReleaseEvent(enentPoint);
62
63     /**Step 11: Read the cout put back to host memory.*/
64     status = clEnqueueReadBuffer(commandQueue, outputBuffer, CL_TRUE, 0, NUM * sizeof(double), output, 0, NULL, NULL);
65     cout<<output[NUM-1]<<endl;
66
67     /**Step 12: Clean the resources.*/
68     status = clReleaseKernel(kernel);//*Release kernel.
69     status = clReleaseProgram(program);    //Release the program object.
70     status = clReleaseMemObject(inputBuffer);//Release mem object.
71     status = clReleaseMemObject(outputBuffer);
72     status = clReleaseCommandQueue(commandQueue);//Release  Command queue.
73     status = clReleaseContext(context);//Release context.
74
75     if (output != NULL)
76     {
77         free(output);
78         output = NULL;
79     }
80
81     if (devices != NULL)
82     {
83         free(devices);
84         devices = NULL;
85     }
86     return 0;
87 }