C++ 多个类的DLL封装以及隐式链接和显式链接2种方法调用

最新推荐文章于 2024-03-20 07:46:46 发布
最新推荐文章于 2024-03-20 07:46:46 发布
阅读量5k 收藏 19
点赞数 1
分类专栏： opencv OpenCL C++ 文章标签： C++ opencv OpenCL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/waterbinbin/article/details/52625508
版权
C++ 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
opencv
2 篇文章 0 订阅
订阅专栏
OpenCL
2 篇文章 0 订阅
订阅专栏

将OpenCL和OpenCV一些简单的方法封装成DLL，具体OpenCL和OpenCV的配置方法可以参考本人的博客。

VS2015下安装与编译OpenCV源码并在VS2015下配置OpenCV环境

VS上运行CUDA，并在NVDIA显卡安装的CUDA中运行OpenCL


1.  DLL封装

（1）  创建DLL工程

新建一个Win32控制台应用程序，项目名称为buildopencldll，选择DLL和空项目。

（2）新建头文件

头文件：createopencldll.h

向动态链接库添加类的核心代码： 
#ifdef CREATEOPENCLDLL_EXPORTS
#define CREATEOPENCLDLL_API __declspec(dllexport) 
#else
#define CREATEOPENCLDLL_API __declspec(dllimport) 
#endif
为显式链接做准备的导出函数： 
extern "C"
{
	CREATEOPENCLDLL_API CreateOpenCLDLL* GetCreateOpenCLDLL(void);
	typedef CreateOpenCLDLL* (*PFNGetCreateOpenCLDLL)(void);
}

创建类时必须加上 CREATEOPENCLDLL_API，如写成class CREATEOPENCLDLL_APICreateOpenCLDLL 要不然生成不了lib文件
完整的头文件代码如下： 
#pragma once
#ifndef _CREATEOPENCLDLL_H_
#define _CREATEOPENCLDLL_H_

#ifdef CREATEOPENCLDLL_EXPORTS
#define CREATEOPENCLDLL_API __declspec(dllexport) 
#else
#define CREATEOPENCLDLL_API __declspec(dllimport) 
#endif

#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif


class CREATEOPENCLDLL_API CreateOpenCLDLL
{
public:
	CreateOpenCLDLL();
	~CreateOpenCLDLL();
	//  选择平台并创建上下文  
	cl_context CreateContext();
	cl_command_queue CreateCommandQueue(cl_context context, cl_device_id *device);
	cl_program CreateProgram(cl_context context, cl_device_id device, const char* fileName);
	bool CreateMemObjects(cl_context context, cl_mem memObjects[3], float *a, float *b);
	void Cleanup(cl_context context, cl_command_queue commandQueue,
		cl_program program, cl_kernel kernel, cl_mem memObjects[3]);
	void Calcaute();

private:
	cl_context m_context;
	cl_command_queue m_commandQueue;
	cl_program m_program;
	cl_device_id m_device;
	cl_kernel m_kernel;
	cl_mem m_memObjects[3];
	cl_int m_errNum;
};
/* 导出函数声明 */
extern "C"
{
	CREATEOPENCLDLL_API CreateOpenCLDLL* GetCreateOpenCLDLL(void);
	typedef CreateOpenCLDLL* (*PFNGetCreateOpenCLDLL)(void);
}

#endif


（3）Cpp文件：createopencldll.cpp

需要添加：#define CREATEOPENCLDLL_EXPORTS

完整的cpp代码如下：

#define CREATEOPENCLDLL_EXPORTS

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <sstream>

#include "createopencldll.h"

using namespace std;

const int KArraySize = 1000;

CreateOpenCLDLL::CreateOpenCLDLL()
{
	m_context = 0;
	m_commandQueue = 0;
	m_program = 0;
	m_device = 0;
	m_kernel = 0;
	m_memObjects[0] = 0;
	m_memObjects[1] = 0;
	m_memObjects[2] = 0;
	m_errNum = 0;
}

CreateOpenCLDLL::~CreateOpenCLDLL()
{

}

//  选择平台并创建上下文
cl_context CreateOpenCLDLL::CreateContext()
{
	cl_int errNum;
	cl_uint numPlatforms;
	cl_platform_id firstPlatformId;
	cl_context context = NULL;

	//选择第一个可用的平台  
	errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
	if (errNum != CL_SUCCESS || numPlatforms <= 0)
	{
		std::cerr << "Failed to find any OpenCL platforms." << std::endl;
		return NULL;
	}

	// 创建一个opencl上下文，成功则使用GUP上下文，否则使用cpu  
	cl_context_properties contextProperties[] =
	{
		CL_CONTEXT_PLATFORM,
		(cl_context_properties)firstPlatformId,
		0
	};
	context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
		NULL, NULL, &errNum);
	if (errNum != CL_SUCCESS)
	{
		std::cout << "Could not create GPU context, trying CPU..." << std::endl;
		context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,
			NULL, NULL, &errNum);
		if (errNum != CL_SUCCESS)
		{
			std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
			return NULL;
		}
	}

	return context;
}

