OpenCL使用GPU滤波

最新推荐文章于 2024-08-17 06:30:00 发布
最新推荐文章于 2024-08-17 06:30:00 发布
阅读量4.2k 收藏 3
点赞数
分类专栏： DirectCompute

OpenCL使用GPU滤波

最近开始研究OpenCL，以便在需要大量计算时，用GPU来加速。

为了实用性，结合工作，编写第一个OpenCL的程序。

为了实用，我选择以前做的数字滤波来作为本次的设计目标。我们的数字滤波，主要是用FIR滤波，需要滤波的数据是多通道的电生理数据，滤波系数是使用Matlab仿真的，原始数据是通过多道生理记录仪采集的数据。以前的滤波程序是在CPU上完成的。现在把它移到GPU上完成，就当是一次实验和学习OpenCL的机会。

第一步，下载CUDA（因为我用的是NVidia的显卡，如果使用ATI的显卡，需要下载AMD APP（其前身是 ATI Stream），目前版本2.7，可到网上搜索下载）

 CUDA 下载 （版本4.2）

http://developer.nvidia.com/cuda/cuda-downloads

下载完后安装。安装就不介绍了。注意安装的路径，下面要用到。

第二步 VS2008设置

工具->选项

项目->属性

可能你的安装目录跟我的不一样，设置成你的安装目录就可以了。

其它设置可以在网上查。或者 百度文库

http://wenku.baidu.com/view/cb77e4926bec0975f465e238.html

第三步，开始编程。

为了实用和可重用，做成一个C++类。这个类必须包含3个函数，InitCL初始化， Uninit释放， Filter_GPU滤波，Filter_GPU可能会反复调用。

首先是初始化CL

//初始化OpenCL

BOOL CFilter::InitCL()

{

  

   if(m_bInitCL)

   {

      return FALSE;

   }

   cl_int iError = 0;   // 错误代码

 

   // Platform

   iError = clGetPlatformIDs(1,&m_clPlatform_id,NULL);

   if (iError != CL_SUCCESS)

   {

       TRACE("Error getting platform id \n");

      exit(iError);

   }

   // Device

   iError = clGetDeviceIDs(m_clPlatform_id, CL_DEVICE_TYPE_GPU, 1, &m_clDevice_id, NULL);

   if (iError != CL_SUCCESS)

   {

      TRACE("Error getting device ids \n");

      exit(iError);

   }

   // Context

   m_clContext = clCreateContext(0, 1, &m_clDevice_id, NULL, NULL, &iError);

   if (iError != CL_SUCCESS)

   {

      TRACE("Error creating context \n");

      exit(iError);

   }

   // Command-queue

   m_clQueue = clCreateCommandQueue(m_clContext, m_clDevice_id, 0, &iError);

   if (iError != CL_SUCCESS)

   {

      TRACE("Error creating command queue \n");

      exit(iError);

   }

   上面的代码没什么特殊的，照着写就行了

 

   CString strPath;

   GetCurrentDirectory(MAX_PATH,strPath.GetBuffer(MAX_PATH));//获得当前路径

   strPath.ReleaseBuffer();

  

   CString strNewPath = strPath+ "\\testgpu.cl";//找cl文件

  

   size_t src_size = 0;

  

   CFileFind ff;

   if(!ff.FindFile(strNewPath))

   {

      AfxMessageBox("在当前目录没有找到OpenCL的文件testgpu.cl");

      return FALSE;

   }

   ff.Close();

   //读取*.cl中的内容到内存

   CFile *pFile =NULL;

   try

   {

      pFile = new CFile(strNewPath,CFile::modeRead);

   }

   catch (CException* e)

   {

      e->Delete();

      AfxMessageBox(" 打开文件testgpu.cl 出错");

      return FALSE;

   }

  

   int iFileLen = pFile->GetLength();

   const char* source = new char[iFileLen + 1];

   ZeroMemory((void*)source,iFileLen + 1);

   pFile->Read((void *)source,iFileLen);//读取文件

   delete pFile;

   pFile = NULL;

   // Creates the program

  m_clProgram = clCreateProgramWithSource(m_clContext, 1, &source, &src_size, &iError);//加载文件内容

   ASSERT(iError == CL_SUCCESS);

 

   delete source;

   source = NULL;

   // Builds the program

   iError = clBuildProgram(m_clProgram, 1, &m_clDevice_id, NULL, NULL, NULL);//编译cl程序

   ASSERT(iError == CL_SUCCESS);

 

   // Shows the log

   char* build_log;

   size_t log_size;

   // First call to know the proper size

  clGetProgramBuildInfo(m_clProgram, m_clDevice_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);

   build_log = new char[log_size+1];//编译CL的出错记录

   // Second call to get the log

   clGetProgramBuildInfo(m_clProgram, m_clDevice_id, CL_PROGRAM_BUILD_LOG, log_size, build_log,NULL);

   build_log[log_size] = '\0';

   CString strLog(build_log);

   TRACE(strLog + "\n");//因为cl程序是在运行时编译的，在运行过程中如果出错，显示编译CL文件的错误，以便查找问题

   delete build_log;

   build_log = NULL;

 

创建两个Kernel对应两个函数

   // Extracting the kernel

   m_clKernel = clCreateKernel(m_clProgram, "Filter_GPU_Single", &iError);//单通道滤波，这个引号中的字符串要对应cl文件中的kernel函数

   ASSERT(iError == CL_SUCCESS);

   m_clKernel1 = clCreateKernel(m_clProgram, "Filter_GPU_Multi", &iError);//多通道滤波，这个引号中的字符串要对应cl文件中的kernel函数

   ASSERT(iError == CL_SUCCESS);

   m_bInitCL = TRUE;//初始化成功

   return TRUE;

}

