opencl 教程3

OpenCL内存对象：
OpenCL内存对象就是一些OpenCL数据，这些数据一般在设备内存中，能够被拷入也能够被拷出。OpenCL内存对象包括buffer对象和image对象。
buffer对象：连续的内存块----顺序存储，能够通过指针、行列式等直接访问。
image对象：是2维或3维的内存对象，只能通过read_image() 或 write_image()来读取。image对象可以是可读或可写的，但不能同时既可读又可写。

2011-5-28 12:09:02 上传

下载附件 (29.27 KB)

该函数会在指定的context上创建一个buffer对象，image对象相对比较复杂，留在后面再讲。

flags参数指定buffer对象的读写属性，host_ptr可以是NULL，如果不为NULL，一般是一个有效的host buffer对象，这时，函数创建OpenCL buffer对象后，会把对应host buffer的内容拷贝到OpenCL buffer中。

2011-5-28 12:09:08 上传

下载附件 (119.62 KB)

在Kernel执行之前，host中原始输入数据必须显式的传到device中，Kernel执行完后，结果也要从device内存中传回到host内存中。我们主要通过函数clEnqueue{Read|Write}{Buffer|Image}来实现这两种操作。从host到device，我们用clEnqueueWrite，从device到host，我们用clEnqueueRead。clEnqueueWrite命令包括初始化内存对象以及把host 数据传到device内存这两种操作。当然，像前面一段说的那样，也可以把host buffer指针直接用在CreateBuffer函数中来实现隐式的数据写操作。

2011-5-28 12:09:10 上传

下载附件 (41.58 KB)

这个函数初始化OpenCL内存对象，并把相应的数据写到OpenCL内存关联的设备内存中。其中，blocking_write参数指定是数拷贝完成后函数才返回还是数据开始拷贝后就立即返回（阻塞模式于非阻塞模式）。Events参数指定这个函数执行之前，必须要完成的Event（比如先要创建OpenCL内存对象的Event）。

2011-5-28 12:09:16 上传

下载附件 (105.45 KB)

OpenCL程序对象：
程序对象就是通过读入Kernel函数源代码或二进制文件，然后在指定的设备上进行编译而产生的OpenCL对象。

2011-5-28 12:09:21 上传

下载附件 (77.52 KB)

2011-5-28 12:09:22 上传

下载附件 (20.55 KB)

这个函数通过源代码(strings)，创建一个程序对象，其中counts指定源代码串的数量，lengths指定源代码串的长度（为NULL结束的串时，可以省略）。当然，我们还必须自己编写一个从文件中读取源代码串的函数。

2011-5-28 12:09:24 上传

下载附件 (24.97 KB)

对context中的每个设备，这个函数编译、连接源代码对象，产生device可以执行的文件，对GPU而言就是设备对应shader汇编。如果device_list参数被提供，则只对这些设备进行编译连接。options参数主要提供一些附加的编译选项，比如宏定义、优化开关标志等等。
如果程序编译失败，我们能够根据返回的状态，通过调用clGetProgramBuildInfo来得到错误信息。
加上创建内存对象以及程序对象的代码如下:

1. #include "stdafx.h"
   
2. #include <CL/cl.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <time.h>
   
6. #include <iostream>
   
7. #include <fstream>
   
8. using namespace std;
   
9. #define NWITEMS 262144
   
10. #pragma comment (lib,"OpenCL.lib")
    
11. //把文本文件读入一个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. if(f.is_open())
    
18. {
    
19. size_t fileSize;
    
20. f.seekg(0, std::fstream::end);
    
21. size = fileSize = (size_t)f.tellg();
    
22. f.seekg(0, std::fstream::beg);
    
23. str = new char[size+1];
    
24. if(!str)
    
25. {
    
26. f.close();
    
27. return NULL;
    
28. }
    
29. f.read(str, fileSize);
    
30. f.close();
    
31. str[size] = '\0';
    
32. 
    
33. s = str;
    
34. delete[] str;
    
35. return 0;
    
36. }
    
37. printf("Error: Failed to open file %s\n", filename);
    
