OpenCL简单的框架

最新推荐文章于 2024-06-23 14:25:49 发布
最新推荐文章于 2024-06-23 14:25:49 发布
阅读量458 收藏
点赞数 1
分类专栏： OpenCL 文章标签： opencl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jsf921942722/article/details/51753881
版权

**1.**openclModel.cpp

#include <string.h>
#include <stdio.h>
#include "bufferCpy.h"
#include "CLInit.h"
#include "InitKernel.h"
#include "MemBuffer.h"

int main()
{

    initCLEnv();
    InitKernelList();
    InitMem(10, 10);

    bufferCopy(MEM_input, MEM_output);

    UnitMem();
    UnitKernelList();
    unitCLEnv();

    getchar();
    return 0;
}

**2.**CLInit.h CLInit.hc

#ifndef _CLINIT_H_
#define _CLINIT_H_

#include <CL\cl.h>

typedef struct _CLENV_{
    cl_platform_id * platform;
    cl_uint numOfPlatform;
    cl_device_id * device;
    cl_uint numOfDevice;
    cl_context ctx;
    cl_command_queue * commandQueue;
    int inited;
}clEnv;

#ifdef __cplusplus
extern "C"
{
#endif

clEnv * getCLEnv();
int initCLEnv();
int unitCLEnv();

#ifdef __cplusplus
}
#endif

#endif
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include "CLInit.h"
#pragma warning(disable : 4996)

static clEnv gCLEnv = {0};

clEnv * getCLEnv(){
    if(gCLEnv.inited == 1)
    {
        return &gCLEnv;
    }else
    {
        return NULL;
    }
}

