GPGPU OpenCL Reduction操作与group同步

Reduction操作：规约操作就是由多个数生成一个数，如求最大值、最小值、向量点积、求和等操作，都属于这一类操作。

有大量数据的情况下，使用GPU进行任务并行与数据并行，可以收到可好的效果。

group同步：OpenCL只提供了工作组内的各线程之间的同步机制，并没有提供所有线程的同步。提供组内item-work同步的方法：

　　void barrier (cl_mem_fence_flags flags)

　　参数说明：cl_mem_fence_flags 可以取CLK_LOCAL_MEM_FENCE、CLK_GLOBAL_MEM_FENCE

　　函数说明：(1)一个work-group中所有work-item遇到barrier方法，都要等待其他work-item也到达该语句，才能执行后面的程序；

　　　　　　　 (2)还可以组内的work-item对local or global memory的顺序读写操作。

如下图中每个大框表示任务并行、每个group线程；框中的计算是数据并行、每个item-work线程：

作为练习，给出个完整的使用OpenCL计算整数序列求和，在数据并行中使用Local Memory 加速，group组内并行同步使用CLK_LOCAL_MEM_FENCE。

程序实例(整数序列求和)：

1.核函数(Own_Reduction_Kernels.cl)：

 __kernel
 void
 reduce(__global uint4* input, __global uint4* output, int NUM)
 {
     NUM = NUM / ;    //每四个数为一个整体uint4。
     unsigned int tid = get_local_id();
     unsigned int localSize = get_local_size();
     unsigned int globalSize = get_global_size();

     uint4 res=(uint4){,,,};
     __local uint4 resArray[];

     unsigned int i = get_global_id();
     while(i < NUM)
     {
         res+=input[i];
         i+=globalSize;
     }
     resArray[tid]=res;    //将每个work-item计算结果保存到对应__local memory中
     barrier(CLK_LOCAL_MEM_FENCE);

     // do reduction in shared mem
     for(unsigned int s = localSize >> ; s > ; s >>= )
     {
         if(tid < s)
         {
             resArray[tid] += resArray[tid + s];
         }
         barrier(CLK_LOCAL_MEM_FENCE);
     }

     // write result for this block to global mem
     if(tid == )
         output[get_group_id()] = resArray[];
 }

2.tool.h 、tool.cpp

见：http://www.cnblogs.com/xudong-bupt/p/3582780.html 

3.Reduction.cpp

 #include <CL/cl.h>
 #include "tool.h"
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <iostream>
 #include <string>
 #include <fstream>
 using namespace std;

 int isVerify(int NUM,int groupNUM,int *res)    //校验结果
 {
        int sum1 = (NUM+)*NUM/;
     int sum2 = ;
     for(int i = ;i < groupNUM*; i++)
         sum2 += res[i];
     if(sum1 == sum2)
         return ;
     return -;
 }

 void isStatusOK(cl_int status)    //判断状态码
 {
     if(status == CL_SUCCESS)
         cout<<"RIGHT"<<endl;
     else
         cout<<"ERROR"<<endl;
 }

 int main(int argc, char* argv[])
 {
     cl_int    status;
     /**Step 1: Getting platforms and choose an available one(first).*/
     cl_platform_id platform;
     getPlatform(platform);

     /**Step 2:Query the platform and choose the first GPU device if has one.*/
     cl_device_id *devices=getCl_device_id(platform);

     /**Step 3: Create context.*/
     cl_context context = clCreateContext(NULL,, devices,NULL,NULL,NULL);

     /**Step 4: Creating command queue associate with the context.*/
     cl_command_queue commandQueue = clCreateCommandQueue(context, devices[], , NULL);

     /**Step 5: Create program object */
     const char *filename = "Own_Reduction_Kernels.cl";
     string sourceStr;
     status = convertToString(filename, sourceStr);
     const char *source = sourceStr.c_str();
     size_t sourceSize[] = {strlen(source)};
     cl_program program = clCreateProgramWithSource(context, , &source, sourceSize, NULL);

     /**Step 6: Build program. */
     status=clBuildProgram(program, ,devices,NULL,NULL,NULL);

     /**Step 7: Initial input,output for the host and create memory objects for the kernel*/
     int NUM=;    //6400*4
     size_t global_work_size[] = {};  ///
     size_t local_work_size[]={};    ///256 PE
     size_t groupNUM=global_work_size[]/local_work_size[];
     int* input = new int[NUM];
     for(int i=;i<NUM;i++)
         input[i]=i+;
     int* output = new int[(global_work_size[]/local_work_size[])*];

     cl_mem inputBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR, (NUM) * sizeof(int),(void *) input, NULL);
     cl_mem outputBuffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY , groupNUM** sizeof(int), NULL, NULL);

     /**Step 8: Create kernel object */
     cl_kernel kernel = clCreateKernel(program,"reduce", NULL);

     /**Step 9: Sets Kernel arguments.*/
     status = clSetKernelArg(kernel, , sizeof(cl_mem), (void *)&inputBuffer);
     status = clSetKernelArg(kernel, , sizeof(cl_mem), (void *)&outputBuffer);
     status = clSetKernelArg(kernel, , sizeof(int), &NUM);

     /**Step 10: Running the kernel.*/
     cl_event enentPoint;
     status = clEnqueueNDRangeKernel(commandQueue, kernel, , NULL, global_work_size, local_work_size, , NULL, &enentPoint);
     clWaitForEvents(,&enentPoint); ///wait
     clReleaseEvent(enentPoint);
     isStatusOK(status);

     /**Step 11: Read the cout put back to host memory.*/
     status = clEnqueueReadBuffer(commandQueue, outputBuffer, CL_TRUE, ,groupNUM* * sizeof(int), output, , NULL, NULL);
     isStatusOK(status);
     if(isVerify(NUM, groupNUM ,output) == )
         cout<<"The result is right!!!"<<endl;
     else
         cout<<"The result is wrong!!!"<<endl;

     /**Step 12: Clean the resources.*/
     status = clReleaseKernel(kernel);//*Release kernel.
     status = clReleaseProgram(program);    //Release the program object.
     status = clReleaseMemObject(inputBuffer);//Release mem object.
     status = clReleaseMemObject(outputBuffer);
     status = clReleaseCommandQueue(commandQueue);//Release  Command queue.
     status = clReleaseContext(context);//Release context.

     free(input);
     free(output);
     free(devices);
     return ;
 }