详细程序注解学OpenCL一环境配置和入门程序

关注

转载最新推荐文章于 2026-11-03 12:11:07 发布 1.8k 阅读 AI 写同款· GEO 优化 ›

OpenCL中kernel设置的序号关系发起kernel运算的API： cl_int enqueueNDRangeKernel( const Kernel& kernel, const NDRange& offset, const NDRange& global, const NDRange& local = NullRange, const VECTOR_CLASS<Event>* events = NULL, Event* event = NULL) 我们会设置数据数组的核心参数：阅读详情

本专栏是通过注解程序的方法学习OpenCL，我觉得一个一个地去抠原理也不是办法，干脆直接学习程序，然后把相关原理都直接注解到程序语句当中。

原创地址：http://blog.youkuaiyun.com/kenden23/article/details/14101657

一开始要配置好环境，我的是nvidia，所以就按照我的电脑举例，AMD应该也差不多。

1. 首先要到nvidia网站下载适合你显卡的最新驱动，安装好

2. 还是在nvidia网站下载好CUDA开发包，安装好

3. 如果默认安装路径的话，路径应该是在：C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v5.0

4. 打开这个目录会发现里面有include和lib文件夹，这就是我们需要配置在visual studio中的文件

5. 打开visual studio（版本基本都无关系，我用的是vs2012），新建一个win32空项目。按下alt+F7打开项目属性，也可以点击项目文件右键，选择属性。

6. 在属性页里面找到“C/C++”的“常规”项，点击，右边有“附加包含目录”，然后编辑，添加目录：C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v5.0\include

7.在属性页里面找到“连接器”，点击其“常规”项，右边有“附加库目录”，然后也是编辑，添加目录：C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v5.0\lib\Win32，如果是64位系统可以是：C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v5.0\lib\x64。

8. 在属性页里找到“常规”项，右边“附加依赖项”，编辑，添加lib文件：OpenCL.lib

9. 然后就可以新建源文件，在源文件里面添加相关的OpenCl程序，就可以调试OpenCL程序了。

下面就可以开始学习程序了。

下面是个入门程序，已经注释好了，注释包括了基本原理的解析，可以通过直接阅读和调试程序学习OpenCL了。

本程序是读取电脑中的支持OpenCL的硬件nvidia和intel和AMD等信息，然后显示在屏幕上。