static int initPlatform(){
    cl_int err = 0;
    err = clGetPlatformIDs(0, NULL, &(gCLEnv.numOfPlatform));
    if(err != CL_SUCCESS || 0 == gCLEnv.numOfPlatform)
    {
        printf("clGetPlatformIDs error. error code = %d\n", err);
        return -1;
    }
    gCLEnv.platform = (cl_platform_id*)malloc(sizeof(cl_platform_id) * gCLEnv.numOfPlatform);
    if(NULL == gCLEnv.platform){
        printf("malloc platform error.\n");
        return -2;
    }
    err = clGetPlatformIDs(gCLEnv.numOfPlatform, gCLEnv.platform, NULL);
    if(CL_SUCCESS != err)
    {
        printf("clGetPlatformIDs error. error code = %d\n", err);
        return -3;
    }
    return 0;
}
static int initDevice(){
    cl_int err = 0;
    cl_uint i = 0;
    cl_platform_id temp;
    for(i = 0; i < gCLEnv.numOfPlatform; i ++)
    {
        char platformInfo[2048];
        size_t num = 0;
        clGetPlatformInfo(gCLEnv.platform[i], CL_PLATFORM_VENDOR, 2048, platformInfo, &num);
        platformInfo[num] = '\0';
        printf("platform number = %d ,  %s\n", i, platformInfo);
    }
    for(i = 0; i < gCLEnv.numOfPlatform; i ++){
        char platformInfo[2048];
        size_t num = 0;
        clGetPlatformInfo(gCLEnv.platform[i], CL_PLATFORM_VENDOR, 2048, platformInfo, &num);
        platformInfo[num] = '\0';
        if(strcmp(platformInfo, "Advanced Micro Devices, Inc."))
        {
            continue;
        }
        err = clGetDeviceIDs(gCLEnv.platform[i], CL_DEVICE_TYPE_GPU, 0, NULL, &gCLEnv.numOfDevice);
        if(0 != gCLEnv.numOfDevice)
        {
            gCLEnv.device = (cl_device_id*)malloc(gCLEnv.numOfDevice * sizeof(cl_device_id));
            if(NULL == gCLEnv.device){
                printf("malloc devices error.\n");
                return -1;
            }
            err = clGetDeviceIDs(gCLEnv.platform[i], CL_DEVICE_TYPE_GPU, gCLEnv.numOfDevice, gCLEnv.device, 0);
            if(CL_SUCCESS != err){
                printf("clGetDeviceIDs error. error code = %d\n", err);
                return -2;
            }

            temp = gCLEnv.platform[0];
            gCLEnv.platform[0] = gCLEnv.platform[i];
            gCLEnv.platform[i] = temp;

            {
                char deviceInfo[2048];
                size_t num = 0;
                clGetDeviceInfo (gCLEnv.device[0],CL_DEVICE_NAME,2048, deviceInfo, &num);
                deviceInfo[num] = '\0';
                printf("select device name = %s\n", deviceInfo);

            }
            {
                char platformInfo[2048];
                size_t num = 0;
                clGetPlatformInfo(gCLEnv.platform[0],CL_PLATFORM_VENDOR, 2048, platformInfo, &num);
                platformInfo[num] = '\0';
                printf("select platform name = %s\n", platformInfo);
            }
            break;
        }
    }

    if(0 != gCLEnv.numOfDevice)
    {
        return 0;
    }

    for(i = 0; i < gCLEnv.numOfPlatform; i ++){
        err = clGetDeviceIDs(gCLEnv.platform[i], CL_DEVICE_TYPE_CPU, 0, NULL, &gCLEnv.numOfDevice);
        if(0 != gCLEnv.numOfDevice){
            gCLEnv.device = (cl_device_id*)malloc(gCLEnv.numOfDevice * sizeof(cl_device_id));
            if(NULL == gCLEnv.device){
                printf("malloc device error.\n");
                return -1;
            }
            err = clGetDeviceIDs(gCLEnv.platform[i], CL_DEVICE_TYPE_CPU, gCLEnv.numOfDevice, gCLEnv.device, 0);
            if(CL_SUCCESS != err){
                printf("clGetDeviceIDs error. error code = %d\n", err);
                return -2;
            }

            temp = gCLEnv.platform[0];
            gCLEnv.platform[0] = gCLEnv.platform[i];
            gCLEnv.platform[i] = temp;

            {
                char deviceInfo[2048];
                size_t num = 0;
                clGetDeviceInfo (gCLEnv.device[0],CL_DEVICE_NAME,2048, deviceInfo, &num);
                deviceInfo[num] = '\0';
                printf("select device name = %s\n", deviceInfo);

            }
            {
                char platformInfo[2048];
                size_t num = 0;
                clGetPlatformInfo(gCLEnv.platform[0],CL_PLATFORM_VENDOR, 2048, platformInfo, &num);
                platformInfo[num] = '\0';
                printf("select platform name = %s\n", platformInfo);
            }

            break;
        }
    }
    return 0;
}
static int initContext(){
    cl_int err = 0;
    cl_context_properties prop[3] = {CL_CONTEXT_PLATFORM, (cl_context_properties)gCLEnv.platform[0], 0};
    gCLEnv.ctx = clCreateContext(prop, gCLEnv.numOfDevice, gCLEnv.device, NULL, NULL, &err);

    if(CL_SUCCESS != err){
        printf("clCreateContext error. error code = %d\n", err);
        return -1;
    }
    return 0;
}
static int initCommandQueue(){
    int err = 0;
    cl_uint i = 0;

    gCLEnv.commandQueue = (cl_command_queue*)malloc(sizeof(cl_command_queue) * gCLEnv.numOfDevice);
    if(NULL == gCLEnv.commandQueue){
        printf("malloc commandQueue error\n");
        return -1;
    }

    for(i = 0; i < gCLEnv.numOfDevice; i ++){
        gCLEnv.commandQueue[i] = clCreateCommandQueue(gCLEnv.ctx, gCLEnv.device[i], CL_QUEUE_PROFILING_ENABLE, &err);
        if(CL_SUCCESS != err){
            printf("clCreateCommandQueue error. error code = %d\n", err);
            return -2;
        }
    }
    return 0;
}