释放就比较简单

BOOL CFilter::Uninit()

{//释放资源

   if(!m_bInitCL)

   {

      return FALSE;

   }

   clReleaseKernel(m_clKernel);

   clReleaseKernel(m_clKernel1);

 

   clReleaseCommandQueue(m_clQueue);

 

   clReleaseContext(m_clContext);

   return TRUE;

}

下面开始写滤波函数

//用OpenCL（GPU）计算单通道滤波 iDataNum 数据总个数

BOOL CFilter::Filter_GPU(float *pBufferIn,float *pBuferOut,const int iDataNum)

{

   if(!m_bInitCL || !m_bInitFilter)

   {

      return FALSE;

   }

   if(pBufferIn == NULL || pBuferOut == NULL || iDataNum <=0 )

   {

      return FALSE;

   }

   cl_int iError = 0;   // Used to handle iError codes

   const int iMem_size = sizeof(float)*m_iFilterLen;

   int iSrcLen = m_iFilterLen + iDataNum -1;

   if(m_pSrcBuffer == NULL || m_iSrcBufferLen < iSrcLen)

   {//没有申请缓冲或者缓冲太小，需要申请缓冲

      if(m_pSrcBuffer)

      {//删除重新申请

        delete m_pSrcBuffer;

        m_pSrcBuffer = NULL;

      }

      m_iSrcBufferLen = iSrcLen;

      m_pSrcBuffer = new float[m_iSrcBufferLen];

   }

   //准备数据

   memcpy(m_pSrcBuffer,m_pDataSave + 1,(m_iFilterLen - 1) * sizeof(float));//把上一次的数据尾的数据拷到源数据缓冲头

   memcpy(m_pSrcBuffer + m_iFilterLen -1,pBufferIn,iDataNum * sizeof(float));//拷贝源数据

   memcpy(m_pDataSave,pBufferIn + iDataNum - m_iFilterLen,m_iFilterLen * sizeof(float));//把本次的数据尾的数据暂存，以便下次使用

 

   //建立CL缓冲

   cl_mem pSrcBuffer_CL  = clCreateBuffer(m_clContext, CL_MEM_READ_ONLY |CL_MEM_COPY_HOST_PTR, iSrcLen * sizeof(float), m_pSrcBuffer, &iError);   //源数据

   cl_mem FilterBuffer_CL = clCreateBuffer(m_clContext, CL_MEM_READ_ONLY |CL_MEM_COPY_HOST_PTR, iMem_size, m_pFilterBuffer, &iError);           //滤波系数

   cl_mem pBufferOut_CL  = clCreateBuffer(m_clContext, CL_MEM_WRITE_ONLY, iSrcLen * sizeof(float),NULL, &iError);                      //结果

 

   const int iFilterLen = m_iFilterLen;

   //设置Kernel函数参数

   iError =  clSetKernelArg(m_clKernel, 0, sizeof(cl_mem), &pSrcBuffer_CL);

   iError |= clSetKernelArg(m_clKernel, 1, sizeof(cl_mem), &FilterBuffer_CL);

   iError |= clSetKernelArg(m_clKernel, 2, sizeof(cl_mem), &pBufferOut_CL);

   iError |= clSetKernelArg(m_clKernel, 3, sizeof(size_t), &iDataNum);

   iError |= clSetKernelArg(m_clKernel, 4, sizeof(size_t), &iFilterLen);

   // 执行kernel函数

   const size_t global_ws = iDataNum; // Total number of work-items

   iError = clEnqueueNDRangeKernel(m_clQueue, m_clKernel, 1, NULL, &global_ws, NULL, 0, NULL, NULL);

   //读取结果数据

   iError = clEnqueueReadBuffer(m_clQueue, pBufferOut_CL, CL_TRUE, 0, iDataNum * sizeof(float),pBuferOut, 0, NULL, NULL);

   //释放CL缓冲

   clReleaseMemObject(pSrcBuffer_CL);

   clReleaseMemObject(FilterBuffer_CL);

   clReleaseMemObject(pBufferOut_CL);

   return TRUE;

}