//选择第一个可用的设备并创建一个命令队列
cl_command_queue CreateOpenCLDLL::CreateCommandQueue(cl_context context, cl_device_id *device)
{
	cl_int errNum;
	cl_device_id *devices;
	cl_command_queue commandQueue = NULL;
	size_t deviceBufferSize = -1;

	//这个clGetContextInfo获得设备缓冲区的大小  
	errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &deviceBufferSize);
	if (errNum != CL_SUCCESS)
	{
		std::cerr << "Failed call to clGetContextInfo(...,GL_CONTEXT_DEVICES,...)";
		return NULL;
	}

	if (deviceBufferSize <= 0)
	{
		std::cerr << "No devices available.";
		return NULL;
	}

	//为设备缓冲区分配内存，这个clGetContextInfo用来获得上下文中所有可用的设备  
	devices = new cl_device_id[deviceBufferSize / sizeof(cl_device_id)];
	errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, deviceBufferSize, devices, NULL);
	if (errNum != CL_SUCCESS)
	{
		delete[] devices;
		std::cerr << "Failed to get device IDs";
		return NULL;
	}
	char    deviceName[512];
	char    deviceVendor[512];
	char    deviceVersion[512];
	errNum = clGetDeviceInfo(devices[0], CL_DEVICE_VENDOR, sizeof(deviceVendor),
		deviceVendor, NULL);
	errNum |= clGetDeviceInfo(devices[0], CL_DEVICE_NAME, sizeof(deviceName),
		deviceName, NULL);
	errNum |= clGetDeviceInfo(devices[0], CL_DEVICE_VERSION, sizeof(deviceVersion),
		deviceVersion, NULL);

	printf("OpenCL Device Vendor = %s,  OpenCL Device Name = %s,  OpenCL Device Version = %s\n", deviceVendor, deviceName, deviceVersion);
	// 在这个例子中，我们只选择第一个可用的设备。在实际的程序，你可能会使用所有可用的设备或基于OpenCL设备查询选择性能最高的设备  
	commandQueue = clCreateCommandQueue(context, devices[0], 0, NULL);
	if (commandQueue == NULL)
	{
		delete[] devices;
		std::cerr << "Failed to create commandQueue for device 0";
		return NULL;
	}

	*device = devices[0];
	delete[] devices;
	return commandQueue;
}

//从磁盘加载内核源文件并创建一个程序对象
cl_program CreateOpenCLDLL::CreateProgram(cl_context context, cl_device_id device, const char* fileName)
{
	cl_int errNum;
	cl_program program;

	std::ifstream kernelFile(fileName, std::ios::in);
	if (!kernelFile.is_open())
	{
		std::cerr << "Failed to open file for reading: " << fileName << std::endl;
		return NULL;
	}

	std::ostringstream oss;
	oss << kernelFile.rdbuf();

	std::string srcStdStr = oss.str();
	const char *srcStr = srcStdStr.c_str();
	//创建程序对象  
	program = clCreateProgramWithSource(context, 1,
		(const char**)&srcStr,
		NULL, NULL);
	if (program == NULL)
	{
		std::cerr << "Failed to create CL program from source." << std::endl;
		return NULL;
	}
	//编译内核源代码  
	errNum = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
	if (errNum != CL_SUCCESS)
	{
		// 编译失败可以通过clGetProgramBuildInfo获取日志  
		char buildLog[16384];
		clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,
			sizeof(buildLog), buildLog, NULL);

		std::cerr << "Error in kernel: " << std::endl;
		std::cerr << buildLog;
		clReleaseProgram(program);
		return NULL;
	}

	return program;
}

//创建内存对象 
bool CreateOpenCLDLL::CreateMemObjects(cl_context context, cl_mem memObjects[3],float *a, float *b)
{
	//创建内存对象  
	memObjects[0] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(float)* KArraySize, a, NULL);
	memObjects[1] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(float)* KArraySize, b, NULL);
	memObjects[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
		sizeof(float)* KArraySize, NULL, NULL);

	if (memObjects[0] == NULL || memObjects[1] == NULL || memObjects[2] == NULL)
	{
		std::cerr << "Error creating memory objects." << std::endl;
		return false;
	}

	return true;
}

//清理任何创建OpenCL的资源 
void CreateOpenCLDLL::Cleanup(cl_context context, cl_command_queue commandQueue,
	cl_program program, cl_kernel kernel, cl_mem memObjects[3])
{
	for (int i = 0; i < 3; i++)
	{
		if (memObjects[i] != 0)
			clReleaseMemObject(memObjects[i]);
	}
	if (commandQueue != 0)
		clReleaseCommandQueue(commandQueue);

	if (kernel != 0)
		clReleaseKernel(kernel);

	if (program != 0)
		clReleaseProgram(program);

	if (context != 0)
		clReleaseContext(context);
}