int initCLEnv(){
    int err = 0;
    if((err = initPlatform()) != 0)
    {
        printf("initplatform error.\n");
        return -1;
    }
    if((err = initDevice()) != 0)
    {
        printf("initDevice error.\n");
        return -2;
    }
    if((err = initContext()) != 0)
    {
        printf("initContext error.\n");
        return -3;
    }
    if((err = initCommandQueue()) != 0)
    {
        printf("initCommandQueue error.\n");
        return -4;
    }
    gCLEnv.inited = 1;
    return 0;
}
int unitCLEnv(){
    cl_uint i = 0;
    for(i = 0; i < gCLEnv.numOfDevice; i ++){
        clReleaseCommandQueue(gCLEnv.commandQueue[i]);
    }
    free(gCLEnv.commandQueue);

    clReleaseContext(gCLEnv.ctx);
    for(i = 0; i < gCLEnv.numOfDevice; i ++){
        clReleaseDevice(gCLEnv.device[i]);
    }
    free(gCLEnv.device);

    free(gCLEnv.platform);

    memset(&gCLEnv, 0, sizeof(clEnv));

    return 0;
}

**3.**InitKernel.h InitKernel.c

#ifndef _INITKERNEL_H_                        
#define _INITKERNEL_H_                        
//                                             
//Auto generated file                          
//                                             
typedef enum _KERNEL_List_{                    
    KERNEL_Start            = -1,              
    KERNEL_buffercpy,                             
    KERNEL_Number                              
}KERNEL_List;                                  
#ifdef __cplusplus                  
extern "C"                      
{                           
#endif                      
cl_kernel* getKernelList();                    
int InitKernelList();                          
int UnitKernelList();                          
#ifdef __cplusplus                  
}                           
#endif                      
//                                             
//end                                          
//                                             
#endif    
#include <CL\cl.h>
#include <stdio.h>
#include "InitKernel.h"
#include "CLInit.h"
#include "kernelSrc.c"
static cl_kernel kernelList[KERNEL_Number] = {0};

cl_kernel* getKernelList(){
    return kernelList;
}

int InitKernelList(){

    cl_int err = 0;
    int i = 0;

    clEnv * env = getCLEnv();

    cl_program m_program = clCreateProgramWithSource(env->ctx, 1, &kernelsrc, NULL, &err);

    if(CL_SUCCESS != err){
        printf("clCreateProgramWidthSource error. error code = %d\n", err);
        return -1;
    }
    err = clBuildProgram(m_program, env->numOfDevice, env->device, NULL, NULL, NULL);
    if(CL_SUCCESS != err){
        printf("clBuildProgram error. error code = %d\n", err);
        return err;
    }
    for(i = 0; i < KERNEL_Number; i ++){
        kernelList[i] = clCreateKernel(m_program, kernelName[i], &err);
        if(CL_SUCCESS != err){
            printf("clCreateKernel %s error. error code = %d\n", kernelName[i], err);
            return err;
        }
    }

    clReleaseProgram(m_program);

    return 0;
}

int UnitKernelList(){
    int i = 0; 
    for(i = 0; i < KERNEL_Number; i ++){
        clReleaseKernel(kernelList[i]);
        kernelList[i] = 0;
    }
    return 0;
}

**4.**MemBuffer.h MemBuffer.c

#ifndef _MEMBUFFER_H_
#define _MEMBUFFER_H_

#include <CL\cl.h>
typedef enum _MEMLIST_{
    MEM_START = -1,
    MEM_input,
    MEM_output,
    MEM_Number,
}MEM_LIST;
#ifdef __cplusplus
extern "C"
{
#endif
cl_mem * getMemList();
int InitMem(int width, int height);
int UnitMem();

int loadMemData(MEM_LIST memBuffer, int width, int height, float * data);

#ifdef __cplusplus
}
#endif

#endif
#include <stdio.h>
#include "MemBuffer.h"
#include "CLInit.h"
static cl_mem memList[MEM_Number] = {0};
cl_mem* getMemList(){
    return memList;
}
int InitMem(int width, int height){

    cl_int err = 0;
    clEnv * env = NULL;
    env = getCLEnv();

    memList[MEM_input] = clCreateBuffer(env->ctx, CL_MEM_READ_WRITE, width * height * sizeof(float), NULL, &err);
    if(CL_SUCCESS != err){
        goto ERROR;
    }

    memList[MEM_output] = clCreateBuffer(env->ctx, CL_MEM_READ_WRITE, width * height * sizeof(float), NULL, &err);
    if(CL_SUCCESS != err){
        goto ERROR;
    }

    return 0;
ERROR:
    printf("clCreateBuffer error.error code = %d", err);
    return -1;
    return 0;
}