//用OpenCL（GPU）多通道滤波，iDataNum 数据总个数，iFrameLen 帧长度bFrameOrder = TRUE 按帧排列，bFrameOrder = FALSE 按通道排列

BOOL CFilter::Filter_GPU(float *pBufferIn,float *pBuferOut,const int iDataNum,const int iFrameLen,BOOLbFrameOrder)

{

   if(!m_bInitCL || !m_bInitFilter)

   {

      return FALSE;

   }

   if(pBufferIn == NULL || pBuferOut == NULL || iDataNum <=0 || iFrameLen <=0)

   {

      return FALSE;

   }

   cl_int iError = 0;   // Used to handle iError codes

   int i =0;

 

   int iSrcLen = ((m_iFilterLen - 1 ) *iFrameLen + iDataNum );

 

   if(m_pSrcBuffer == NULL || m_iSrcBufferLen < iSrcLen)

   {//没有申请缓冲或者缓冲太小，需要申请缓冲

      if(m_pSrcBuffer)

      {//删除重新申请

        delete m_pSrcBuffer;

        m_pSrcBuffer = NULL;

      }

      m_iSrcBufferLen = iSrcLen;

      m_pSrcBuffer = new float[m_iSrcBufferLen];

   }

   //准备数据

   int iFrames = iDataNum / iFrameLen;

   int iBlockLen = iFrames + m_iFilterLen - 1;

   if(bFrameOrder)

   {//按帧排列

      for(i =0;i< iFrameLen;i++)

      {//把上一次的数据尾的数据拷到源数据的每个段缓冲头

        memcpy(m_pSrcBuffer + i * iBlockLen,m_pDataSave + i * m_iFilterLen + 1,(m_iFilterLen - 1) *sizeof(float));

      }

 

      for(i =0;i< iFrames;i++)

      {

        for(int j=0;j< iFrameLen;j++)

         {

           m_pSrcBuffer[j * iBlockLen + m_iFilterLen - 1 + i] = pBufferIn[i * iFrameLen + j];

        }

      }

      for(i =0;i< iFrameLen;i++)

      {//把本次的数据尾的数据暂存，以便下次使用

        memcpy(m_pDataSave + i * m_iFilterLen ,m_pSrcBuffer + i * iBlockLen + iBlockLen - m_iFilterLen,(m_iFilterLen - 1) * sizeof(float));

      }

 

   }

   else

   {//按通道排列

      for(i =0;i< iFrameLen;i++)

      {

        memcpy(m_pSrcBuffer + i * iBlockLen,m_pDataSave + i * m_iFilterLen + 1,(m_iFilterLen - 1) *sizeof(float));//把上一次的数据尾的数据拷到源数据的每个段的缓冲头

        memcpy(m_pSrcBuffer+ i * iBlockLen + m_iFilterLen - 1,pBufferIn + i * iFrames,iFrames *sizeof(float));//拷贝原始数据

        memcpy(m_pDataSave + i * m_iFilterLen,m_pSrcBuffer + i * iBlockLen + iBlockLen - m_iFilterLen,m_iFilterLen  * sizeof(float));//把本次的数据尾的数据暂存，以便下次使用

      }

 

   }

  

   const int iFilter_size = sizeof(float) * m_iFilterBufferLen;

   //创建CL缓冲

   cl_mem pSrcBuffer_CL = clCreateBuffer(m_clContext, CL_MEM_READ_ONLY |CL_MEM_COPY_HOST_PTR, iSrcLen * sizeof(float), m_pSrcBuffer, &iError);   //源数据

   cl_mem FilterBuffer_CL = clCreateBuffer(m_clContext, CL_MEM_READ_ONLY |CL_MEM_COPY_HOST_PTR, iFilter_size, m_pFilterBuffer, &iError);        //滤波系数

   cl_mem pBufferOut_CL = clCreateBuffer(m_clContext, CL_MEM_WRITE_ONLY, iSrcLen * sizeof(float),NULL, &iError);                        //结果

 

   const int iFilter = m_iFilterLen;

   iError =  clSetKernelArg(m_clKernel1, 0, sizeof(cl_mem), &pSrcBuffer_CL);

   iError |= clSetKernelArg(m_clKernel1, 1, sizeof(cl_mem), &FilterBuffer_CL);

   iError |= clSetKernelArg(m_clKernel1, 2, sizeof(cl_mem), &pBufferOut_CL);

   iError |= clSetKernelArg(m_clKernel1, 3, sizeof(size_t), &iDataNum);

   iError |= clSetKernelArg(m_clKernel1, 4, sizeof(size_t), &iFilter);

   iError |= clSetKernelArg(m_clKernel1, 5, sizeof(size_t), &iFrameLen);

   // 执行kernel

   const size_t global_ws = iDataNum; // Total number of work-items

  iError = clEnqueueNDRangeKernel(m_clQueue, m_clKernel1, 1, NULL, &global_ws, NULL, 0, NULL, NULL);

   //读取结果

   iError = clEnqueueReadBuffer(m_clQueue, pBufferOut_CL, CL_TRUE, 0, iDataNum * sizeof(float),pBuferOut, 0, NULL, NULL);

 

   //结果是按通道存储的，因此，如果要按帧输出，需要转换

 

   //释放CL缓冲

   clReleaseMemObject(pSrcBuffer_CL);

   clReleaseMemObject(FilterBuffer_CL);

   clReleaseMemObject(pBufferOut_CL);

   return TRUE;

}