38. return 1;
    
39. }
    
40. int main(int argc, char* argv[])
    
41. {
    
42. //在host内存中创建三个缓冲区
    
43. float *buf1 = 0;
    
44. float *buf2 = 0;
    
45. float *buf = 0;
    
46. 
    
47. buf1 =(float *)malloc(NWITEMS * sizeof(float));
    
48. buf2 =(float *)malloc(NWITEMS * sizeof(float));
    
49. buf =(float *)malloc(NWITEMS * sizeof(float));
    
50. //初始化buf1和buf2的内容
    
51. int i;
    
52. srand( (unsigned)time( NULL ) );
    
53. for(i = 0; i < NWITEMS; i++)
    
54. buf1[i] = rand()%65535;
    
55. srand( (unsigned)time( NULL ) +1000);
    
56. for(i = 0; i < NWITEMS; i++)
    
57. buf2[i] = rand()%65535;
    
58. cl_uint status;
    
59. cl_platform_id platform;
    
60. //创建平台对象
    
61. status = clGetPlatformIDs( 1, &platform, NULL );
    
62. cl_device_id device;
    
63. //创建GPU设备
    
64. clGetDeviceIDs( platform, CL_DEVICE_TYPE_GPU,
    
65. 1,
    
66. &device,
    
67. NULL);
    
68. //创建context
    
69. cl_context context = clCreateContext( NULL,
    
70. 1,
    
71. &device,
    
72. NULL, NULL, NULL);
    
73. //创建命令队列
    
74. cl_command_queue queue = clCreateCommandQueue( context,
    
75. device,
    
76. CL_QUEUE_PROFILING_ENABLE, NULL );
    
77. //创建三个OpenCL内存对象，并把buf1的内容通过隐式拷贝的方式
    
78. //拷贝到clbuf1,buf2的内容通过显示拷贝的方式拷贝到clbuf2
    
79. cl_mem clbuf1 = clCreateBuffer(context,
    
80. CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
    
81. NWITEMS*sizeof(cl_float),buf1,
    
82. NULL );
    
83. cl_mem clbuf2 = clCreateBuffer(context,
    
84. CL_MEM_READ_ONLY ,
    
85. NWITEMS*sizeof(cl_float),NULL,
    
86. NULL );
    
87. status = clEnqueueWriteBuffer(queue, clbuf2, 1,
    
88. 0, NWITEMS*sizeof(cl_float), buf2, 0, 0, 0);
    
89. cl_mem buffer = clCreateBuffer( context,
    
90. CL_MEM_WRITE_ONLY,
    
91. NWITEMS * sizeof(cl_float),
    
92. NULL, NULL );
    
93. const char * filename = "add.cl";
    
94. std::string sourceStr;
    
95. status = convertToString(filename, sourceStr);
    
96. const char * source = sourceStr.c_str();
    
97. size_t sourceSize[] = { strlen(source) };
    
98. //创建程序对象
    
99. cl_program program = clCreateProgramWithSource(
    
100. context,
     
101. 1,
     
102. &source,
     
103. sourceSize,
     
104. NULL);
     
105. //编译程序对象
     
106. status = clBuildProgram( program, 1, &device, NULL, NULL, NULL );
     
107. if(status != 0)
     
108. {
     
109. printf("clBuild failed:%d\n", status);
     
110. char tbuf[0x10000];
     
111. clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0x10000, tbuf, NULL);
     
112. printf("\n%s\n", tbuf);
     
113. return -1;
     
114. }
     
115. if(buf)
     
116. free(buf);
     
117. if(buf1)
     
118. free(buf1);
     
119. if(buf2)
     
120. free(buf2);
     
121. //删除OpenCL资源对象
     
122. clReleaseMemObject(clbuf1);
     
123. clReleaseMemObject(clbuf2);
     
124. clReleaseMemObject(buffer);
     
125. clReleaseProgram(program);
     
126. clReleaseCommandQueue(queue);
     
127. clReleaseContext(context);
     
128. return 0;
     
129. }

复制代码