int UnitMem(){
    int i = 0; 
    for(i = 0; i < MEM_Number; i ++){
        if(memList[i] != NULL){
            clReleaseMemObject(memList[i]);
            memList[i] = 0;
        }
    }
    return 0;
}
int loadMemData(MEM_LIST memBuffer, int width, int height, float * data){
    cl_int err = 0;
    clEnv * env = NULL;
    env = getCLEnv();

    err = clEnqueueWriteBuffer(env->commandQueue[0], memList[MEM_input], CL_FALSE, 0, width * height * sizeof(float), data, 0, NULL, NULL);
    if(CL_SUCCESS != err){
        printf("write buffer error. error code = %d\n", err);
        return -1;
    }
    return 0;
}

5. bufferCpy.h bufferCpy.c

#ifndef _BUFFERCPY_H_
#define _BUFFERCPY_H_
#include "MemBuffer.h"
#ifdef __cplusplus
extern "C"
{
#endif

    int bufferCopy(MEM_LIST input, MEM_LIST output);

#ifdef __cplusplus
}
#endif


#endif
#include <malloc.h>
#include <stdio.h>
#include "bufferCpy.h"
#include "CLInit.h"
#include "InitKernel.h"
int bufferCopy(MEM_LIST input, MEM_LIST output){

    int width = 10, height = 10;
    float * inData = NULL;
    float * outData = NULL;
    size_t mGlobal;
    float data = 0.0f;
    int i, j;
    cl_int err = 0;
    cl_mem * memList = NULL;
    cl_kernel * kernelList = NULL;
    clEnv * env = NULL;

    inData = (float*)malloc(width * height * sizeof(float));
    outData = (float*)malloc(width * height * sizeof(float));
    for(i = 0; i < height; i ++){
        for(j = 0; j < width; j ++){
            inData[i * width + j] = data;
            printf("%f ", inData[i * width + j]);
            data += 1.0f;
        }
        printf("\n");
    }
    printf("***************************************************************************\n");



    memList = getMemList();
    kernelList = getKernelList();
    env = getCLEnv();

    err = clEnqueueWriteBuffer(env->commandQueue[0], memList[MEM_input], CL_TRUE, 0, width * height * sizeof(float), inData, 0, NULL, NULL);
    if(CL_SUCCESS != err){
        printf("bufferCopy clEnqueueWriteBuffer error. error code = %d\n", err);
        return err;
    }

    err  = clSetKernelArg(kernelList[KERNEL_buffercpy], 0, sizeof(cl_mem), &memList[MEM_input]);
    err += clSetKernelArg(kernelList[KERNEL_buffercpy], 1, sizeof(cl_mem), &memList[MEM_output]);
    if(CL_SUCCESS != err){
        printf("bufferCopy clSetKernelArg error. error code = %d\n", err);
        return err;
    }
    mGlobal = width * height;
    err = clEnqueueNDRangeKernel(env->commandQueue[0], kernelList[KERNEL_buffercpy], 1, NULL, &mGlobal, NULL, 0, NULL, NULL);
    if(CL_SUCCESS != err){
        printf("bufferCopy clEnqueueNDRangeKernel error. error code = %d\n", err);
        return err;
    }


    err = clEnqueueReadBuffer(env->commandQueue[0], memList[MEM_output], CL_TRUE, 0, width * height * sizeof(float), outData, 0, NULL, NULL);
    if(CL_SUCCESS != err){
        printf("bufferCopy clEnqueueMapBuffer error. error code = %d\n", err);
        return err;
    }

    for(i = 0; i < height; i ++){
        for(j = 0; j < width; j ++){
            printf("%f ", outData[i * width + j]);
        }
        printf("\n");
    }
    return 0;
}

**6.**buffercpy.cl

/*
    * name          : buffercpy
    * @param in     : input
    * @param out    : output
*/
__kernel void buffercpy(__global float * in, __global float * out){ 
    int id = get_global_id(0);
    out[id] = in[id];
}

**7.**PrepareCLKernel.bat 改文件是把文件中kernel,转换成字符串