Kernel 函数 ，写在testgpu.cl文件中

__kernel void Filter_GPU_Multi(__global const float* pSrcBuffer_CL,__global const float*pFilterBuffer_CL,__global float* pBufferOut_CL,const int iNum,const int iFilterNum,const int iFrameLen)

{//多通道滤波

   const int idx = get_global_id(0);

   if (idx < iNum)

   {

      int iBlockLen = iNum / iFrameLen;

      int iFrames = idx / iBlockLen;

      float fSum =0.0f;

      for(int i = 0;i< iFilterNum;i++)

      {

         fSum += pSrcBuffer_CL[iFrames * (iFilterNum -1 + iBlockLen ) + idx % iBlockLen + i] *pFilterBuffer_CL[iFrames * iFilterNum + i];

      }

      pBufferOut_CL[idx] = fSum;

   }

}

__kernel void Filter_GPU_Single(__global const float* pSrcBuffer_CL,__global const float*pFilterBuffer_CL,__global float* pBufferOut_CL,const int iNum,const int iFilterNum)

{//单通道滤波

   const int idx = get_global_id(0);

   if (idx < iNum)

   {

      float fSum =0.0f;

      for(int i = 0;i< iFilterNum;i++)

      {

         fSum += pSrcBuffer_CL[idx + i] * pFilterBuffer_CL[i];

      }

      pBufferOut_CL[idx] = fSum;

   }

}

为了验证用GPU计算的结果是否正确，还需要写CPU计算的程序，以便验证其正确性。CPU计算此处就不贴代码了，完整代码请到http://download.csdn.net/detail/iddialog/4640938 下载。

 

以上程序在win7  CUDA SDK 4.2 和  VC++ 2008 + SP1 编译通过。能够正常运行。运行结果GPU和CPU运算结果是一致的。由于每次计算后，m_pDataSave的内容发生变化，输出缓冲前面一段数据可能会不一样。如果要测试GPU和CPU两种方式的结果是否一样，需要每次在滤波前把m_pDataSave的内容设成一样。

如果VS2008没有SP1，需要修改stdafx.h文件

删除下面这行

#include <afxcontrolbars.h> // 功能区和控件条的MFC 支持

添加

#ifdef CWinAppEx

#undef CWinAppEx

#endif

#define  CWinAppEx CWinApp

 

结尾：

