OpenCl入门——实现简单卷积

现在的卷积实现无非是那么几种：直接卷积、im2col+gemm、局部gemm、wingrod、FFT。如果直接卷积的话，其实kernel函数是比较好实现。以下代码参考至《OpenCL Programing Guide》，主要是main函数各种构造比较麻烦，个人感觉，OpenCL为了追求平台的移植性，使用起来实在是太不方便了。(代码仅表示思路，未测试)

Convolution.cl:

//Convolution.cl
__kernel void convolve(const __global uint * const input, __constant uint *const mask, __global uint * const output, const int inputWidth, const int maskWidth)
{
    const int x = get_global_id();
    const int y = get_global_id();

    uint sum =;
    for(int r =;r<maskWidth;r++)
    {
        const int idxIntmp = (y +r) *inputWidth +x ;
        for(int c = ; c<maskWidth;c++)
        {
            sum +=mask[(r*maskWidth) +c] * input[idxIntmp +c];
        }
    }
    outpu[y* get_global_size() +x] = sum;
}

//Convolution.cpp

//Convolution.cpp
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <CL/cl.h>

//Constants
const unsigned int inputSignalWidth = ;
const unsigned int inputSignalHeight= ;

cl_uint inputSignal[inputSignalWidth][inputSignalHeight] =
{
    {, , , , , , ,  },
    {, , , , , , ,  },
    {, , , , , , ,  },
    {, , , , , , ,  },
    {, , , , , , ,  },
    {, , , , , , ,  },
    {, , , , , , ,  },
    {, , , , , , ,  }
};
const unsigned int outputSignalWidth = ;
const unsigned int outputSignalHeight= ;

cl_uint ouputSignal[outputSignalWidth][outputSignalHeight];
const unsigned int maskWidth = ;
const unsigned int maskHeight= ;

cl_uint mask[maskWidth][maskHeight] =
{
    {, , },
    {, , },
    {, , }
};

inline void checkErr(cl_int err, const char* name)
{
    if(err != CL_SUCCESS)
    {
        std::cerr <<"ERROR: "<< name
        <<" (" << err << ")"<<std::endl;
        exit(EXIT_FAILURE);
    }
}

void CL_CALLBACK contextCallback(const char * errInfo, const void * private_info, size_t cb, void * user_data)
{
    std::cout << "Error occurred during context user: "<< errInfo << std::endl;
    exit(EXIT_FAILURE);
}

int main(int argc, char** argv)
{
    cl_int errNum;
    cl_uint numPlatforms;
    cl_uint numDevices;
    cl_platform_id * platformIDs;
    cl_context context =NULL;
    cl_command_queue queue;
    cl_program program;
    cl_kernel kernel;
    cl_mem inputSignalBuffer;
    cl_mem outputSignalBuffer;
    cl_mem maskBuffer;

    errNum = clGetPlatformIDs(, NULL, &numPlatforms);
    checkErr( (errNum != CL_SUCCESS )? errNum: (numPlatforms <=  ? -: CL_SUCCESS),"clGetPlatformIDs");

    deviceIDs = NULL;
    cl_uint i;
    for(i =; i <numPlatforms; i++)
    {
        errNum = clGetDeviceIDs(platformIDs[i], CL_DEVICE_TYPE_CPU, , NULL, &numDevices);
        if(errNum != CL_SUCCESS && errNum !=CL_DEVICE_NOT_FOUND)
        {
            checkErr(errNum, "clGetDeviceIDs");
        }
        else if(numDevices > )
        {
            deviceIDs = (cl_device_id *)alloca(sizeof(cl_device_id) * numDevices);
            break;
        }
    }

    cl_context_properties contextProperties[] =
    {
        CL_CONTEXT_PLATFORM, (cl_context_properties)platformIDs[i],
    };
    context = clCreateContext(contextProperties, numDevices, deviceIDs,&contextCallback, NULL, &errNum);
    checkErr(errNum, "clCreateContext");

    std::ifstream srcFile("Convolution.cl");
    std::string srcProg(std::istreambuf_iterator<char>(srcFile),(std::istreambuf_iterator<char>()));

    const char * src = srcProg.c_str();
    size_t length = srcProg.length();

    program = clCreateProgramWithSource(context, , &src, &length, &errNum);
    checkErr(errNum, "clCreateProgramWithSource");

    errNum = clBuildProgram(program, numDevices, deviceIDs, NULL, NULL, NULL);
    checkErr(errNum, "clBuildProgram");

    kernel = clCreateKernel(program, "convolve", &errNum);
    checkErr(errNum, "clCreateKernel");

    inputSignalBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(cl_uint) * inputSignalHeight * inputSignalWidth,
        static_cast<void*> (inputSignal), &errNum);
    checkErr(errNum, "clCreateBuffer(inputSignal)");

    maskBuffer = clCreateBuffer(context,CL_MEM_READ_ONLY| CL_MEM_COPY_HOST_PTR, sizeof(cl_uint)* maskHeight *maskWidth, static_cast<void*>(mask), &errNum);
    checkErr(errNum, "clCreateBuffer(mask)");

    outputSignalBuffer= clCreateBuffer(context,CL_MEM_WRITE_ONLY ,sizeof(cl_uint)* outputSignalHeight *outputSignalWidth, NULL, &errNum);
    checkErr(errNum, "clCreateBuffer(outputSignal)");

    queue = clCreateCommandQueue(context, deviceIDs[], , &errNum);
    checkErr(errNum, "clCreateCommandQueue");

    errNum = clSetKernelArg(kernel, , sizeof(cl_mem), &inputSignalBuffer);
    errNum |=clSetKernelArg(kernel, , sizeof(cl_mem), &maskBuffer);
    errNum |=clSetKernelArg(kernel, , sizeof(cl_mem), &outputSignalBuffer);
    errNum |=clSetKernelArg(kernel, , sizeof(cl_uint),&inputSignalWidth);
    errNum |=clSetKernelArg(kernel, , sizeof(cl_uint),&maskWidth);
    checkErr(errNum, "clSetKernelArg");

    const size_t globalWorkSize[] = {outputSignalWidth *outputSignalHeight};
    const size_t localWorkSize[] = {};

    errNum = clEnqueueNDRangeKernel(queue,kernel, , NULL, globalWorkSize, localWorkSize, , NULL, NULL);
    checkErr(errNum, "clEnqueueNDRangeKernel");

    errNum = clEnqueueReadBuffer(queue, outputSignalBuffer,CL_TRUE, , sizeof(cl_uint)*outputSignalHeight*outputSignalWidth, outputSignal, , NULL, NULL);
    checkErr(errNum, "clEnqueueReadBuffer");
    return ;
}