@echo off

echo 开始删除文件。。。
@del kernelSrc.c
@del InitKernel.h
echo 删除文件完成。。。

echo #ifndef _KernelSrc_C_                          >> kernelSrc.c
echo #define _KernelSrc_C_                          >> kernelSrc.c
echo //                                             >> kernelSrc.c
echo //Auto generated file                          >> kernelSrc.c
echo //                                             >> kernelSrc.c

echo static const char* kernelName[] = {            >> kernelSrc.c


echo #ifndef _INITKERNEL_H_                        >> InitKernel.h
echo #define _INITKERNEL_H_                        >> InitKernel.h
echo //                                             >> InitKernel.h
echo //Auto generated file                          >> InitKernel.h
echo //                                             >> InitKernel.h
echo typedef enum _KERNEL_List_{                    >> InitKernel.h
echo     KERNEL_Start            = -1,              >> InitKernel.h


@setlocal enabledelayedexpansion
For /F "delims==" %%i in ('dir /b *.cl') do (
echo     "%%~nsi",                                  >> kernelSrc.c
echo     KERNEL_%%~nsi,                             >> InitKernel.h
)
@setlocal disabledelayedexpansion

echo };                                             >> kernelSrc.c

echo     KERNEL_Number                              >> InitKernel.h
echo }KERNEL_List;                                  >> InitKernel.h

echo #ifdef __cplusplus                 >> InitKernel.h
echo extern "C"                     >> InitKernel.h
echo {                          >> InitKernel.h
echo #endif                     >> InitKernel.h

echo cl_kernel* getKernelList();                    >> InitKernel.h
echo int InitKernelList();                          >> InitKernel.h
echo int UnitKernelList();                          >> InitKernel.h

echo #ifdef __cplusplus                 >> InitKernel.h
echo }                          >> InitKernel.h
echo #endif                     >> InitKernel.h

echo //                                             >> InitKernel.h
echo //end                                          >> InitKernel.h
echo //                                             >> InitKernel.h
echo #endif                                         >> InitKernel.h

echo static const char* kernelsrc =                 >> kernelSrc.c

@setlocal enabledelayedexpansion
set var=
For /F "delims==" %%i in ('dir /b *.cl') do (
For /F "delims=" %%l in ('type "%%~nsi.cl"') do (
echo "%%l\n"\>> kernelSrc.c
)
echo "\n"\>> kernelSrc.c
)
@setlocal disabledelayedexpansion

echo "";>> kernelSrc.c

echo //                                             >> kernelSrc.c
echo //end                                          >> kernelSrc.c
echo //                                             >> kernelSrc.c
echo #endif                                         >> kernelSrc.c

move kernelSrc.c ..\kernelInc\kernelSrc.c
move InitKernel.h ..\..\InitKernel.h

@echo Done

如有疑问可留言。