[cpp] view plain copy print ?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#ifdef MAC
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
int main() {
/* Host data structures */
cl_platform_id *platforms;
//每一个cl_platform_id 结构表示一个在主机上的OpenCL执行平台，就是指电脑中支持OpenCL的硬件，如nvidia显卡，intel CPU和显卡，AMD显卡和CPU等
cl_uint num_platforms;
cl_int i, err, platform_index = -1;
/* Extension data */
char* ext_data;
size_t ext_size;
const char icd_ext[] = "cl_khr_icd";
//要使platform工作，需要两个步骤。1 需要为cl_platform_id结构分配内存空间。2 需要调用clGetPlatformIDs初始化这些数据结构。一般还需要步骤0：询问主机上有多少platforms
/* Find number of platforms */
//返回值如果为-1就说明调用函数失败，如果为0标明成功
//第二个参数为NULL代表要咨询主机上有多少个platform，并使用num_platforms取得实际flatform数量。
//第一个参数为1，代表我们需要取最多1个platform。可以改为任意大如：INT_MAX整数最大值。但是据说0，否则会报错，实际测试好像不会报错。下面是步骤0：询问主机有多少platforms
err = clGetPlatformIDs(5, NULL, &num_platforms);
if(err < 0) {
perror("Couldn't find any platforms.");
exit(1);
}
printf("I have platforms: %d\n", num_platforms); //本人计算机上显示为2，有intel和nvidia两个平台
/* Access all installed platforms */
//步骤1 创建cl_platform_id，并分配空间
platforms = (cl_platform_id*)
malloc(sizeof(cl_platform_id) * num_platforms);
//步骤2 第二个参数用指针platforms存储platform
clGetPlatformIDs(num_platforms, platforms, NULL);
/* Find extensions of all platforms */
//获取额外的平台信息。上面已经取得了平台id了，那么就可以进一步获取更加详细的信息了。
//一个for循环获取所有的主机上的platforms信息
for(i=0; i<num_platforms; i++)
{
/* Find size of extension data */
//也是和前面一样，先设置第三和第四个参数为0和NULL，然后就可以用第五个参数ext_size获取额外信息的长度了。
err = clGetPlatformInfo(platforms[i],
CL_PLATFORM_EXTENSIONS, 0, NULL, &ext_size);
if(err < 0)
{
perror("Couldn't read extension data.");
exit(1);
}
printf("The size of extension data is: %d\n", ext_size);//我的计算机显示224.
/* Access extension data */
//这里的ext_data相当于一个缓存，存储相关信息。
ext_data = (char*)malloc(ext_size);
//这个函数就是获取相关信息的函数，第二个参数指明了需要什么样的信息，如这里的CL_PLATFORM_EXTENSIONS表示是opencl支持的扩展功能信息。我计算机输出一大串，机器比较新（专门为了学图形学而购置的电脑），支持的东西比较多。
clGetPlatformInfo(platforms[i], CL_PLATFORM_EXTENSIONS,
ext_size, ext_data, NULL);
printf("Platform %d supports extensions: %s\n", i, ext_data);
//这里是输出生产商的名字，比如我显卡信息是：NVIDIA CUDA
char *name = (char*)malloc(ext_size);
clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME,
ext_size, name, NULL);
printf("Platform %d name: %s\n", i, name);
//这里是供应商信息，我显卡信息：NVIDIA Corporation
char *vendor = (char*)malloc(ext_size);
clGetPlatformInfo(platforms[i], CL_PLATFORM_VENDOR,
ext_size, vendor, NULL);
printf("Platform %d vendor: %s\n", i, vendor);
//最高支持的OpenCL版本，本机显示：OpenCL1.1 CUDA 4.2.1
char *version = (char*)malloc(ext_size);
clGetPlatformInfo(platforms[i], CL_PLATFORM_VERSION,
ext_size, version, NULL);
printf("Platform %d version: %s\n", i, version);
//这个只有两个值：full profile 和 embeded profile
char *profile = (char*)malloc(ext_size);
clGetPlatformInfo(platforms[i], CL_PLATFORM_PROFILE,
ext_size, profile, NULL);
printf("Platform %d full profile or embeded profile?: %s\n", i, profile);
/* Look for ICD extension */
//如果支持ICD这一扩展功能的platform，输出显示，本机的Intel和Nvidia都支持这一扩展功能
if(strstr(ext_data, icd_ext) != NULL)
platform_index = i;
std::cout<<"Platform_index = "<<platform_index<<std::endl;
/* Display whether ICD extension is supported */
if(platform_index > -1)
printf("Platform %d supports the %s extension.\n",
platform_index, icd_ext);
std::cout<<std::endl;
//释放空间
free(ext_data);
free(name);
free(vendor);
free(version);
free(profile);
}
if(platform_index <= -1)
printf("No platforms support the %s extension.\n", icd_ext);
/* Deallocate resources */
free(platforms);
return 0;
}

每个电脑的输出结果不一样的，我电脑的输出结果是：

OpenCL 查看设备信息

下面是注释程序，目的就是查看自己计算机上所有支持OpenCL的设备，并打印信息。

主函数调用run（）就可以运行了。要设置请看我另一篇OpenCl设置文章。

