精华内容
下载资源
问答
  • opencl环境配置

    2015-01-04 13:51:34
    opencl环境配置、配置OpenCL工程、64位配置、32位配置等
  • OpenCL 环境适配流程

    2017-06-08 10:30:04
    OpenCL 环境配置实例

    OpenCL 环境适配流程

    前期工作:了解系统配置,选择合适的软件
    利用GPU-Z的工具查看。本人电脑主机配置示意图:
    这里写图片描述
    图1
    Intel显卡,支持OpenCL。

    硬件准备:
    AMD(A卡)、NVIDIA(N卡)、Intel(I卡)等商家提供的支持OpenCL的显卡。
    软件准备:
    相应商家显卡的最新驱动
    SDK软件
    A卡:AMPAPP SDK@默认:C:\Program Files(x86)\AMD APP
    I卡:OpenCL-drivers(非必需),opencl-sdk@默认:C:\Program Files(x86)\Intel\OpenCL SDK\6.3(版本号)
    N卡:CUDA toolkit(非必需),GPU Computing SDK@默认:C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\5.8(版本号)
    配置流程:
    Windows操作系统,VS2017+N卡(本人笔记本电脑配置)
    1>默认地址安装SDK软件
    2>VS2013下新建C++项目(Shift+Ctrl+N->空白项目C++)
    3>右击工程目录下源程序文件夹,新建源文件(Shift+Ctrl+A)
    4>右击项目名->属性(或者:工具->选项)->C/C++->常规->附加包含目录->编辑->复制或搜索添加C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\5.8 (版本号)\include
    5>属性->链接器->常规->附加库目录->编辑->复制或搜索添加C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\5.8(版本号)\lib\win32(本人笔记本为32位,64位作相应调整)
    6>链接器->输入->附加依赖项->编辑->输入添加OpenCL.lib
    注:每次新建项目都要进行此项配置
    绝大多数情况下2>-6>步不分先后顺序,但第4>步有时要在新建源文件后才可见。

    Windows操作系统,VS2013+I卡(本人台式机配置流程)
    1>默认地址安装软件
    2>VS2013下新建C++项目(Shift+Ctrl+N->空白项目C++)
    3>右击工程目录下源程序文件夹,新建源文件(Shift+Ctrl+A)
    4>右击项目名->属性(或者:工具->选项)->C/C++->附加包含目录->编辑->复制或搜索添加C:\Program Files(x86)\Intel\OpenCL SDK\6.3(版本号)\include
    5>属性->链接器->常规->附加库目录->编辑->复制或搜索添加C:\Program Files (x86)\Intel\OpenCL SDK\6.3(版本号)\lib\x86 (本人台式机是64位机,但安装VS时默认32位,所以64位机在先择相应的lib文件夹时因先查看选项窗口上平台信息,本人台式机平台:活动(Win32),选择x86,活动的是64位,选择x64,详见图2,如果不对应VS平台信息,配置失败)
    6>链接器->输入->附加依赖项->编辑->输入添加OpenCL.lib
    注:除OpenCL软件安装目录不同,其他配置过程与N卡相同。
    A卡采用类似流程,从略。

    这里写图片描述
    图2

    在源文件中编写以下程序,调看计算机的OpenCL设备信息。此段代码来自《OpenCL异构并行编程实战》随书代码,详见http://book.2cto.com/201510/57214.html

    # include <stdio.h>
    # include <stdlib.h>
    # include <malloc.h>
    
    # ifdef APPLE
    # include <OpenCL/cl.h>
    # else
    # include <CL/cl.h>
    # endif
    
    void displayPlatformInfo(cl_platform_id id,
        cl_platform_info param_name,
        const char* paramNameAsStr) {
        cl_int error = 0;
        size_t paramSize = 0;
        error = clGetPlatformInfo(id, param_name, 0, NULL, &paramSize);
        char* moreInfo = (char*)malloc(sizeof(char) * paramSize);
        error = clGetPlatformInfo(id, param_name, paramSize, moreInfo, NULL);
        if (error != CL_SUCCESS) {
            perror("Unable to find any OpenCL platform information");
            return;
        }
        printf("%s: %s\n", paramNameAsStr, moreInfo);
    }
    
    int main() {
    
        /* OpenCL 1.1 data structures */
        cl_platform_id* platforms;
    
        /* OpenCL 1.1 scalar data types */
        cl_uint numOfPlatforms;
        cl_int  error;
    
        /*
        Get the number of platforms
        Remember that for each vendor's SDK installed on the computer,
        the number of available platform also increased.
        */
        error = clGetPlatformIDs(0, NULL, &numOfPlatforms);
        if (error != CL_SUCCESS) {
            perror("Unable to find any OpenCL platforms");
            exit(1);
        }
    
        // Allocate memory for the number of installed platforms.
        // alloca(...) occupies some stack space but is automatically freed on return
        platforms = (cl_platform_id*)alloca(sizeof(cl_platform_id) * numOfPlatforms);
        printf("Number of OpenCL platforms found: %d\n", numOfPlatforms);
    
        error = clGetPlatformIDs(numOfPlatforms, platforms, NULL);
        if (error != CL_SUCCESS) {
            perror("Unable to find any OpenCL platforms");
            exit(1);
        }
        // We invoke the API 'clPlatformInfo' twice for each parameter we're trying to extract
        // and we use the return value to create temporary data structures (on the stack) to store
        // the returned information on the second invocation.
        for (cl_uint i = 0; i < numOfPlatforms; ++i) {
            displayPlatformInfo(platforms[i], CL_PLATFORM_PROFILE, "CL_PLATFORM_PROFILE");
            displayPlatformInfo(platforms[i], CL_PLATFORM_VERSION, "CL_PLATFORM_VERSION");
            displayPlatformInfo(platforms[i], CL_PLATFORM_NAME, "CL_PLATFORM_NAME");
            displayPlatformInfo(platforms[i], CL_PLATFORM_VENDOR, "CL_PLATFORM_VENDOR");
            displayPlatformInfo(platforms[i], CL_PLATFORM_EXTENSIONS, "CL_PLATFORM_EXTENSIONS");
        }
        return 0;
    }

    本人台式机结果输出如下:

    Number of OpenCL platforms found: //有两个平台
    CL_PLATFORM_PROFILE: FULL_PROFILE//平台简介
    CL_PLATFORM_VERSION: OpenCL 2.0//平台版本:OpenCL 2.0
    CL_PLATFORM_NAME: Intel(R) OpenCL//平台名称
    CL_PLATFORM_VENDOR: Intel(R) Corporation//商家
    CL_PLATFORM_EXTENSIONS: cl_intel_dx9_media_sharing cl_khr_3d_image_writes cl_khr_byte_addressable_store cl_khr_d3d11_sharing cl_khr_depth_images cl_khr_dx9_media_sharing cl_khr_gl_sharing cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_icd cl_khr_image2d_from_buffer cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_spir//拓展项
    CL_PLATFORM_PROFILE: FULL_PROFILE//第二个平台简介
    CL_PLATFORM_VERSION: OpenCL 2.1//平台版本:OpenCL 2.1
    CL_PLATFORM_NAME: Experimental OpenCL 2.1 CPU Only Platform
    CL_PLATFORM_VENDOR: Intel(R) Corporation
    CL_PLATFORM_EXTENSIONS: cl_khr_icd cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_byte_addressable_store cl_khr_depth_images cl_khr_3d_image_writes cl_intel_exec_by_local_thread cl_khr_spir cl_khr_dx9_media_sharing cl_intel_dx9_media_sharing cl_khr_d3d11_sharing cl_khr_gl_sharing cl_khr_fp64 cl_khr_image2d_from_buffer

    注:运行时,计算机先加载OpenCL必要的.dll,而后才进入程序。需加载的.dll较多,加载的过程较长。

    展开全文
  • OpenCL环境配置及测试程序

    千次阅读 2018-04-05 22:37:28
    OpenCL环境配置及测试程序 ==============================================================目录结构1、OpenCL环境配置2、测试程序3、参考 ==============================================================...

    OpenCL环境配置及测试程序

     ==============================================================

    目录结构

    1、OpenCL环境配置

    2、测试程序

    3、参考

     ==============================================================

    关键词:OpenCL 环境配置 测试程序

    OpenCL(Open Computing Language)是面向异构系统的并行编程语言,最初由苹果开放,得到了许多厂商的支持并不断完善,如Intel,AMD,NVIDIA等,许多博客中似乎都使用AMD的SDK,本文使用Intel的开放SDK。

    1、OpenCL环境配置

    下载Intel OpenCL的SDK文件并安装,记住安装目录:

    https://software.intel.com/ru-ru/intel-opencl

    安装Visual Studio,我安装的是Visual Studio Professional 2017。

    以下是测试案例,打开VS,新建项目,新建一个空的Win控制台应用程序工程项目,命名为test。

    以下配置OpenCL的库文件和头文件路径

    项目→ test属性→C/C++→常规→附加包含路径

    D:\Program Files (x86)\Intel\OpenCL SDK\6.3\include

    项目→test属性→链接器→常规→附加库目录

    D:\Program Files (x86)\Intel\OpenCL SDK\6.3\lib\x86

    项目→test属性→链接器→输入→附加依赖项

    OpenCL.lib;

     

    配置完成后,将test.cpp中的文件内容替换为附件test.cpp的内容,在资源管理器中加入核文件Helloworld_kernel.cl

     按F5编译运行后,出现控制台显示如下信息表示已经成功配置环境。


    2、测试程序

    test.cpp

    #include "stdafx.h"
    #include <tchar.h>
    #include <CL/cl.h>
    #include <iostream>
    #include <fstream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string>
    
    using namespace std;
    
    cl_int ConvertToString(const char *pFileName, std::string &str);
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	cl_int			iStatus = 0;				// 函数返回状态
    	cl_uint			uiNumPlatforms = 0;				// 平台个数
    	cl_platform_id	Platform = NULL;				// 选择的平台
    	size_t			uiSize = 0;				// 平台版本名字字节数	
    	cl_int			iErr = 0;				// 返回参数
    	char			*pName = NULL;				// 平台版本名
    	cl_uint			uiNumDevices = 0;				// 设备数量
    	cl_device_id	*pDevices = NULL;				// 设备
    	cl_context		Context = NULL;				// 设备环境
    	cl_command_queue	CommandQueue = NULL;			// 命令队列
    	const char		*pFileName = "HelloWorld_Kernel.cl";	// cl文件名
    	string			strSource = "";				// 用于存储cl文件中的代码
    	const char		*pSource;							// 代码字符串指针
    	size_t			uiArrSourceSize[] = { 0 };			// 代码字符串长度
    	cl_program		Program = NULL;				// 程序对象
    	const char		*pInput = "gdkknvnqkc";		// 输入字符串
    	size_t			uiStrlength = strlen(pInput);	// 输入字符串长度
    	char			*pOutput = NULL;				// 输出字符串
    	cl_mem			memInutBuffer = NULL;				// 输入内存对象
    	cl_mem			memOutputBuffer = NULL;				// 输出内存对象
    	cl_kernel		Kernel = NULL;				// 内核对象
    	size_t			uiGlobal_Work_Size[1] = { 0 };		// 用于设定内核分布	
    
            //-------------------1. 获得并选择可用平台-----------------------------
            // 查询可用的平台个数,并返回状态
    	iStatus = clGetPlatformIDs(0, NULL, &uiNumPlatforms);
    	if (CL_SUCCESS != iStatus)
    	{
    		cout << "Error: Getting platforms error" << endl;
    		return 0;
    	}
    	// 获得平台地址
    	if (uiNumPlatforms > 0)  // 如果有可用平台
    	{
    		// 根据平台数为平台分配内存空间
    		cl_platform_id *pPlatforms = (cl_platform_id *)malloc(uiNumPlatforms * sizeof(cl_platform_id));
    
    		// 获得可用的平台
    		iStatus = clGetPlatformIDs(uiNumPlatforms, pPlatforms, NULL);
    		Platform = pPlatforms[0];	// 获得第一个平台的地址
    		free(pPlatforms);			// 释放平台占用的内存空间
    	}
    	// 获得平台版本名
    	// 获得平台版本名的字节数
    	iErr = clGetPlatformInfo(Platform, CL_PLATFORM_VERSION, 0, NULL, &uiSize);
    
    	// 根据字节数为平台版本名分配内存空间
    	pName = (char *)alloca(uiSize * sizeof(char));
    
    	// 获得平台版本名字
    	iErr = clGetPlatformInfo(Platform, CL_PLATFORM_VERSION, uiSize, pName, NULL);
    	cout << pName << endl;
    
    	//--------------2. 查询GPU设备,并选择可用设备------------------------
    	// 获得GPU设备数量
    	iStatus = clGetDeviceIDs(Platform, CL_DEVICE_TYPE_GPU, 0, NULL, &uiNumDevices);
    	if (0 == uiNumDevices)	// 如果没有GPU设备
    	{
    		cout << "No GPU device available." << endl;
    		cout << "Choose CPU as default device." << endl;
    
    		// 选择CPU作为设备,获得设备数
    		iStatus = clGetDeviceIDs(Platform, CL_DEVICE_TYPE_CPU, 0, NULL, &uiNumDevices);
    
    		// 为设备分配空间
    		pDevices = (cl_device_id *)malloc(uiNumDevices * sizeof(cl_device_id));
    
    		// 获得平台
    		iStatus = clGetDeviceIDs(Platform, CL_DEVICE_TYPE_CPU, uiNumDevices, pDevices, NULL);
    	}
    	else
    	{
    		pDevices = (cl_device_id *)malloc(uiNumDevices * sizeof(cl_device_id));
    
    		iStatus = clGetDeviceIDs(Platform, CL_DEVICE_TYPE_GPU, uiNumDevices, pDevices, NULL);
    	}
    
    	// -------------------3.创建设备环境---------------------------------
    	// 创建设备环境
    	Context = clCreateContext(NULL, 1, pDevices, NULL, NULL, NULL);
    	if (NULL == Context)
    	{
    		cout << "Error: Can not create context" << endl;
    		return 0;
    	}
    
    	// -------------------4.创建命令队列--------------------------------------
    	// 创建第1个设备的命令队列
    	CommandQueue = clCreateCommandQueue(Context, pDevices[0], 0, NULL);
    	if (NULL == CommandQueue)
    	{
    		cout << "Error: Can not create CommandQueue" << endl;
    		return 0;
    	}
    
    
    	// ----------------------5. 创建程序对象------------------------------
    	// 将cl文件中的代码转为字符串
    	iStatus = ConvertToString(pFileName, strSource);
    
    	pSource = strSource.c_str();			// 获得strSource指针
    	uiArrSourceSize[0] = strlen(pSource);	// 字符串大小
    
    											// 创建程序对象
    	Program = clCreateProgramWithSource(Context, 1, &pSource, uiArrSourceSize, NULL);
    	if (NULL == Program)
    	{
    		cout << "Error: Can not create program" << endl;
    		return 0;
    	}
    
    
    	// -----------------------------6. 编译程序--------------------------------
    	// 编译程序
    	iStatus = clBuildProgram(Program, 1, pDevices, NULL, NULL, NULL);
    	if (CL_SUCCESS != iStatus)	// 编译错误
    	{
    		cout << "Error: Can not build program" << endl;
    		char szBuildLog[16384];
    		clGetProgramBuildInfo(Program, *pDevices, CL_PROGRAM_BUILD_LOG, sizeof(szBuildLog), szBuildLog, NULL);
    
    		cout << "Error in Kernel: " << endl << szBuildLog;
    		clReleaseProgram(Program);
    
    		return 0;
    	}
    
    	//-------------------------7. 并创建输入输出内核内存对象--------------------------------
    
    	// 创建输入内存对象
    	memInutBuffer = clCreateBuffer(
    		Context,
    		CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,  // 输入内存为只读,并可以从宿主机内存复制到设备内存
    		(uiStrlength + 1) * sizeof(char),		  // 输入内存空间大小
    		(void *)pInput,
    		NULL);
    
    	// 创建输出内存对象
    	memOutputBuffer = clCreateBuffer(
    		Context,
    		CL_MEM_WRITE_ONLY,					// 输出内存只能写
    		(uiStrlength + 1) * sizeof(char),	// 输出内存空间大小
    		NULL,
    		NULL);
    
    	if ((NULL == memInutBuffer) || (NULL == memOutputBuffer))
    	{
    		cout << "Error creating memory objects" << endl;
    		return 0;
    	}
    
    	//--------------------------8. 创建内核对象-------------------------------------
    	Kernel = clCreateKernel(Program,
    		"helloworld",  // cl文件中的入口函数
    		NULL);
    	if (NULL == Kernel)
    	{
    		cout << "Error: Can not create kernel" << endl;
    		return 0;
    	}
    
    
    
    	//----------------------------9. 设置内核参数----------------------------------
    	iStatus = clSetKernelArg(Kernel,
    		0,		// 参数索引
    		sizeof(cl_mem),
    		(void *)&memInutBuffer);
    
    	iStatus |= clSetKernelArg(Kernel, 1, sizeof(cl_mem), (void *)&memOutputBuffer);
    
    	if (CL_SUCCESS != iStatus)
    	{
    		cout << "Error setting kernel arguments" << endl;
    	}
    
    
    
    	// --------------------------10.运行内核---------------------------------
    	uiGlobal_Work_Size[0] = uiStrlength;  // 输入字符串大小
    
    										  // 利用命令队列使将再设备上执行的内核排队
    	iStatus = clEnqueueNDRangeKernel(
    		CommandQueue,
    		Kernel,
    		1,
    		NULL,
    		uiGlobal_Work_Size,  // 确定内核在设备上的多个处理单元间的分布
    		NULL,				 // 确定内核在设备上的多个处理单元间的分布
    		0,
    		NULL,
    		NULL);
    
    
    	if (CL_SUCCESS != iStatus)
    	{
    		cout << "Error: Can not run kernel" << endl;
    		return 0;
    	}
    
    	// ----------------------------11. 将输出读取到主机内存
    	pOutput = (char *)malloc(uiStrlength + 1);  // uiStrlength 为 输入字符串长度
    
    	iStatus = clEnqueueReadBuffer(
    		CommandQueue,		// 命令队列
    		memOutputBuffer,	// 输出内存对象
    		CL_TRUE,			// 内核读取结束之前该函数不会返回
    		0,
    		uiStrlength * sizeof(char),
    		pOutput,
    		0,
    		NULL,
    		NULL);
    
    	if (CL_SUCCESS != iStatus)
    	{
    		cout << "Error: Can not reading result buffer" << endl;
    		return 0;
    	}
    
    
    	// ---------------------12--输出计算结果---------------
    	pOutput[uiStrlength] = '\0';
    	cout << "Input String:" << endl;
    	cout << pInput << endl;
    	cout << "Output String:" << endl;
    	cout << pOutput << endl;
    
    
    	// -------------------------------13. 释放资源--------------------------------
    	iStatus = clReleaseKernel(Kernel);
    	iStatus = clReleaseProgram(Program);
    	iStatus = clReleaseMemObject(memInutBuffer);
    	iStatus = clReleaseMemObject(memOutputBuffer);
    	iStatus = clReleaseCommandQueue(CommandQueue);
    	iStatus = clReleaseContext(Context);
    
    	if (NULL != pOutput)
    	{
    		free(pOutput);
    		pOutput = NULL;
    	}
    
    	if (NULL != pDevices)
    	{
    		free(pDevices);
    		pDevices = NULL;
    	}
    
    	system("pause");//避免执行完闪退
    	return 0;
    }
    
    // 将cl文件代码转为字符串
    cl_int ConvertToString(const char *pFileName, std::string &Str)
    {
    	size_t		uiSize = 0;
    	size_t		uiFileSize = 0;
    	char		*pStr = NULL;
    	std::fstream fFile(pFileName, (std::fstream::in | std::fstream::binary));
    
    
    	if (fFile.is_open())
    	{
    		fFile.seekg(0, std::fstream::end);
    		uiSize = uiFileSize = (size_t)fFile.tellg();  // 获得文件大小
    		fFile.seekg(0, std::fstream::beg);
    		pStr = new char[uiSize + 1];
    
    		if (NULL == pStr)
    		{
    			fFile.close();
    			return 0;
    		}
    
    		fFile.read(pStr, uiFileSize);				// 读取uiFileSize字节
    		fFile.close();
    		pStr[uiSize] = '\0';
    		Str = pStr;
    
    		delete[] pStr;
    
    		return 0;
    	}
    
    	cout << "Error: Failed to open cl file\n:" << pFileName << endl;
    
    	return -1;
    }
    

    HelloWorld_Kernel.cl

    __kernel void helloworld(__global char*pIn, __global char *pOut) 
    
    { 
    
       int iNum = get_global_id(0); 
    
       pOut[iNum] = pIn[iNum] + 1; 
    
    } 

    3、参考

    OpenCL “速成”冲刺【第一天】:

    https://blog.csdn.net/zhoubo616819598/article/details/10977915


    展开全文
  • 配置VS2013 OpenCL环境

    2018-10-25 19:48:44
    配置VS2013 OpenCL环境 &nbsp; &nbsp; 配置VS2013 OpenCL环境 &nbsp; 1. 安装CUDA安装包 &nbsp; 由于目前的CUDA安装包自带显卡驱动、CUAD工具、OpenCL的SDK;其中OpenCL的相关内容...

    配置VS2013 OpenCL环境

     

     

    配置VS2013 OpenCL环境

     

    1. 安装CUDA安装包

     

    由于目前的CUDA安装包自带显卡驱动、CUAD工具、OpenCL的SDK;其中OpenCL的相关内容的默认目录有:

    • CL文件夹的目录:C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v7.0\include
    • OpenCL.lib文件目录:C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v7.0\lib
    • OpenCL.dll文件目录:C:\Program Files\NVIDIA Corporation\OpenCL

    2. 新建空项目

     

    可以通过VS2013的VC++模板新建一个空项目;

    图 1

    3. 添加文件

    为了验证配置的正确性,所以为项目添加两个文件:cl_kernel.cl和main.cpp。

    1) 添加cl_kernel.cl文件

        其中在项目所在的目录下新建一个cl_kernel.cl文件,其内容为附录1所示,目录结构如图 1所示。同时在VS2013的项目中将cl_kernel.cl文件添加到项目的"源文件"筛选器中,如图 2所示。

     

    图 2

    图 3

    2) 添加main.cpp文件

    类似cl_kernel.cl文件操作,同样将main.cpp文件添加到项目中。

    4. 配置CL目录

    需要将OpenCL的SDK的头文件包含到项目中,具体操作方法为:

    在项目->属性->配置属性->C/C++->常规->附加包含目录->配置,然后添加CL文件夹的目录:C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v7.0\include。如图 3所示。

    图 4

    5. 配置预处理器

    项目->属性->配置属性->c/c++->预处理器定义->编辑,然后添加"_CRT_SECURE_NO_WARNINGS",否则会报错。

    图 5

    6. 配置外部依赖OpenCL.lib目录

    具体操作:项目->属性->配置属性->链接器->常规->附加库目录。然后将OpenCL.lib文件所在的目录添加进去,其中需要注意的是将程序Debug成32位和64位平台添加的Opencl.lib目录是不同的,如图 4所示,是Debug成Win32平台,所以只加"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v7.0\lib\Win32"路径;若是Debug成X64,则添加的路径为"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v7.0\lib\x64"。同时需要在"启用增量链接"选项中选否。

    图 6

    图 7

    7. 配置OpenCL.lib文件

    项目->属性->配置属性->连接器->输入->附件依赖库->编辑,接着添加OpenCL.lib

    图 8

    8. 运行结果图

    图 9

     

    附录1 cl_kernel.cl文件

     

    复制代码
    1 __kernel  void MyCLAdd(__global  int *dst, __global  int *src1, __global  int *src2) 

    3 { 

    5  int index = get_global_id( 0); 

    7 dst[index] = src1[index] + src2[index]; 

    9 } 
    复制代码

     

    附录2:main.cpp文件

     

    复制代码
      1 #include <CL/cl.h> 
      2 
      3 #include <stdio.h> 
      4 
      5 #include <iostream> 
      6 
      7  using  namespace std; 
      8 
      9  
     10 
     11  int main( void){ 
     12 
     13     cl_uint numPlatforms =  0;  // the NO. of platforms 
     14 
     15     cl_platform_id platform = nullptr;  // the chosen platform 
     16 
     17     cl_context context = nullptr;  //  OpenCL context 
     18 
     19     cl_command_queue commandQueue = nullptr; 
     20 
     21     cl_program program = nullptr;  //  OpenCL kernel program object that'll be running on the compute device 
     22 
     23     cl_mem input1MemObj = nullptr;  //  input1 memory object for input argument 1 
     24 
     25     cl_mem input2MemObj = nullptr;  //  input2 memory object for input argument 2 
     26 
     27     cl_mem outputMemObj = nullptr;  //  output memory object for output 
     28 
     29     cl_kernel kernel = nullptr;  //  kernel object 
     30 
     31  
     32 
     33     cl_int status = clGetPlatformIDs( 0, NULL, &numPlatforms); 
     34 
     35      if (status != CL_SUCCESS) 
     36 
     37     { 
     38 
     39         cout <<  " Error: Getting platforms! " << endl; 
     40 
     41          return  0; 
     42 
     43     } 
     44 
     45  
     46 
     47      /* For clarity, choose the first available platform.  */ 
     48 
     49      if (numPlatforms >  0) 
     50 
     51     { 
     52 
     53         cl_platform_id* platforms = (cl_platform_id*) malloc(numPlatforms*  sizeof(cl_platform_id)); 
     54 
     55         status = clGetPlatformIDs(numPlatforms, platforms, NULL); 
     56 
     57         platform = platforms[ 0]; 
     58 
     59          free(platforms); 
     60 
     61     } 
     62 
     63      else 
     64 
     65     { 
     66 
     67         puts( " Your system does not have any OpenCL platform! "); 
     68 
     69          return  0; 
     70 
     71     } 
     72 
     73  
     74 
     75      /* Step 2:Query the platform and choose the first GPU device if has one.Otherwise use the CPU as device. */ 
     76 
     77     cl_uint numDevices =  0; 
     78 
     79     cl_device_id *devices; 
     80 
     81     status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU,  0, NULL, &numDevices); 
     82 
     83      if (numDevices ==  0)  // no GPU available. 
     84 
     85     { 
     86 
     87         cout <<  " No GPU device available. " << endl; 
     88 
     89         cout <<  " Choose CPU as default device. " << endl; 
     90 
     91         status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU,  0, NULL, &numDevices); 
     92 
     93         devices = (cl_device_id*) malloc(numDevices *  sizeof(cl_device_id)); 
     94 
     95  
     96 
     97         status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, numDevices, devices, NULL); 
     98 
     99     } 
    100 
    101      else 
    102 
    103     { 
    104 
    105         devices = (cl_device_id*) malloc(numDevices *  sizeof(cl_device_id)); 
    106 
    107         status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numDevices, devices, NULL); 
    108 
    109         cout <<  " The number of devices:  " << numDevices << endl; 
    110 
    111     } 
    112 
    113  
    114 
    115      /* Step 3: Create context. */ 
    116 
    117     context = clCreateContext(NULL,  1, devices, NULL, NULL, NULL); 
    118 
    119  
    120 
    121      /* Step 4: Creating command queue associate with the context. */ 
    122 
    123     commandQueue = clCreateCommandQueue(context, devices[ 0],  0, NULL); 
    124 
    125  
    126 
    127      /* Step 5: Create program object  */ 
    128 
    129      //  Read the kernel code to the buffer 
    130 
    131     FILE *fp = fopen( " cl_kernel.cl ",  " rb "); 
    132 
    133  
    134 
    135      // 错误    1    error C4996 : 'fopen' : This function or variable may be unsafe.Consider using fopen_s instead.To disable deprecation, use _CRT_SECURE_NO_WARNINGS.See online help for details.c : \users\zyj\documents\visual studio 2013\projects\project3\project3\main.cpp    67    1    Project3 
    136 
    137  
    138 
    139  
    140 
    141      if (fp == nullptr) 
    142 
    143     { 
    144 
    145         puts( " The kernel file not found! "); 
    146 
    147          goto RELEASE_RESOURCES; 
    148 
    149     } 
    150 
    151     fseek(fp,  0, SEEK_END); 
    152 
    153     size_t kernelLength = ftell(fp); 
    154 
    155     fseek(fp,  0, SEEK_SET); 
    156 
    157      char *kernelCodeBuffer = ( char*) malloc(kernelLength +  1); 
    158 
    159     fread(kernelCodeBuffer,  1, kernelLength, fp); 
    160 
    161     kernelCodeBuffer[kernelLength] =  ' \0 '; 
    162 
    163     fclose(fp); 
    164 
    165  
    166 
    167      const  char *aSource = kernelCodeBuffer; 
    168 
    169     program = clCreateProgramWithSource(context,  1, &aSource, &kernelLength, NULL); 
    170 
    171  
    172 
    173      /* Step 6: Build program.  */ 
    174 
    175     status = clBuildProgram(program,  1, devices, NULL, NULL, NULL); 
    176 
    177  
    178 
    179      /* Step 7: Initial inputs and output for the host and create memory objects for the kernel */ 
    180 
    181      int __declspec(align( 32)) input1Buffer[ 128];  //  32 bytes alignment to improve data copy 
    182 
    183      int __declspec(align( 32)) input2Buffer[ 128]; 
    184 
    185      int __declspec(align( 32)) outputBuffer[ 128]; 
    186 
    187  
    188 
    189      //  Do initialization 
    190 
    191      int i; 
    192 
    193      for (i =  0; i <  128; i++) 
    194 
    195         input1Buffer[i] = input2Buffer[i] = i +  1; 
    196 
    197     memset(outputBuffer,  0,  sizeof(outputBuffer)); 
    198 
    199  
    200 
    201      //  Create mmory object 
    202 
    203     input1MemObj = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,  128 *  sizeof( int), input1Buffer, nullptr); 
    204 
    205     input2MemObj = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,  128 *  sizeof( int), input2Buffer, nullptr); 
    206 
    207     outputMemObj = clCreateBuffer(context, CL_MEM_WRITE_ONLY,  128 *  sizeof( int), NULL, NULL); 
    208 
    209  
    210 
    211      /* Step 8: Create kernel object  */ 
    212 
    213     kernel = clCreateKernel(program,  " MyCLAdd ", NULL); 
    214 
    215  
    216 
    217      /* Step 9: Sets Kernel arguments. */ 
    218 
    219     status = clSetKernelArg(kernel,  0,  sizeof(cl_mem), ( void *)&outputMemObj); 
    220 
    221     status = clSetKernelArg(kernel,  1,  sizeof(cl_mem), ( void *)&input1MemObj); 
    222 
    223     status = clSetKernelArg(kernel,  2,  sizeof(cl_mem), ( void *)&input2MemObj); 
    224 
    225  
    226 
    227      /* Step 10: Running the kernel. */ 
    228 
    229     size_t global_work_size[ 1] = {  128 }; 
    230 
    231     status = clEnqueueNDRangeKernel(commandQueue, kernel,  1, NULL, global_work_size, NULL,  0, NULL, NULL); 
    232 
    233     clFinish(commandQueue);  //  Force wait until the OpenCL kernel is completed 
    234 
    235  
    236 
    237      /* Step 11: Read the cout put back to host memory. */ 
    238 
    239     status = clEnqueueReadBuffer(commandQueue, outputMemObj, CL_TRUE,  0, global_work_size[ 0] *  sizeof( int), outputBuffer,  0, NULL, NULL); 
    240 
    241  
    242 
    243     printf( " Veryfy the rsults...  "); 
    244 
    245      for (i =  0; i <  128; i++) 
    246 
    247     { 
    248 
    249          if (outputBuffer[i] != (i +  1) *  2) 
    250 
    251         { 
    252 
    253             puts( " Results not correct! "); 
    254 
    255              break; 
    256 
    257         } 
    258 
    259     } 
    260 
    261      if (i ==  128) 
    262 
    263         puts( " Correct! "); 
    264 
    265 RELEASE_RESOURCES: 
    266 
    267      /* Step 12: Clean the resources. */ 
    268 
    269     status = clReleaseKernel(kernel); // *Release kernel. 
    270 
    271     status = clReleaseProgram(program);  // Release the program object. 
    272 
    273     status = clReleaseMemObject(input1MemObj); // Release mem object. 
    274 
    275     status = clReleaseMemObject(input2MemObj); 
    276 
    277     status = clReleaseMemObject(outputMemObj); 
    278 
    279     status = clReleaseCommandQueue(commandQueue); // Release Command queue. 
    280 
    281     status = clReleaseContext(context); // Release context. 
    282 
    283  
    284 
    285      free(devices); 
    286 
    287 } 
    展开全文
  • debian opencl环境搭建

    2017-06-22 15:52:38
    Opencl环境搭建 time:2016-6-21 write:luoad 一、安装hd 7870显卡驱动 1.查看显卡驱动是否安装 lshw -c video; 在configuration一栏 如果没有driver相关内容说明没有安装驱动。 2.安装步骤: (注:以下...

    Opencl环境搭建
    time:2016-6-21
    write:luoad
    一、安装hd 7870显卡驱动
    1.查看显卡驱动是否安装 lshw -c video;
    这里写图片描述
    在configuration一栏 如果没有driver相关内容说明没有安装驱动。
    2.安装步骤: (注:以下步骤全在网上那个找到得)
    1、安装解压及依赖
    sudo aptitude install build-essential cdbs fakeroot dh-make debhelper debconf libstdc++6 dkms libqtgui4 wget execstack libelfg0 module-assistant
    2、安装32位库
    sudo aptitude install ia32-libs(这一步可能没有ia32-libs,没有就跳过该步骤)
    3、从AMD官网上下载最新的显卡驱动
    ./amd-driver-installer-15.302-x86.x86_64.run

    3.结果:
    这里写图片描述
    二、安装amd的opencl环境:
    以下总结参考:
    /opt/AMDAPPSDK-3.0/docs/AMD_APP_SDK_GettingStartedGuide.pdf下的
    AMD_APP_SDK_InstallationNotes.pdf

    直接将AMD-APP-SDKInstaller-v3.0.130.136-GA-linux64.tar.bz2解压,执行该shell脚本。(所在目录:/home/test/soft/)

    1.这里需要将/opt/AMDAPPSDK-3.0/lib/x86_64/sdk/libOpenCL.so.1
    复制到/usr/lib/
    2.这里需要将/opt/AMDAPPSDK-3.0/lib/x86_64/sdk/libOpenCL.so.1改名为libOpenCL.so 放到/usr/lib/
    编译如下:
    g++ hello_world.cpp -I AMDAPPSDKROOT/includeL AMDAPPSDKROOT/lib/x86_64 -lOpenCL -o hello
    这里写图片描述

    结果输出:
    得到hello执行文件。
    这里写图片描述

    至此,关于amd显卡驱动安装和AMDSDK环境搭建完毕!

    展开全文
  • 在Linux下搭建OpenCL环境一、AMD APP SDK介绍二、安装AMD APP SDK三、AMD APP SDK使用 一、AMD APP SDK介绍 AMD APP SDK是AMD提供的SDK包,其中包含对OpenCL标准接口的实现。下载地址: ...二、安装AMD APP SDK ...
  • 在Windows下搭建OpenCL环境一、AMD APP SDK介绍二、安装AMD APP SDK三、AMD APP SDK使用 一、AMD APP SDK介绍 AMD APP SDK是AMD提供的SDK包,其中包含对OpenCL标准接口的实现。下载地址: ...二、安装AMD APP SDK ...
  • 基于cuda配置opencl环境

    2021-03-15 16:53:31
    基于cuda配置opencl环境 1、根据自己的PC的NVIDA版本选择安装对应版本的CUDA。 2、在VS2013中新建一个空的项目。 3、进入项目属性中配置属性,具体如下: (1) C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA...
  • 简单的OCL 准备openCL环境是一件令人烦恼的事情,因此我包装了OpenCL的初始化部分并设置了内核参数,并在example文件夹中提供了示例代码。 笔记 如果找不到opencl路径,请手动设置。
  • centos7安装opencl环境

    千次阅读 2017-06-11 11:48:13
    CentOS7+AMD+OpenCL环境搭建因为原来的SOC的除了问题,导致自己重新搭建环境。重新搭建环境时,遇到了不少问题。现在将过程整理成文档,以供自己以后参考。准备工作 centos7镜像(CentOS-7.0-1406-x86_64-DVD.iso) ...
  • Windows下的基于FPGA的opencl环境配置什么是opencl开发环境的配置1.工具准备2.设计环境变量环境测试开发板环境测试参考内容 什么是opencl OpenCL(全称为Open Computing Langugae,开放运算语言),是开发跨平台并行...
  • 刚刚接触Linux,很多地方不会,把自己搭建Intel FPGA OpenCL环境的步骤汇总如下: 1.安装AOCL 这一点先不详细说,有时间更新: 首先下载,网址为...
  • AMD的显卡驱动虽然是开源了,但是对于OPENCL的编译那一套环境一直是自己在搞,貌似没有交给社区,所以要在UOS上配置基于AMD显卡的OPENCL环境,就不能简单的通过apt-get这样的命令直接安装搞定了,需要安装amdgpu-pro这...
  • ubuntu16.04 配置ffmpeg,cuda,opencl环境

    千次阅读 2016-08-14 21:37:21
    本文介绍了如何在新装的ubuntu16.04系统上配置ffmpeg环境,cuda环境和opencl环境
  • 本文在Windows 10 64位系统上搭建OpenCL开发环境,笔记本显卡的类型(使用英特尔® 驱动程序和支持助理查询): NVIDIA GeForce 820M Intel® HD Graphics Family Adapter Compatibility NVIDIA...
  • <p><img alt="" height="107" src="https://img-ask.csdnimg.cn/upload/1623028749108.png" width="700" /></p> 显卡类型如上图,然后我去官网找对应linux版本... 我该如何去搭建对应的opencl环境?</p>
  • 新电脑Linux-64bit安装OpenCL环境Nvidia

    千次阅读 2017-08-22 11:08:08
    公司换了新电脑,又安装一次OpenCL环境: 1,命令:lspci |grep VGA查看显卡型号   结果显示是NVIDIA显卡:GeForce GTX 750 Ti 然后再https://developer.nvidia.com/cuda-gpus 查到我要下5.0的显卡驱动才行 所以去...
  • Intel核显--OpenCL环境--Linux

    万次阅读 热门讨论 2018-01-23 14:44:46
    Machine :Intel Xeon i7 6700(core) + Intel HD Graphics 530(skyLake) +Linux (CentOS 7.2或7.3,我的7.3)+eclipse(Neon)安装OpenCL环境,希望安装成功后将Intel i7 6700作为host,HD Graphics 530作为device。...
  • VS2008+OpenCL环境配置

    2012-02-27 15:27:00
    VS2008+OpenCL环境配置 1. 配置.cl文件支持: 1.1. 打开VS2008, 工具->选项->文本编辑器->文件扩展名,添加一个新的扩展名,指定编辑器为Microsoft Visual C++ 。这样在OpenCL文件中就能...
  • 组装的电脑没带独立显卡,...本文在Windows 10 64位系统上搭建OpenCL开发环境。 一、准备文件 将显卡驱动更新到最新版本,Windows 驱动中自动包含了OpenCL驱动,Linux系统需要另外下载OpenCL驱动。 VS2012-VS2...
  • OpenCL环境配置及测试

    千次阅读 2018-05-14 15:39:54
    由于计算性能的要求,特别需要使用并行计算,这里对TBB和OpenCL都进行了一些测试。测试了TBB和OpenCL之后,我的感觉是如果真的要做高性能的异构计算,那还是选择CUDA吧,并且应该选用专用计算的GPU。首先先把自己...
  • 引用:http://bbs.csdn.net/topics/390899158(概念问题) ... intel opencl下载地址:https://software.intel.com/en-us/intel-opencl/download 硬件:intel(R) HD ...
  • AMD OpenCL环境配置

    千次阅读 2017-03-29 15:23:05
    win7下,先按照“驱动精灵”指示,把驱动装齐活了,然后再把SDK装一下就可以了
  • 1、安装Visual Studio 2019 2、安装Buildtoos for Visual ... .\vcpkg.exe install opencl .\vcpkg.exe install opencl:x64-windows 4、打开vs2019创建空项目开始愉快的Opencl学习开发吧 简洁记录,仅供参考 ...
  • 由于目前的CUDA安装包自带显卡驱动、CUAD工具、OpenCL的SDK;其中OpenCL的相关内容的默认目录有: CL文件夹的目录:C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v7.0\include OpenCL.lib文件目录...
  • 组装的电脑没带独立显卡,用...本文在Windows 10 64位系统上搭建OpenCL开发环境。 一、准备文件 将显卡驱动更新到最新版本,Windows 驱动中自动包含了OpenCL驱动,Linux系统需要另外下载OpenCL驱动。 VS2012-...
  • Windows下opencl环境配置

    千次阅读 2016-09-14 11:00:53
    转自:... 首先声明我这篇主要是根据下面网站的介绍, 加以修改和详细描述,一步一步在我自己的电脑上实现的, ... ...首先要将显卡驱动更新到最新版,以支持opencl 。要看显卡支不支持

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,422
精华内容 2,568
关键字:

opencl环境