darkerJ
关注
专栏目录
并行编程框架OpenCL
哈哈星云
05-16 779
OpenCL提供了一个统一的编程模型，使开发人员可以轻松地编写并行代码，并将其映射到不同的硬件平台上。需要注意的是，由于OpenCL是一个跨平台的编程模型，具体的代码可能会根据不同的平台和设备有所不同。作者专业：该书的作者是OpenCL专家，具有丰富的实践经验和理论知识，能够深入浅出地介绍OpenCL的使用和原理。经典案例：书中不仅有理论知识的介绍，还有很多实际的案例和示例代码，可以帮助读者更好地理解和运用OpenCL。是在设备上执行的函数，它将输入向量a和b中的元素相加，并将结果存储在输出向量c中。
OpenCL的框架
松子茶的专栏
10-06 3589
面向异构平台的应用都必须完成的步骤：1）发现构成异构系统的组件。2）探查这些组件的特征，使软件能够适应不同硬件单元的特定特性。3）创建将在平台上运行的指令块（内核）。4）建立并管理计算中涉及的内存对象。5）在系统中正确的组件上按正确的顺序执行内核。6）收集最终结果。这些步骤通过OpenCL中的一系列API再加上一个面向内核的编程环境来完成。我们将采用一种“分而治之”的策略解释以上步骤的所有工作。
OpenCL框架
生活需要深度
03-03 356
OpenCL(Open Computing Language，开放计算语言）：从软件视角看，它是用于异构平台编程的框架；从规范视角看，它是异构并行计算的行业标准，由Khronos Group来维护；异构平台包括了CPU、GPU、FPGA、DSP，以及最近几年流行的各类AI加速器等；OpenCL包含两部分：1）用于编写运行在OpenCL device上的kernels的语言（基于C99）；2）OpenCL API，至于Runtime的实现交由各个厂家，比如Intel发布的。
代码硬件从零开始做OpenCL开发（一）架构
weixin_33877885的博客
05-03 142
时间紧张，先记一笔，后续优化与完善。   本文将作为我《从零开始做OpenCL开辟》系列文章的第一篇。       1 异构盘算、GPGPU与OpenCL   OpenCL是前当一个通用的由很多公司和组织同共起发的多CPU\GPU\其他片芯 异构盘算（heterogeneous）的标准，它是跨平台的。旨在充分利用GPU壮大的并行盘算能力以及与CPU的协同任务，更高效的利用硬件高效的成完大规...
OpenCL程序框架
meeelion的专栏
05-17 500
这几天研究了一下OpenCL，阅读了nvidia中的例子，归纳OpenCL程序的一般结构如下：int main(int argc, char* argv[]){        //获得platform        clGetPlatformIDs(1, &cpPlatform, NULL);        //获得GPU设备        clGetDevic
OpenCL框架与示例
吴建明wujianming_110117
12-10 495
OpenCL框架与示例 下面的图简单说明了OpenCL的编程框架，图是用的GPU，其他类似； 名词的概念： Platform (平台)：主机加上OpenCL框架管理下的若干设备构成了这个平台，通过这个平台，应用程序可以与设备共享资源并在设备上执行kernel。实际使用中基本上一个厂商对应一个Platform，比如Intel, AMD都是这样。 Device（设备）：官方的解释是计算单元（Compute Units）的集合。举例来说，GPU是典型的device。Intel和AMD的多核CPU也提供OpenC
cf4ocl：OpenCL的C框架
02-05
OpenCL的C框架cf4ocl是用于开发和基准化项目的跨平台纯C面向对象的框架。 目的是： 促进用C（支持C ++）快速开发OpenCL主机程序，并避免通常需要的繁琐且容易出错的样板代码。 协助基准测试OpenCL事件，例如内核...
OpenCL框架下的流域径流模拟分布式调度研究.pdf
08-08
OpenCL框架下的流域径流模拟分布式调度研究主要针对大规模流域范围内，通过使用像元作为基本单元进行并行计算，可以实现逐小时迭代，从而有效模拟径流汇流过程。在OpenCL（Open Computing Language）框架中，将流...
一文细说OpenCL框架
youzhangjing_的博客
02-02 605
OpenCL(Open Computing Language，开放计算语言）：从软件视角看，它是用于异构平台编程的框架；从规范视角看，它是异构并行计算的行业标准，由Khronos Group来维护；异构平台包括了CPU、GPU、FPGA、DSP，以及最近几年流行的各类AI加速器等；OpenCL包含两部分：1）用于编写运行在OpenCL device上的kernels的语言（基于C99）；
opengcl:跨平台通用C ++组件库
03-29
OpenGCL的 OpenGCL是一个用c ++编写的开源跨平台通用组件库。 可用组件 gthread：符合POSIX pthread的多线程和C ++包装器 gsem：符合POSIX标准的信号灯 gsocket：套接字API和C ++包装器 gtimer：高分辨率计时器 gmmap：内存映射文件 glist：简单的双向链表 gque：简单的循环队列 gmbox：线程安全gque（消息框） gevent：简单的线程安全事件和事件发射器 gtokenizer：简单的字符串标记器 支持平台 GNU / Linux WIN32 西格温 Mingw-64 资源资源 请参阅目录以获取简要用法。
浅谈opencl之整体框架
weixin_42730667的博客
08-04 386
结合四大模型，以CPU和GPU平台为例子，opencl整体框架如下： CPU为host端， GPU为device端， host和device端的交互是以context为主。context贯穿到整个opencl程序的过程，是opencl交互基础。首先以conext创建programs， kernel程序有两种方式一种是以字符串的形式，另外一种是以二进制方式，最后通过program提交到GPU上...
OpenCL框架组成
华章IT官方博客
11-21 223
OpenCL框架组成 本文主要讨论OpenCL框架，其组成可划分为以下三个部分： OpenCL平台API：平台API定义了宿主机程序发现OpenCL设备所用的函数以及这些函数的功能，另外还定义了为OpenCL应用创建上下文的函数。 OpenCL运行时API：这个API管理上下文来创建命令队列以及运行时发生的其他操作。例如，将命令提交到命令队列的函数就来自OpenCL运行时API。 Op...
【OpenCL基础 · 二 】OpenCL架构
lijianyi0219的博客
09-12 2126
通过【OpenCL基础 · 一】因源，我们了解了OpenCL的起源和应用场景。在异构并行平台上，OpenCL可以协助开发者方便地使用计算资源，使得异构平台编程变得容易。那么如何使用这个便捷的开发工具就是开发人员需要学习的了，我们需要从宏观到细节去理解OpenCL是如何运作的，才能进行实际的代码开发工作。这篇博文将介绍OpenCL的整体框架，展示它是如何利用异构平台进行控制、资源调度及运算的。包括OpenCL平台模型、执行模型和存储器模型。
关于OpenCL架构的整理
2Know的博客
04-18 2002
关于OpenCL架构的整理OpenCL不仅仅是一种编程语言，也是一种并行编程框架。它包括编程语言、API、函数库以及运行时来支持软件在整个平台上的开发。 下面介绍OpenCL中包含的各个模型： 平台模型Platform Model 内存模型Memory Model 执行模型Execution Model 编程模型Programming Model 1. 平台模型平台模型是对不同硬件平台（主机以及不同
OpenCL相关开源项目
v2nero的专栏
08-24 1087
https://github.com/FakenMC/cf4ocl/wiki/OpenCL-implementations
OpenCL 教程：从基础到实践
最新发布
jiayoushijie的博客
06-23 5051
OpenCL（Open Computing Language）是一个开放标准的并行编程框架，用于在异构系统上编写高性能计算程序。它允许开发者利用各种计算设备（如 CPU、GPU、FPGA 等）来加速计算密集型任务。通过本教程，我们已经深入探讨了 OpenCL 的核心概念、编程模型、内存模型和执行模型。我们还通过实际的例子展示了如何实现和优化 OpenCL 程序。记住，优化是一个迭代的过程。始终使用性能分析工具来测量你的优化效果，并根据具体的硬件和问题特性来调整你的策略。
OpenCL编程指南-1.1OpenCL简介
qq_36314864的博客
05-10 1343
OpenCL是面向由CPU、GPU和其他处理器组合构成的计算机进行编程的行业标准框架。这些所谓的 “异构系统” 已经成为一类重要的平台，OpenCL是直接满足这些异构系统需求的第一个行业标准。OpenCL于2008年12月首次发布，早期产品则在2009年秋天才推出，因此OpenCL是一项相当新的技术。利用OpenCL，可以编写一款能够在各类系统上成功运行的程序，这些系统包括移动电话、笔记本电脑，甚至是大规模超计算机中的节点。OpenCL通过公布硬件来提供高度的可移植性，而不是将硬件隐藏在精巧的抽象之下。
OpenCL简介
热门推荐
qq_44074143的博客
03-22 2万+
文章目录前言一、什么是OpenCL？1.1 平台模型1.2 执行模型1.2.1 内核如何在 OpenCL 设备上执行1.2.2 上下文1.2.3 命令队列1.3 内存模型1.4 编程模型二、OpenCL的内容 前言 一、什么是OpenCL？ OpenCL是面向由CPU、GPU和其他处理器组合构成的计算机进行编程的行业标准框架。用OpenCL， 可以编写一款能够在各类系统上成功运行的程序，这些系统包括移动电话、笔记本电脑， 甚至是大规模超计算机中的节点。Open CL通过公布硬件 来提供高度的可移植性， 而
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值