[cpp] view plain copy print ?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef MAC
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
namespace device_ext_test
{
int run() {
/* Host/device data structures */
cl_platform_id *platforms;
cl_device_id *devices;
cl_uint num_platforms;
cl_uint num_devices, addr_data;
cl_int i, err;
/* Extension data */
char name_data[48], ext_data[4096];
err = clGetPlatformIDs(5, NULL, &num_platforms);
if(err < 0) {
perror("Couldn't find any platforms.");
exit(1);
}
/* 选取所有的platforms*/
platforms = (cl_platform_id*)
malloc(sizeof(cl_platform_id) * num_platforms);
err = clGetPlatformIDs(num_platforms, platforms, NULL);
if(err < 0) {
perror("Couldn't find any platforms");
exit(1);
}
//循环查看所有platforms的devices信息，一般intel和AMD的都可以有两个devices：CPU和显卡
//如果是nvidia的就一般只有一个显卡device了。
for (int j = 0; j < (int)num_platforms; j++)
{
printf("\nplatform %d\n", j+1);
/* 步骤和platforms的一样 */
err = clGetDeviceIDs(platforms[j], CL_DEVICE_TYPE_ALL, 1, NULL, &num_devices);
if(err < 0) {
perror("Couldn't find any devices");
exit(1);
}
/* Access connected devices */
devices = (cl_device_id*)
malloc(sizeof(cl_device_id) * num_devices);
clGetDeviceIDs(platforms[j], CL_DEVICE_TYPE_ALL,
num_devices, devices, NULL);
/*循环显示platform的所有device（CPU和显卡）信息。*/
for(i=0; i<(int)num_devices; i++) {
err = clGetDeviceInfo(devices[i], CL_DEVICE_NAME,
sizeof(name_data), name_data, NULL);
if(err < 0) {
perror("Couldn't read extension data");
exit(1);
}
clGetDeviceInfo(devices[i], CL_DEVICE_ADDRESS_BITS,
sizeof(ext_data), &addr_data, NULL);
clGetDeviceInfo(devices[i], CL_DEVICE_EXTENSIONS,
sizeof(ext_data), ext_data, NULL);
printf("NAME: %s\nADDRESS_WIDTH: %u\nEXTENSIONS: %s\n\n",
name_data, addr_data, ext_data);
}
}
free(platforms);
free(devices);
printf("\n");
system("pause");
return 0;
}
}

OpenCL 操作context

本程序主要测试：

context = clCreateContext(NULL, 1, &device, NULL, NULL, &err);

创建一个context

clRetainContext(context);//Context的reference +1

clReleaseContext(context);//Context的reference -1

[cpp] view plain copy print ?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef MAC
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
namespace context_count
{
int run()
{
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_int err;
cl_uint ref_count;
err = clGetPlatformIDs(1, &platform, NULL);
if(err < 0) {
perror("Couldn't find any platforms");
exit(1);
}
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);
if(err == CL_DEVICE_NOT_FOUND) {
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, NULL);
}
if(err < 0) {
perror("Couldn't find any devices");
exit(1);
}
/* 创建 context */
context = clCreateContext(NULL, 1, &device, NULL, NULL, &err);
if(err < 0) {
perror("Couldn't create a context");
exit(1);
}
/* 获取reference count的数量，使用ref_count返回值*/
err = clGetContextInfo(context, CL_CONTEXT_REFERENCE_COUNT,
sizeof(ref_count), &ref_count, NULL);
if(err < 0) {
perror("Couldn't read the reference count.");
exit(1);
}
printf("Initial reference count: %u\n", ref_count);
/* 每次函数访问context的时候,调用clRetainContext，就是把context reference + 1，因为context并不是像platform和device那样delete的，而是clRetainContext的时候+1，当调用clReleaseContext的时候-1，当为零的时候，系统自动删除context。这就可以方便cl_context数据存活超过创建它的函数，可以让第三方库什么的继续访问context */
clRetainContext(context);clRetainContext(context);
clGetContextInfo(context, CL_CONTEXT_REFERENCE_COUNT,
sizeof(ref_count), &ref_count, NULL);
printf("Reference count: %u\n", ref_count);
clReleaseContext(context);
clGetContextInfo(context, CL_CONTEXT_REFERENCE_COUNT,
sizeof(ref_count), &ref_count, NULL);
printf("Reference count: %u\n", ref_count);
clReleaseContext(context);clReleaseContext(context);
system("pause");
return 0;
}
}