由于第一次写OpenCL程序，错误在所难免。而且对于cl的滤波函数，也没有很好的算法，也没花时间去研究。只能算是实验OpenCL的一个测试程序。对于GPU加速的程序，需要好的算法。对于程序员来说，需要改变以前的思维习惯，以前都用单一的计算单元在做计算，即便用到多线程，也是基于任务的，也就是说A线程做一件事，B线程做另外一件事。对于运算，一般在循环中顺序执行。而GPU由于内核多，是并发执行的，因此需要考虑其并发性和乱序执行。如果数据量小的话，其数据IO所占的时间往往比执行所占的时间多，这时使用GPU还不如使用CPU快。因此，好的算法以及运算量大的程序，才能感觉到GPU加速的优势。要写好OpenCL程序，以后的路还很长。（什么时候我们的程序由CPU和GPU自动调节运行就好了，对用户和程序员均不透明，就像双核或者多核CPU一样，我们根本就不用关心程序或者说某个线程在哪个核上运行！呵呵）。

Augusdi
关注
专栏目录
OpenCL做并行滤波
2Know的博客
10-15 1862
本实验主要进行OpenCL一维信号的滤波；主要思路是以离散信号的序列点作为目标，一个工作项负责一个信号点的计算；这样做的好处是方便，相对于串行实现获得相当大的性能提升；但是每个工作项负载不均衡。
学习OpenCL与卷积神经网络 Day1——对OpenCL与CNN的简单认识
不偷懒会死星人的blog
12-09 1770
目录自学工具自学用电子书自学用课程自学用平台关于OpenCL平台模型执行模型内核上下文命令队列存储器模型存储器类型存储器对象关于卷积神经网络(CNN)目的与用途构造卷积层(Convolution)池化层(Pooling)全连接层(FC layer)关于将OpenCL与CNN相结合的想法简单程序构建 自学工具 自学用电子书 OpenCL异构计算 OpenCL编程指南 OpenCL异构并行计算原理、机制与优化 自学用课程 [link]https://www.coursera.org/learn/opencl-f
OpenCL 实现单通道和多通道数字滤波
10-12
使用CPU + GPU的异构模式，实现单通道和多通道数字滤波（FIR）.其实现采用CPU实现和GPU实现，可以对比两种方法的结果。主要采用了OpenGL框架，在VS2008 + CUDA SDK4.2 + Win7下编译通过，显卡GForce 9600. VC完整工程，独立的C++类，全源码（包括Kernel函数）。可以作为OpenGL的入门资料。如果不能正常使用，请参看《ReadMe.doc》.
HPC应用&密码破解工具hashcat详细安装使用教程
最新发布
qq_27815483的博客
08-17 1160
​ hashcat号称是世界上最快的密码破解工具。此前曾有过hashcat-lagacy（仅支持CPU）、cudahashcat以及oclhashcat，本文所述的hashcat是现在已经作为开源软件在github上公开的由OpenCL实现的hashcat，当前最新版本为v6.1.1。支持多种操作系统（Linux, Windows 和 macOS），多种OpenCL运行时库（AMD, Apple, Intel, Nvidia, POCL, ROCM）以及多种计算设备（GPU、CPU、APU）。支持多种破解方
OpenCL双边滤波实现美颜功能
weixin_30426957的博客
02-22 292
OpenCL是一个并行异构计算的框架，包括intel，AMD，英伟达等等许多厂家都有对它的支持，不过英伟达只到1.2版本，主要发展自己的CUDA去了。虽然没有用过CUDA，但个人感觉CUDA比OpenCL更好一点，但OpenCL支持面更管，CPU,GPU,DSP,FPGA等多种芯片都能支持OpenCL。OpenCL与D3D中的像素着色器非常相似。 1.双边滤波原理 双边滤波器的...
CUDA、GPU实现图像的sobel、prewitt、均值、中值滤波
06-27
CUDA、GPU实现图像的sobel、prewitt、均值、中值滤波
Android平台下OpenCL并行Sobel滤波实现
06-11
这个项目"Android平台下OpenCL并行Sobel滤波实现"是利用OpenCL技术在安卓设备上进行图像处理，具体是实现了Sobel边缘检测算法的并行化。以下是对这个主题的详细阐述： 首先，我们需要理解Sobel滤波器。Sobel滤波是...
A C++ GPU Computing Library for OpenCL.zip
12-27
"A C++ GPU Computing Library for OpenCL"是针对OpenCL的C++封装库，它简化了OpenCL的使用，使得C++开发者可以更加便捷地进行GPU编程。该库通常包括以下功能： 1. **设备管理**：库提供了对OpenCL设备的轻松访问和...
Opencl 之bilateral filter优化
Emel 的博客
07-19 1406
由于项目的需要在我还没有搞清楚Opencl框架的情况下就开始去用opencl方式去优化一个图像处理算法--bilateral_filter，可想而知其过程的艰辛，好在昨天已经搞定收工了，感谢这一个月的过程让我从一个opencl路人变成了亲戚，特此写一篇博客记录下一些心得。废话少说现在开始。 拿到这个任务是我首先感觉相对我之前写代码还是比较高大上的，因此心里也暗暗下决心搞定这个问题，于是先去了解双...
基于OpenCL的mean filter性能
weixin_34161064的博客
12-16 225
1.对于一个标准的3*3 均值滤波，kernel代码如下： 使用buffer/image缓冲对象 __kernel void filter(__global uchar4* inputImage, __global uchar4* outputImage, uint N){ int x = get_global_id(0); int y = get_global_id(1); int w...
OpenCL的初步基本理解
松子茶的专栏
10-11 2132
对于OpenCL来说，它的执行过程可以这样理解：一段代码，.cpp的那个是在host上面执行的，也就是那段非kernel的代码。而kernel的那段代码来说，是在设备上执行的。对于平台，设备，上下文什么的都是一些比较抽象的概念。
OpenCL Workshop 1 —— 数字音频滤波
weixin_34405332的博客
03-24 264
Introduction 这两年深度学习大火，Cuda跟着吃红利，OpenCL发展也很快。虽然OpenCL不是事实上的标准，但是作为开放标准，适应性是很强的，除了显卡之外，CPU/FPGA上都可以执行。 第一个OpenCL Workshop的具体目标就是编写一个音频文件升频工具，用来给PCM编码的WAV文件四倍频，把升频结果写到一个新的WAV文件里面。 用于升频的主要方法，数字滤波，可以广泛...
GPU中值、均值滤波效果(2022/05/30)
yodala的博客
05-30 442
GPU的应用均值滤波中值滤波时间对比 均值滤波 如上图所示，从左到右分别是原图，以及通过均值滤波33，55处理后的图片，55的效果比33的好。 中值滤波 如上图所示，从左到右分别是原图，以及通过中值滤波33，55处理后的图片，55的效果比33的好。 时间对比 中值滤波比均值滤波效果好。 无论是中值还是均值滤波，55滤波器的的效果都比33的好。 当使用中值滤波时，利用gpu比利用cpu可以节约大量的时间，因为中值滤波需要进行排序处理，使用cpu的多重循环较为耗时，gpu则可以少两重循环。 ...
OpenCv图像处理之高斯滤波-线性滤波(三)
YANJINING
09-03 286
OpenCv图像处理之高斯滤波-线性滤波
《Mali OpenCL SDK v1.1.0》教程样例之六“索贝尔滤波器”
Johnson的技术博客
03-14 4011
Sobel图像滤波器是一种简单的卷积滤波器，主要用于边缘检测算法。 样例结果 输入图像 输出图像 算法 　　一种做图像边缘检测的技术是，找出图像的梯度。大梯度值的区域对应图像色彩或密度的剧变区域。典型地，这些区域是边缘。 　　如果你对于幅图像卷积两个Sobel算子，你会得到两个输出： 　> X方向的梯度(dX) 　> Y方
OpenCL 通用编程与优化（20）
weixin_38498942的博客
03-02 635
OpenCL 通用编程与优化（20）
编写OpenCL程序的基本步骤
实践出真理
09-06 949
OpenCL(全称为Open Computing Langugae，开放运算语言)是第一个面向异构系统(此系统中可由CPU，GPU或其它类型的处理器架构组成)的并行编程的开放式标准。它是跨平台的。OpenCL由两部分组成，一是用于编写kernels（在OpenCL设备上运行的函数）的语言，二是用于定义并控制平台的API(函数)。OpenCL提供了基于任务和基于数据两种并行计算机制，它极大地扩展了GPU的应用范围，使之不再局限于图形领域。
OpenCL编程指南：GPU与嵌入式图像处理宝典
在图像处理方面，OpenCL提供了强大的工具，允许开发者利用GPU的并行计算能力进行复杂的图像算法实现，例如滤波、边缘检测、图像转换等。通过OpenCL，开发者可以创建自定义的图像处理内核，充分利用GPU的并行计算单元...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值