void CreateOpenCLDLL::Calcaute()
{
	// 创建opencl上下文和第一个可用平台  
	m_context = CreateContext();
	if (m_context == NULL)
	{
		std::cerr << "Failed to create OpenCL context." << std::endl;
	}

	// 在创建的一个上下文中选择第一个可用的设备并创建一个命令队列  
	m_commandQueue = CreateCommandQueue(m_context, &m_device);
	if (m_commandQueue == NULL)
	{
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	// 创建一个程序对象 HelloWorld.cl kernel source  
	m_program = CreateProgram(m_context, m_device, "HelloWorld.cl");
	if (m_program == NULL)
	{
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	// 创建内核  
	m_kernel = clCreateKernel(m_program, "hello_kernel", NULL);
	if (m_kernel == NULL)
	{
		std::cerr << "Failed to create kernel" << std::endl;
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	// 创建一个将用作参数内核内存中的对象。首先创建将被用来将参数存储到内核主机存储器阵列  
	float result[KArraySize];
	float a[KArraySize];
	float b[KArraySize];
	for (int i = 0; i < KArraySize; i++)
	{
		a[i] = (float)i;
		b[i] = (float)(i * 2);
	}

	if (!CreateMemObjects(m_context, m_memObjects, a, b))
	{
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	// 设置内核参数、执行内核并读回结果  
	m_errNum = clSetKernelArg(m_kernel, 0, sizeof(cl_mem), &m_memObjects[0]);
	m_errNum |= clSetKernelArg(m_kernel, 1, sizeof(cl_mem), &m_memObjects[1]);
	m_errNum |= clSetKernelArg(m_kernel, 2, sizeof(cl_mem), &m_memObjects[2]);
	if (m_errNum != CL_SUCCESS)
	{
		std::cerr << "Error setting kernel arguments." << std::endl;
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	size_t globalWorkSize[1] = { KArraySize };//让之等于数组的大小  
	size_t localWorkSize[1] = { 1 };  //让之等于1  

									  // 利用命令队列使将在设备执行的内核排队  

	m_errNum = clEnqueueNDRangeKernel(m_commandQueue, m_kernel, 1, NULL,
		globalWorkSize, localWorkSize,
		0, NULL, NULL);
	if (m_errNum != CL_SUCCESS)
	{
		std::cerr << "Error queuing kernel for execution." << std::endl;
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	std::cout << "Executed program succesfully." << std::endl;
	// Read the output buffer back to the Host  


	m_errNum = clEnqueueReadBuffer(m_commandQueue, m_memObjects[2], CL_TRUE,
		0, KArraySize * sizeof(float), result,
		0, NULL, NULL);
	if (m_errNum != CL_SUCCESS)
	{
		std::cerr << "Error reading result buffer." << std::endl;
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}


	//输出结果  
	for (int i = 0; i < KArraySize; i++)
	{
		std::cout << result[i] << " ";
	}
	std::cout << std::endl;
	std::cout << "Executed program succesfully." << std::endl;
	Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);

}
/* 导出函数定义 */
CreateOpenCLDLL* GetCreateOpenCLDLL(void)
{
	CreateOpenCLDLL* pCreateOpenCLDLL = new CreateOpenCLDLL();
	return pCreateOpenCLDLL;
}


（4）生成代码

按生成后，在的debug或者release文件夹中，会生成相应的DLL文件和LIB文件，如下图生成buildopencldll.dll，buildopencldll.lib



2. C++ 多个类的DLL封装

封装好一个类之后，在后面的类可以调用这个类生成的dll，再封装新类的dll。具体过程可以参考第1步。

在工程中添加头文件createopencldll.h到新的工程目录。在debug或者release文件中复制buildopencldll.lib到新的工程目录如下：

在项目中，属性->连接器->输入->附加依赖项中，添加buildopencldll.lib

将buildopencldll.dll复制到新工程的debug或者release目录下。
具体新项目的createopencvdll.h代码如下：
 
#pragma once
#ifdef CREATEOPENCVDLL_EXPORTS
#define CREATEOPENCVDLL_API __declspec(dllexport) 
#else
#define CREATEOPENCVDLL_API __declspec(dllimport) 
#endif

#include "createopencldll.h"

#include "opencv2\opencv_modules.hpp"
#include "opencv2\highgui\highgui.hpp"
#include "opencv2\core\core.hpp"

using namespace cv;

class CREATEOPENCVDLL_API CreateOpenCVDLL
{
public:
	CreateOpenCVDLL();
	~CreateOpenCVDLL();
	void showImage();

private:
	Mat m_image;
};

createopencvdll.cpp代码如下： 
#define CREATEOPENCVDLL_EXPORTS

#include "createopencvdll.h"

CreateOpenCVDLL::CreateOpenCVDLL()
{

}

CreateOpenCVDLL::~CreateOpenCVDLL()
{

}

void CreateOpenCVDLL::showImage()
{
	m_image = imread("1.jpg");
	namedWindow("image", CV_WINDOW_AUTOSIZE);
	imshow("image", m_image);
	cvWaitKey(0);
}

3. DLL的调用

新建一个win32控制台应用程序，选择控制台应用程序，工程名字为：testdll，新建main函数。


（1）隐式链接

方法1：

在工程中添加头文件createopencldll.h到新的工程目录。在debug或者release文件中复制buildopencldll.lib到新的工程目录如下：

在项目中，属性->连接器->输入->附加依赖项中，添加buildopencldll.lib

将buildopencldll.dll复制到新工程的debug或者release目录下。
测试代码如下：
 
#include "createopencldll.h"

int main()
{
	CreateOpenCLDLL createopencldll;
	createopencldll.Calcaute();
	return 0;
}
结果图如下：


方法2：

在方法1的基础下，不添加buildopencldll.lib到附加依赖项中，使用代码的方式添加，即在原来的代码下多添加： #pragma comment( lib, "buildopencldll.lib")代码如下： 
#pragma comment(lib, "buildopencldll.lib")

#include "createopencldll.h"

int main()
{
	CreateOpenCLDLL createopencldll;
	createopencldll.Calcaute();
	return 0;
}

（2）显式链接

参考博客：http://blog.csdn.net/chollima/article/details/5324808

这个博客先定义虚基类，然后到基类等的实现，这样比较好。

这种方法不需要createopencldll.lib，将createopencldll.dll复制到debug或者release目录。

具体实现代码如下：
增加一个虚基类：createdll.h 
#pragma once
#ifndef _CREATEDLL_H_
#define _CREATEDLL_H_

#ifdef CREATEDLL_EXPORTS
#define CREATEDLL_API __declspec(dllexport) 
#else
#define CREATEDLL_API __declspec(dllimport) 
#endif
/*
设计这个接口类的作用：
能采用动态调用方式使用这个类
*/
#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif

class CREATEDLL_API CreateDLL
{
public:
	CreateDLL() {}
	virtual ~CreateDLL(void) {};
	//  选择平台并创建上下文  
	virtual cl_context CreateContext() = 0;
	virtual cl_command_queue CreateCommandQueue(cl_context context, cl_device_id *device) = 0;
	virtual cl_program CreateProgram(cl_context context, cl_device_id device, const char* fileName) = 0;
	virtual bool CreateMemObjects(cl_context context, cl_mem memObjects[3], float *a, float *b) = 0;
	virtual void Cleanup(cl_context context, cl_command_queue commandQueue,
		cl_program program, cl_kernel kernel, cl_mem memObjects[3]) = 0;
	virtual void Calcaute() = 0;

};
/* 导出函数声明 */
extern "C"
{
	CREATEDLL_API CreateDLL* GetCreateDLL(void);
	typedef CreateDLL* (*PFNGetCreateOpenCLDLL)(void);
}

#endif


createopencldll.h 更改如下：


#pragma once
#define CREATEDLL_EXPORTS
#include "createdll.h"

class CREATEDLL_API CreateOpenCLDLL :public CreateDLL
{
public:
	CreateOpenCLDLL();
	~CreateOpenCLDLL();
	//  选择平台并创建上下文  
	cl_context CreateContext();
	cl_command_queue CreateCommandQueue(cl_context context, cl_device_id *device);
	cl_program CreateProgram(cl_context context, cl_device_id device, const char* fileName);
	bool CreateMemObjects(cl_context context, cl_mem memObjects[3], float *a, float *b);
	void Cleanup(cl_context context, cl_command_queue commandQueue,
		cl_program program, cl_kernel kernel, cl_mem memObjects[3]);
	void Calcaute();

private:
	cl_context m_context;
	cl_command_queue m_commandQueue;
	cl_program m_program;
	cl_device_id m_device;
	cl_kernel m_kernel;
	cl_mem m_memObjects[3];
	cl_int m_errNum;
	cl_event m_prof_event;
	cl_int   m_status;

};


//#pragma once
//#ifndef _CREATEOPENCLDLL_H_
//#define _CREATEOPENCLDLL_H_
//
//#ifdef CREATEOPENCLDLL_EXPORTS
//#define CREATEOPENCLDLL_API __declspec(dllexport) 
//#else
//#define CREATEOPENCLDLL_API __declspec(dllimport) 
//#endif
//
//#ifdef __APPLE__
//#include <OpenCL/cl.h>
//#else
//#include <CL/cl.h>
//#endif
//
//
//class CREATEOPENCLDLL_API CreateOpenCLDLL
//{
//public:
//	CreateOpenCLDLL();
//	~CreateOpenCLDLL();
//	//  选择平台并创建上下文  
//	cl_context CreateContext();
//	cl_command_queue CreateCommandQueue(cl_context context, cl_device_id *device);
//	cl_program CreateProgram(cl_context context, cl_device_id device, const char* fileName);
//	bool CreateMemObjects(cl_context context, cl_mem memObjects[3], float *a, float *b);
//	void Cleanup(cl_context context, cl_command_queue commandQueue,
//		cl_program program, cl_kernel kernel, cl_mem memObjects[3]);
//	void Calcaute();
//
//private:
//	cl_context m_context;
//	cl_command_queue m_commandQueue;
//	cl_program m_program;
//	cl_device_id m_device;
//	cl_kernel m_kernel;
//	cl_mem m_memObjects[3];
//	cl_int m_errNum;
//};
///* 导出函数声明 */
//extern "C"
//{
//	CREATEOPENCLDLL_API CreateOpenCLDLL* GetCreateOpenCLDLL(void);
//	typedef CreateOpenCLDLL* (*PFNGetCreateOpenCLDLL)(void);
//}
//
//#endif

createopencldll.cpp更改如下： 


//#define CREATEOPENCLDLL_EXPORTS

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <sstream>
#include <time.h>

#include "createopencldll.h"

using namespace std;

const int KArraySize = 1000;

CreateOpenCLDLL::CreateOpenCLDLL()
{
	m_context = 0;
	m_commandQueue = 0;
	m_program = 0;
	m_device = 0;
	m_kernel = 0;
	m_memObjects[0] = 0;
	m_memObjects[1] = 0;
	m_memObjects[2] = 0;
	m_errNum = 0;
}

CreateOpenCLDLL::~CreateOpenCLDLL()
{

}

//  选择平台并创建上下文  
cl_context CreateOpenCLDLL::CreateContext()
{
	cl_int errNum;
	cl_uint numPlatforms;
	cl_platform_id firstPlatformId;
	cl_context context = NULL;

	//选择第一个可用的平台    
	errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
	if (errNum != CL_SUCCESS || numPlatforms <= 0)
	{
		std::cerr << "Failed to find any OpenCL platforms." << std::endl;
		return NULL;
	}

	// 创建一个opencl上下文，成功则使用GUP上下文，否则使用cpu    
	cl_context_properties contextProperties[] =
	{
		CL_CONTEXT_PLATFORM,
		(cl_context_properties)firstPlatformId,
		0
	};
	context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
		NULL, NULL, &errNum);
	if (errNum != CL_SUCCESS)
	{
		std::cout << "Could not create GPU context, trying CPU..." << std::endl;
		context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,
			NULL, NULL, &errNum);
		if (errNum != CL_SUCCESS)
		{
			std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
			return NULL;
		}
	}

	return context;
}

//选择第一个可用的设备并创建一个命令队列  
cl_command_queue CreateOpenCLDLL::CreateCommandQueue(cl_context context, cl_device_id *device)
{
	cl_int errNum;
	cl_device_id *devices;
	cl_command_queue commandQueue = NULL;
	size_t deviceBufferSize = -1;

	//这个clGetContextInfo获得设备缓冲区的大小    
	errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &deviceBufferSize);
	if (errNum != CL_SUCCESS)
	{
		std::cerr << "Failed call to clGetContextInfo(...,GL_CONTEXT_DEVICES,...)";
		return NULL;
	}

	if (deviceBufferSize <= 0)
	{
		std::cerr << "No devices available.";
		return NULL;
	}

	//为设备缓冲区分配内存，这个clGetContextInfo用来获得上下文中所有可用的设备    
	devices = new cl_device_id[deviceBufferSize / sizeof(cl_device_id)];
	errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, deviceBufferSize, devices, NULL);
	if (errNum != CL_SUCCESS)
	{
		delete[] devices;
		std::cerr << "Failed to get device IDs";
		return NULL;
	}
	char    deviceName[512];
	char    deviceVendor[512];
	char    deviceVersion[512];
	errNum = clGetDeviceInfo(devices[0], CL_DEVICE_VENDOR, sizeof(deviceVendor),
		deviceVendor, NULL);
	errNum |= clGetDeviceInfo(devices[0], CL_DEVICE_NAME, sizeof(deviceName),
		deviceName, NULL);
	errNum |= clGetDeviceInfo(devices[0], CL_DEVICE_VERSION, sizeof(deviceVersion),
		deviceVersion, NULL);

	printf("OpenCL Device Vendor = %s,  OpenCL Device Name = %s,  OpenCL Device Version = %s\n", deviceVendor, deviceName, deviceVersion);
	// 在这个例子中，我们只选择第一个可用的设备。在实际的程序，你可能会使用所有可用的设备或基于OpenCL设备查询选择性能最高的设备    
	commandQueue = clCreateCommandQueue(context, devices[0], 0, NULL);
	if (commandQueue == NULL)
	{
		delete[] devices;
		std::cerr << "Failed to create commandQueue for device 0";
		return NULL;
	}

	*device = devices[0];
	delete[] devices;
	return commandQueue;
}

//从磁盘加载内核源文件并创建一个程序对象  
cl_program CreateOpenCLDLL::CreateProgram(cl_context context, cl_device_id device, const char* fileName)
{
	cl_int errNum;
	cl_program program;

	std::ifstream kernelFile(fileName, std::ios::in);
	if (!kernelFile.is_open())
	{
		std::cerr << "Failed to open file for reading: " << fileName << std::endl;
		return NULL;
	}

	std::ostringstream oss;
	oss << kernelFile.rdbuf();

	std::string srcStdStr = oss.str();
	const char *srcStr = srcStdStr.c_str();
	//创建程序对象    
	program = clCreateProgramWithSource(context, 1,
		(const char**)&srcStr,
		NULL, NULL);
	if (program == NULL)
	{
		std::cerr << "Failed to create CL program from source." << std::endl;
		return NULL;
	}
	//编译内核源代码    
	errNum = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
	if (errNum != CL_SUCCESS)
	{
		// 编译失败可以通过clGetProgramBuildInfo获取日志    
		char buildLog[16384];
		clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,
			sizeof(buildLog), buildLog, NULL);

		std::cerr << "Error in kernel: " << std::endl;
		std::cerr << buildLog;
		clReleaseProgram(program);
		return NULL;
	}

	return program;
}

