【转载】OpenCL实现矩阵相乘

矩阵相乘其实就是前一个矩阵的每一行乘以后一个矩阵的每一列，然后将乘后的每一个数字相加，得到结果矩阵的指定位置的数值。具体算法回顾一下线性代数即可。但是这种行列相乘其实都是独立的，如果是CPU计算必须串行算法，一行一列的乘，但是放到GPU里面则可以并行相乘，如果维数很大那就会大大节约时间。

具体代码如下：

__kernel
void simpleMultiply(__global float* outPutC,
int widthA,
int heightA,
int widthB ,
int heightB ,
 __global float* inputA ,
__global  float* inputB
 )
{
   int row = get_global_id();
   int col = get_global_id();
   float sum = 0.0f  ;
   for(int i=;i<widthA; i++)
   {
        sum += inputA[row*widthA+i] * inputB[i*widthB+col];
    }
   outPutC[row*widthB+col] = sum;
} ; 

// FirstOpenCL.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include<time.h>
#include <string>
#include<math.h>
#include <vector>
#include <CL/cl.h>
#include <fstream>  

using namespace std; 

#pragma comment (lib,"OpenCL.lib")
std::string  convertToString(const char *filename)
{
    size_t size;
    char*  str;
    std::string s;
    std::fstream f(filename, (std::fstream::in | std::fstream::binary));
    if(f.is_open())
    {
        size_t fileSize;
        f.seekg(, std::fstream::end);
        size = fileSize = (size_t)f.tellg();
        f.seekg(, std::fstream::beg);
        str = new char[size+];
        if(!str)
        {
            f.close();
            std::cout << "Memory allocation failed";
            return NULL;
        }  

        f.read(str, fileSize);
        f.close();
        str[size] = '\0';
        s = str;
        delete[] str;
        return s;
    }
    else
    {
        std::cout << "\nFile containg the kernel code(\".cl\") not found. Please copy the required file in the folder containg the executable.\n";
        exit();
    }
    return NULL;
}  

int main()
{
    //查询平台
    cl_int ciErrNum;
    cl_platform_id platform;
    ciErrNum = clGetPlatformIDs(, &platform, NULL);  

    //获取设备信息
    cl_device_id device;
    cl_int   status;
    cl_uint maxDims;
    cl_event events[];
    size_t globalThreads[];
    size_t localThreads[];
    size_t maxWorkGroupSize;
    size_t maxWorkItemSizes[];  

    ciErrNum = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, , &device, NULL);
    status = clGetDeviceInfo( device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t),(void*)&maxWorkGroupSize,NULL);
    status = clGetDeviceInfo( device, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(cl_uint),(void*)&maxDims, NULL);
    status = clGetDeviceInfo( device, CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(size_t)*maxDims,(void*)maxWorkItemSizes, NULL);  

    //创建上下文
    cl_context ctx = clCreateContext(NULL, , &device, NULL, NULL, &ciErrNum);
    cl_command_queue myqueue = clCreateCommandQueue(ctx,device,,&ciErrNum);  

    int wA=,hA=;
    int wB=,hB=;
    int wC=,hC=;  

    // 数组的大小
    const int  elementsA = wA*hA;
    const int  elementsB = wB*hB;
    const int  elementsC = hA*wB;  

    // 计算内存大小
    size_t datasizeA = sizeof(float)*elementsA;
    size_t datasizeB = sizeof(float)*elementsB;
    size_t datasizeC = sizeof(float)*elementsC;
    // 分配内存空间
    float *A = (float*)malloc(datasizeA);
    float *B = (float*)malloc(datasizeB);
    float *C = (float*)malloc(datasizeC);  

    // 初始化输入数组
    for(int i = ;i < elementsA;i++)
    {
        A[i] = (float)((float)i + 1.0);
    }
    for(int i = ;i < elementsB;i++)
    {
        B[i] = (float)((float)i + 1.0);
    }  

    cl_mem bufferA = clCreateBuffer(ctx,CL_MEM_READ_ONLY,wA*hA*sizeof(float),NULL,&ciErrNum);
    ciErrNum = clEnqueueWriteBuffer(myqueue,bufferA,CL_TRUE,,wA*hA*sizeof(float),(void*)A,,NULL,NULL);  

    cl_mem bufferB = clCreateBuffer(ctx,CL_MEM_READ_ONLY,wB*hB*sizeof(float),NULL,&ciErrNum);
    ciErrNum = clEnqueueWriteBuffer(myqueue,bufferB,CL_TRUE,,wB*hB*sizeof(float),(void*)B,,NULL,NULL);  

    cl_mem bufferC = clCreateBuffer(ctx,CL_MEM_WRITE_ONLY,hA*wB*sizeof(float),NULL,&ciErrNum);  

    //运行时kernel编译
    const char * filename  = "HelloWorld_Kernel.cl";
    std::string  sourceStr = convertToString(filename);
    const char * source    = sourceStr.c_str();
    size_t sourceSize[]    = { strlen(source) };
    //直接将CL文件读到记忆体
    cl_program myprog = clCreateProgramWithSource( ctx, ,&source, sourceSize, &ciErrNum);
    //cl_program myprog = clCreateProgramWithSource(ctx,1,(const char**)&programSource,NULL,&ciErrNum);
    ciErrNum = clBuildProgram(myprog,,NULL,NULL,NULL,NULL);  

    cl_kernel mykernel = clCreateKernel(myprog,"simpleMultiply",&ciErrNum);
    //运行程序
    clSetKernelArg(mykernel,,sizeof(cl_mem),(void*)&bufferC);
    clSetKernelArg(mykernel,,sizeof(cl_mem),(void*)&wA);
    clSetKernelArg(mykernel,,sizeof(cl_mem),(void*)&hA);
    clSetKernelArg(mykernel,,sizeof(cl_mem),(void*)&wB);
    clSetKernelArg(mykernel,,sizeof(cl_mem),(void*)&hB);
    clSetKernelArg(mykernel,,sizeof(cl_mem),(void*)&bufferA);
    clSetKernelArg(mykernel,,sizeof(cl_mem),(void*)&bufferB);  

    size_t localws[] ={wC,wC};
    size_t globalws[]={wC,hC};  

    ciErrNum = clEnqueueNDRangeKernel(myqueue,mykernel,,NULL,globalws,localws,,NULL,&events[]);
    status = clWaitForEvents(, &events[]);
    status = clReleaseEvent(events[]);
    //将结果拷贝到主机端
    ciErrNum = clEnqueueReadBuffer(myqueue,bufferC,CL_TRUE,,wC*hC*sizeof(float),(void*)C,,NULL,&events[]);  

    status = clWaitForEvents(, &events[]);
    status = clReleaseEvent(events[]);  

    printf("\nArray A:\n");
    for (int i = ; i < wA; i++) {
        for (int j = ; j < hA; j++)
            printf("%4.3f\t", A[i*hA + j]);
        printf("\n");
    }
    printf("\nArray B:\n");
    for (int i = ; i < wB; i++) {
        for (int j = ; j < hB; j++)
            printf("%4.3f\t", B[i*hB + j]);
        printf("\n");
    }
    printf("\nArray C:\n");
    for (int i = ; i < wC; i++) {
        for (int j = ; j < hC; j++)
            printf("%4.3f\t", C[i*hC + j]);
        printf("\n");
    }

    getchar();
    return ;
}