OpenCL 获取Program信息

本程序生成一个OpenCL Program，然后获取Program的source，其实它的source就是一个char[]，可以打印出来。

然后我们把这些内容和原来文本的内容对比，看看是否是我们想要读入的内容。

还可以测试是否编译正确，如果不正确会有输出提示的。

下面程序运行如下：

前面都是读入的函数代码。然后后面检查这些函数是否正确，可以看到第二个函数不正确，因为*r没有定义。

下面是完整代码：

[cpp] view plain copy print ?

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#ifdef MAC
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
namespace program_build
{
const static int NUM_FILES = 2;
const char PROGRAM_FILE_1[] = "good.cl";
const char *PROGRAM_FILE_2 = "bad.cl";
int run()
{
/*program可以包括多个kernel，一个kernel相当于一个功能函数，由program包含在内存中，然后就可以使用kernel的功能了。
1 需要使用kernel，创建program，把kernel读入内存
2 需要把program和device连接起来
Host/device data structures */
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_int i, err;
/* Program data structures */
cl_program program;
FILE *program_handle;
char *program_buffer[NUM_FILES];
char *program_log;
const char *file_name[] = {PROGRAM_FILE_1, PROGRAM_FILE_2};
const char options[] = "-cl-finite-math-only -cl-no-signed-zeros";
size_t program_size[NUM_FILES];
size_t log_size;
/* Access the first installed platform */
err = clGetPlatformIDs(1, &platform, NULL);
if(err < 0) {
perror("Couldn't find any platforms");
exit(1);
}
/* Access the first GPU/CPU */
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);
if(err == CL_DEVICE_NOT_FOUND) {
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, NULL);
}
if(err < 0) {
perror("Couldn't find any devices");
exit(1);
}
/* Create a context */
context = clCreateContext(NULL, 1, &device, NULL, NULL, &err);
if(err < 0) {
perror("Couldn't create a context");
exit(1);
}
/* Read each program file and place content into buffer array */
for(i=0; i<NUM_FILES; i++) {
program_handle = fopen(file_name[i], "r");
if(program_handle == NULL) {
perror("Couldn't find the program file");
exit(1);
}
fseek(program_handle, 0, SEEK_END);
program_size[i] = ftell(program_handle);
rewind(program_handle);
program_buffer[i] = (char*)malloc(program_size[i]+1);
program_buffer[i][program_size[i]] = '\0';
fread(program_buffer[i], sizeof(char), program_size[i],
program_handle);
fclose(program_handle);
}
/* Create a program containing all program content */
program = clCreateProgramWithSource(context, NUM_FILES,
(const char**)program_buffer, program_size, &err);
if(err < 0) {
perror("Couldn't create the program");
exit(1);
}
/* Build program
but one provision is crucial: every compiler must be accessible through clBuild-Program. This function compiles and links a cl_program for devices associated with the platform. It doesn’t return a new cl_program, but instead modifies the input data structure.
*/
err = clBuildProgram(program, 1, &device, options, NULL, NULL);
int bufSize = program_size[0] + program_size[1] + 1;
char *programBuffer = (char *) malloc(bufSize);
clGetProgramInfo(program, CL_PROGRAM_SOURCE, bufSize, programBuffer, NULL);
printf("Print Program Source:\n");
printf("\n %s \n", programBuffer);
printf("Check if it is correct:\n");
for (int i = 0; i < NUM_FILES; i++)
{
printf("\n %s \n", program_buffer[i]);
}
if(err < 0)
{
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,
0, NULL, &log_size);
program_log = (char*) malloc(log_size+1);
program_log[log_size] = '\0';
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,
log_size+1, program_log, NULL);
printf("%s\n", program_log);
free(program_log);
system("pause");
exit(1);
}
/* Deallocate resources */
for(i=0; i<NUM_FILES; i++) {
free(program_buffer[i]);
}
clReleaseProgram(program);
clReleaseContext(context);
system("pause");
return 0;
}
}