//创建内存对象   
bool CreateOpenCLDLL::CreateMemObjects(cl_context context, cl_mem memObjects[3], float *a, float *b)
{
	//创建内存对象    
	memObjects[0] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(float)* KArraySize, a, NULL);
	memObjects[1] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(float)* KArraySize, b, NULL);
	memObjects[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
		sizeof(float)* KArraySize, NULL, NULL);

	if (memObjects[0] == NULL || memObjects[1] == NULL || memObjects[2] == NULL)
	{
		std::cerr << "Error creating memory objects." << std::endl;
		return false;
	}

	return true;
}

//清理任何创建OpenCL的资源   
void CreateOpenCLDLL::Cleanup(cl_context context, cl_command_queue commandQueue,
	cl_program program, cl_kernel kernel, cl_mem memObjects[3])
{
	for (int i = 0; i < 3; i++)
	{
		if (memObjects[i] != 0)
			clReleaseMemObject(memObjects[i]);
	}
	if (commandQueue != 0)
		clReleaseCommandQueue(commandQueue);

	if (kernel != 0)
		clReleaseKernel(kernel);

	if (program != 0)
		clReleaseProgram(program);

	if (context != 0)
		clReleaseContext(context);
}

void CreateOpenCLDLL::Calcaute()
{
	// 创建opencl上下文和第一个可用平台    
	m_context = CreateContext();
	if (m_context == NULL)
	{
		std::cerr << "Failed to create OpenCL context." << std::endl;
	}

	// 在创建的一个上下文中选择第一个可用的设备并创建一个命令队列    
	m_commandQueue = CreateCommandQueue(m_context, &m_device);
	if (m_commandQueue == NULL)
	{
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	// 创建一个程序对象 HelloWorld.cl kernel source    
	m_program = CreateProgram(m_context, m_device, "HelloWorld.cl");
	if (m_program == NULL)
	{
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	// 创建内核    
	m_kernel = clCreateKernel(m_program, "hello_kernel", NULL);
	if (m_kernel == NULL)
	{
		std::cerr << "Failed to create kernel" << std::endl;
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	// 创建一个将用作参数内核内存中的对象。首先创建将被用来将参数存储到内核主机存储器阵列    
	float result[KArraySize];
	float a[KArraySize];
	float b[KArraySize];
	for (int i = 0; i < KArraySize; i++)
	{
		a[i] = (float)i;
		b[i] = (float)(i * 2);
	}

	if (!CreateMemObjects(m_context, m_memObjects, a, b))
	{
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	// 设置内核参数、执行内核并读回结果    
	m_errNum = clSetKernelArg(m_kernel, 0, sizeof(cl_mem), &m_memObjects[0]);
	m_errNum |= clSetKernelArg(m_kernel, 1, sizeof(cl_mem), &m_memObjects[1]);
	m_errNum |= clSetKernelArg(m_kernel, 2, sizeof(cl_mem), &m_memObjects[2]);
	if (m_errNum != CL_SUCCESS)
	{
		std::cerr << "Error setting kernel arguments." << std::endl;
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	size_t globalWorkSize[1] = { KArraySize };//让之等于数组的大小    
	size_t localWorkSize[1] = { 1 };  //让之等于1    

									  // 利用命令队列使将在设备执行的内核排队    

	m_errNum = clEnqueueNDRangeKernel(m_commandQueue, m_kernel, 1, NULL,
		globalWorkSize, localWorkSize,
		0, NULL, NULL);
	if (m_errNum != CL_SUCCESS)
	{
		std::cerr << "Error queuing kernel for execution." << std::endl;
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}

	std::cout << "Executed program succesfully." << std::endl;
	// Read the output buffer back to the Host    


	m_errNum = clEnqueueReadBuffer(m_commandQueue, m_memObjects[2], CL_TRUE,
		0, KArraySize * sizeof(float), result,
		0, NULL, NULL);
	if (m_errNum != CL_SUCCESS)
	{
		std::cerr << "Error reading result buffer." << std::endl;
		Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);
	}


	//输出结果    
	for (int i = 0; i < KArraySize; i++)
	{
		std::cout << result[i] << " ";
	}
	std::cout << std::endl;
	std::cout << "Executed program succesfully." << std::endl;
	Cleanup(m_context, m_commandQueue, m_program, m_kernel, m_memObjects);

}
///* 导出函数定义 */
//CreateOpenCLDLL* GetCreateOpenCLDLL(void)
//{
//	CreateOpenCLDLL* pCreateOpenCLDLL = new CreateOpenCLDLL();
//	return pCreateOpenCLDLL;
//}

/* 导出函数定义 */
CreateDLL* GetCreateDLL(void)
{
	CreateDLL* pCreateDLL = new CreateOpenCLDLL();
	return pCreateDLL;
}

测试代码：buildopencldll项目中在新建一个工程 testexplicitdll

testexplicitdll.cpp代码如下：


#include <windows.h>  
#include <cstdio>  
#include "..\buildopencldll\createdll.h"
#include "..\buildopencldll\createopencldll.h"

using namespace std;
int main()
{
	//..\\Debug\\buildopencldll.dll出现红色波浪线需要在字符集设置为 未设置
	//HMODULE hDll = ::LoadLibrary("..\\Debug\\buildopencldll.dll");
	//if (NULL != hDll)
	//{
	//	PFNGetCreateOpenCLDLL pFun = (PFNGetCreateOpenCLDLL)::GetProcAddress(hDll, "GetCreateOpenCLDLL");
	//	if (NULL != pFun)
	//	{
	//		CreateOpenCLDLL* createOpenCLDLL = (*pFun)();
	//		if (NULL != createOpenCLDLL)
	//		{
	//			createOpenCLDLL->Calcaute();
	//			delete createOpenCLDLL;
	//		}
	//	}
	//	::FreeLibrary(hDll);
	//}

	HMODULE hDll = ::LoadLibrary("..\\Debug\\buildopencldll.dll");
	if (NULL != hDll)
	{
		PFNGetCreateOpenCLDLL pFun = (PFNGetCreateOpenCLDLL)::GetProcAddress(hDll, "GetCreateDLL");
		if (NULL != pFun)
		{
			CreateDLL* createOpenCLDLL = (*pFun)();
			if (NULL != createOpenCLDLL)
			{
				createOpenCLDLL->Calcaute();
				delete createOpenCLDLL;
			}
		}
		::FreeLibrary(hDll);
	}
	return 0;
}


所有demo代码可以在如下链接下载：

demo代码



如果出现错误：

错误    C2664       “HMODULELoadLibraryW(LPCWSTR)”: 无法将参数 1 从“const char [19]”转换为“LPCWSTR”    bulidopecvdll    f:\openclproject\bulidopecvdll\bulidopecvdll\main.cpp  18

进入属性->常规->字符集，将使用Unicode字符集改为未设置即可。

waterbinbin
关注
专栏目录
# Ｃ＋＋的DLL封装以及调用（类、VS2019）
JSBYWUYR的博客
01-11 1839
因工作需要，对C++部分代码进行DLL封装。涉及到几个问题： 拿到手的是已经完成的项目，要对其中部分代码进行DLL封装，代码主要是类内的成员函数。所以在不改变项目其他部分的情况下，只对成员函数的具体实现封装。这里涉及到在某一个类内对其他类的调用。 鉴于对DLL的显式调用有些繁琐，故采用隐式调用，隐式调用我知道的有两种方法，我只用了一种，出于可移植性考虑。 DLL的创建 这里直接在新建时选择创建动态链接库即可。 第一步：新建自己的 .h 和 .cpp 文件。格式大致如下： 其中__declspec(dl
OpenCL.dll是什么文件，找不到OpenCL.dll的5种有效解决方法
最新发布
Cybertronnnnnn的博客
07-22 1080
在使用电脑的过程中，可能会突然遇到“找不到 OpenCL.dll”的错误提示，那么OpenCL.dll是什么文件？这个问题又该如何解决？下面就来详细看看吧。OpenCL.dll 是 Open Computing Language（开放计算语言）的一个重要动态链接库文件。它在许多需要进行并行计算和图形处理的应用中发挥着关键作用。当系统无法找到这个文件时，相关的程序和功能就可能无法正常运行。
C++ 多个类的DLL封装以及隐式链接和显式链接
吾王★Excalibur
01-08 1045
将OpenCL和OpenCV一些简单的方法封装成DLL，具体OpenCL和OpenCV的配置方法可以参考本人的博客。 VS2015下安装与编译OpenCV源码并在VS2015下配置OpenCV环境 VS上运行CUDA，并在NVDIA显卡安装的CUDA中运行OpenCL 1.  DLL封装 （1）  创建DLL工程 新建一个Win32控制台应用程序，项目名称为buildopencldll，选择
【C++】多个类的DLL封装及调用
xiao_PuZi的博客
04-04 7755
原文地址：http://blog.csdn.net/xiaowei_cqu/article/details/7737682 项目中需要把一些共通的功能，抽出来做一个dll来调用。因为是以类作为单位的，资料确实少，主要参考了上面那篇博文。需要补充的一点是：程序能够正常调用，但是偶尔会发生accessviolationException，查到的结果是，函数声明时未添加_stdcall，导致缺
c++类函数代码打包成dll及其如何调用
一千零一夜的博客
02-17 8938
调用c++ dll类库
两种方法封装调用MFC-dll
04-20
本文将深入探讨两种封装调用MFC-DLL（动态链接库）的方法：显示封装和隐式封装，并分析它们各自的优势。 首先，我们来理解什么是DLL。DLL是一种可重用代码的模块，它包含可供多个程序同时使用的函数和资源。在MFC...
如何在DLL中导出与封装C++类
01-06
### 如何在DLL中导出与封装C++...通过这样的封装和调用方式，原本只能在隐式加载DLL中使用的C++类现在也可以在LoadRunner的虚拟用户脚本中发挥作用了。这种方法不仅提高了代码的复用性，也增强了脚本的灵活性和扩展性。
静态、动态链接库的创建和调用
01-06
动态链接库主要分为两种：加载时动态链接（也称隐式链接）和运行时动态链接（也称显式链接）。在加载时动态链接中，应用程序像调用本地函数一样调用DLL中导出的函数，且需要在编译和链接时提供头文件和导入库文件，...
MFCDLL.rar_MFCdll_mfc d_mfc 调用MFCdll_mfc 调用dll_visual Studio 200
09-21
隐式链接是将DLL作为一个静态库链接到调用程序中，而显式链接则是在运行时动态加载和卸载DLL。这两种方法各有优缺点，具体使用哪种取决于应用的需求和场景。 总之，通过这个项目文件，我们可以学习到如何在Visual ...
C++之DLL详解
飞鹤的程序员人生
05-14 3624
基本上涉及到了VC++编写DLL经常使用的大部分内容,主要面向有一定工作经验的VC++程序员,以实用为主,言简意赅. 希望看过这篇文章的程序员人能够不再为DLL的编写烦心了.
[C++]C++动态链接库（DLL）的创建和调用
FL1768317420的博客
03-20 3560
我们在编写C/C++等语言程序的时候，经常会遇到很多反复使用的或者常用的部分，如果没次都重新编写代码是一件十分麻烦且无意义的事情，会严重影响我们的工作效率以及代码的可读性，并且无法在其他项目重复使用我们的代码。2>>隐式链接采用静态加载的方式，需要将创建的.dll文件以及.lib文件还有定义的.h头文件,拷贝至我们需要测试的新项目的目录下。现在我们头文件中一个用于加法和减法的函数并加上宏定义的修饰符,以及声明一个需要导出的类的函数。在我们创建的.cpp文件中包含我们的.h头文件并且实现我们的函数。
C++（35)-隐式和显示调用动态库
aggie4628的专栏
08-17 1232
隐式和显示调用动态库
C++动态链接库 & 隐式调用动态库 & 显示调用动态库
羽觞醉月11的博客
05-27 2495
C++ 动态链接库 隐式调用 显式调用
C++——隐式调用动态库.dll
qxqsunshine的博客
03-31 1608
1、依据上个项目中创建的DemoDll工程。在此工程中添加新建项目，控制台程序。 然后再新建一个.cpp文件。里面的内容如下： // XianshiInvokeDll.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 #include <iostream> #include <Windows.h> //第一步，创建一个别名，它引用的的函数类型需要和dll中的导出函数一致 typedef int (*LPDO_ARRAY) (int* pArr, int
[C++][DLL][类]关于DLL封装和DLL类的使用等问题
qq_31103801的博客
03-01 3361
这里写自定义目录标题一、DLL的封装1、描述2、实现二、DLL类的使用1、描述2、实现三、踩过的坑1、方法无法调用问题2、类无法new以及类中方法无法调用3、没有生成lib文件4、预编译头问题 一、DLL的封装 1、描述 dll为动态库，他有非常好的封装性，也能保护源码， 相较于lib静态库，它拥有低内存的特性 并且调用分为两类，即显式调用和隐式调用 2、实现 1、首先在VS中创建动态库dll工程。 2、工程中拥有 pch.h 和 pch.cpp 文件 ，他们的名称可以修改，不过请把所有相关文件中的内
C++ 显式调用DLL
Sayesan的专栏
11-18 1958
1. DLL直接放到DEBUG目录下即可 2,程序中加入代码：例如DLL名为SendRcv.dll，方法名为Int ReadCard（char a[], char b[]） typedef int(*Dllfun)(char a[],char b[]); HRESULT CclassTestDlg::OnButtonCancel(IHTMLElement* /*pElemen
C/C++ dll的隐式调用与显式调用
热门推荐
zyb的博客
11-22 1万+
1.头文件、lib文件、dll文件 头文件：存放函数声明 dll文件：存放函数的定义，动态链接库文件Dynamic Link Library，运行时使用 lib文件：具体分静态编译与动态编译，编译时使用 静态编译 静态编译将导出声明和实现都放在lib中。编译后所有代码都嵌入到宿主程序。 静态编译的优点是编写出来的程序不需要调用DLL和载入函数，直接可以当成程序的一部分来使用。 静态编译的缺点也是显而易见的，使用静态编译的程序体积会比动态编译大，原因是函数的实现被嵌入为程序代码的一部分。 动态
调用DLL文件的两种方法（显式调用/隐式调用）完整示例
qq_41951658的博客
06-23 7198
显式调用 LoadLibrary() GetProcAddress() FreeLibrary() 三步 （1）LoadLibrary() 加载dll并返回一个hModule的句柄 （2）然后用GetProcAddress()获得test.dll中函数的的地址，（函数的入口点）之后就可以调用dll中的函数了 （3）最后要用FreeLibrary(hModule)卸载dll 优点：可以决定何时记载和卸载dll，充分体现DLL的灵活性。 隐式调用 #pragma comm...
C++动态链接库DLL的隐式与显式链接教程
"C++DLL操作说明" ...选择哪种链接方式取决于具体的应用场景，隐式链接适合于固定的、长期使用的函数库，而显式链接更适合于需要动态加载和卸载功能的场景。理解和掌握这两种链接方式是C++程序员必备的技能之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值