【异构计算】OpenCL矩阵转置

介绍

矩阵转置，主要的技巧还是利用好local memory ,防止local memory,以及glabol memory的读取尽量是合并读写。

完整代码一：

main.cpp代码

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <time.h>

#ifdef _APPLE_
#include <OpenCL/OpenCL.h>
#else
#include <CL/cl.h>
#endif

#define MATRIXMULLTIPLY

#define N  6
#define K  8
#define L  5

//Functio to check and handle OpenCL errors
inline void checkErr(cl_int err,const char *name)
{
	if(err !=CL_SUCCESS)
	{
		std::cerr <<"ERROR: "<< name <<"("<<err<< ")"<<std::endl;
		exit(EXIT_FAILURE);
	}
}
cl_context CreateContext()
{
    cl_int errNum;
    cl_uint numPlatforms;
    cl_platform_id firstPlatformId;
    cl_context context = NULL;

    // First, select an OpenCL platform to run on.  For this example, we simply choose the first available platform.  Normally, you would
    // query for all available platforms and select the most appropriate one.
    errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
    if (errNum != CL_SUCCESS || numPlatforms <= 0)
    {
        std::cerr << "Failed to find any OpenCL platforms." << std::endl;
        return NULL;
    }

    // Next, create an OpenCL context on the platform.  Attempt to create a GPU-based context, and if that fails, try to create
    // a CPU-based context.
    cl_context_properties contextProperties[] = { CL_CONTEXT_PLATFORM,(cl_context_properties)firstPlatformId, 0 };

	context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,NULL, NULL, &errNum);
    if (errNum != CL_SUCCESS)
    {
        std::cout << "Could not create GPU context, trying CPU..." << std::endl;
        context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,NULL, NULL, &errNum);
        if (errNum != CL_SUCCESS)
        {
            std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
            return NULL;
        }
    }

    return context;
}

int main( int argc, char * argv[])
{
	// Use the first platform
	cl_int errNum;
	cl_platform_id platformID;
	cl_context context =NULL;
	cl_device_id  device;

	errNum = clGetPlatformIDs(1,&platformID,NULL);
	checkErr(errNum,"clGetPlatformIDS");
	std::cout<<"Platform ID: "<<platformID<<std::endl;

	context = CreateContext( );
	if(context == NULL)
	{
		std::cerr << "Failed to create OpenCL context." << std::endl;
        return NULL;
	}

	errNum = clGetDeviceIDs(platformID,CL_DEVICE_TYPE_GPU,1,&device,NULL);

	if(errNum !=CL_SUCCESS)
	{
		std::cerr <<"Could not create CL_DEVICE_TYPE_GPU context, trying CL_DEVICE_TYPE_CPU..."<<std::endl;
		errNum =clGetDeviceIDs(platformID,CL_DEVICE_TYPE_CPU,1,&device,NULL);
		std::cout <<"Device: "<<device<<std::endl;
		if(errNum !=CL_SUCCESS)
		{
			checkErr(errNum,"clGetDeviceIDs(..CL_DEVICE_TYPE_ALL..)");
		}
	}

	cl_command_queue commandQueue = clCreateCommandQueue(context,device,0,&errNum);
	checkErr(errNum,"clCreateCommandQueue( )");

	cl_int Mat_A_width  = N;
	cl_int Mat_A_height = K;
	cl_int Mat_B_width  = K;
	cl_int Mat_B_height = L;

	float *MatA =(float*)malloc(sizeof(float)*Mat_A_width*Mat_A_height);

	if(MatA ==NULL)
	{
		std::cerr<<"Failed to  Allocationing Memmey ."<<std::endl;
	}

#ifdef MATRIXMULLTIPLY
	float *MatB =(float*)malloc(sizeof(float)*Mat_B_width*Mat_B_height);
	float *MatC =(float*)malloc(sizeof(float)*Mat_A_width*Mat_B_height);
#else
	float *MatC =(float*)malloc(sizeof(float)*Mat_A_width*Mat_A_height);
#endif

	std::cout<<"=====MatA: " << Mat_A_width << "X" << Mat_A_height ;//<< std::endl;
	for(int i = 0; i< Mat_A_width*Mat_A_height; i++)
	{
		MatA[i] = std::rand()*0.25;
		//MatA[i] = 4.5;

		if((i%Mat_A_height ==0)||(i == 0))
		{
			std::cout << std::endl;
		}
		std::cout<<MatA[i]<< "\t";
	}
	std::cout<<std::endl;

	//Allocate space for Matrix A on the device
	cl_mem bufferA = clCreateBuffer(context,
									CL_MEM_READ_ONLY,//|CL_MEM_COPY_HOST_PTR,
									Mat_A_width*Mat_A_height*sizeof(float),
									NULL,
									&errNum);
	checkErr(errNum,"clCreateBuffer(...bufferA..)");
	errNum = clEnqueueWriteBuffer(commandQueue,bufferA,CL_TRUE,0,Mat_A_width*Mat_A_height*sizeof(float),(void*)MatA, 0, NULL,NULL);

#ifdef MATRIXMULLTIPLY
	std::cout<<"MatB: "<<Mat_B_width <<"X"<<Mat_B_height<<std::endl;
	for(int i = 0; i< Mat_B_width*Mat_B_height; i++)
	{
		MatB[i] = std::rand()*0.25;
		//MatB[i] = 2.0;
		if((i%Mat_B_height ==0)||(i == 0))
		{
			std::cout << std::endl;
		}
		std::cout<<MatA[i]<< " ";
	}
	std::cout<<std::endl;
    //Allocate space for Matrix B on the device
	cl_mem bufferB = clCreateBuffer(context,
									CL_MEM_READ_ONLY,//|CL_MEM_COPY_HOST_PTR,
									Mat_B_width*Mat_B_height*sizeof(float),
									NULL,
									&errNum);
	checkErr(errNum,"clCreateBuffer(...bufferB..)");

	//Copy Matrix B to the device
	errNum = clEnqueueWriteBuffer(commandQueue,bufferB,CL_TRUE,	0,Mat_B_width*Mat_B_height*sizeof(float),(void*)MatB,0,NULL,NULL);

    //Allocate space for Matrix C on the device
	cl_mem bufferC = clCreateBuffer(context,
									CL_MEM_READ_ONLY,//|CL_MEM_COPY_HOST_PTR,
									Mat_A_width*Mat_B_height*sizeof(float),
									NULL,
									&errNum);
	checkErr(errNum,"clCreateBuffer(...bufferC..)");
#else
	//Allocate space for Matrix C on the device
	cl_mem bufferC = clCreateBuffer(context,
									CL_MEM_READ_ONLY,//|CL_MEM_COPY_HOST_PTR,
									Mat_A_width*Mat_A_height*sizeof(float),
									NULL,
									&errNum);
	checkErr(errNum,"clCreateBuffer(...bufferC..)");
#endif	

    // We assume that the program source si stroed int the variable
	cl_program program;
	const char* fileName = "Matrixkernel.cl";
	std::ifstream kernelFile(fileName,std::ios::in);

	if( !kernelFile.is_open())
	{
		std::cerr <<"Failed to open file reading:"<<fileName<<std::endl;
		return NULL;
	}

	std::ostringstream oss;
	oss << kernelFile.rdbuf();

	std::string srcStdStr = oss.str();
    const char *srcStr = srcStdStr.c_str();
    program = clCreateProgramWithSource(context, 1,(const char**)&srcStr,NULL, NULL);
    if (program == NULL)
    {
        std::cerr << "Failed to create OpenCL program from source." << std::endl;
        return NULL;
    }

    errNum = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
    if (errNum != CL_SUCCESS)
    {
        // Determine the reason for the error
        char buildLog[16384];
        clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,sizeof(buildLog), buildLog, NULL);

        std::cerr << "Error in kernel: " << std::endl;
        std::cerr << buildLog;
        clReleaseProgram(program);
        return NULL;
    }
#ifdef  MATRIXMULLTIPLY
	// Create the kernel
	cl_kernel kernel = clCreateKernel(program,"MulltiplySample",NULL);
	if(kernel ==NULL)
	{
		std::cerr<<"Faile to create kernel."<<std::endl;
		return NULL;
	}

	//set the kernel arguments
	clSetKernelArg(kernel, 0,sizeof(cl_mem), (void*) &bufferC);
	clSetKernelArg(kernel, 1,sizeof(cl_int), (void*) &Mat_A_width);
	clSetKernelArg(kernel, 2,sizeof(cl_int), (void*) &Mat_A_height);
	clSetKernelArg(kernel, 3,sizeof(cl_int), (void*) &Mat_B_width);
	clSetKernelArg(kernel, 4,sizeof(cl_int), (void*) &Mat_B_height);
	clSetKernelArg(kernel, 5,sizeof(cl_mem), (void*) &bufferA);
	clSetKernelArg(kernel, 6,sizeof(cl_mem), (void*) &bufferB);

	//Set Local and global workgroup sizes
	size_t globalws[2]={Mat_A_width,Mat_B_height};
	size_t localws[2]={Mat_A_width,Mat_B_height};

	//float strTime = clock();
	//Execte the kernel
	errNum = clEnqueueNDRangeKernel(commandQueue,kernel,2,NULL,globalws,localws,0,NULL,NULL);
	if(errNum !=CL_SUCCESS)
	{
		std::cerr<<"Faile to Execte the kernal.."<<std::endl;
		return NULL;
	}

	errNum = clEnqueueReadBuffer(commandQueue,bufferC,CL_TRUE,0,Mat_B_height*Mat_A_width*sizeof(float),(void*)MatC,0,NULL,NULL);

	std::cout<<"MatrixC:"<<Mat_A_width<<"X"<<Mat_B_height<<std::endl;
	for(int i =0; i< Mat_A_width*Mat_B_height; i++)
	{
		if((i != 0)&&(i%Mat_B_height == 0))
		{
			std::cout<<std::endl;
		}

		std::cout<<MatC[i]<<"\t";
	}
	std::cout << std::endl;
	clReleaseKernel(kernel);
#else
	cl_kernel Trapsposekernel;
	cl_int blockSize =16;

	if(Mat_A_width*Mat_A_height >1000)
	{
		Trapsposekernel = clCreateKernel(program,"MatrixTranspose",NULL);
		std::cout<<"CreateKernel in MatrixTranspose"<<std::endl;
		if(Trapsposekernel == NULL)
		{
			std::cerr<<"Faile to Create TrapsposeKernel."<< std::endl;
			return NULL;
		}

		clSetKernelArg(Trapsposekernel, 0,sizeof(cl_mem), (void*) &bufferC);
		clSetKernelArg(Trapsposekernel, 1,sizeof(cl_mem), (void*) &bufferA);
		clSetKernelArg(Trapsposekernel, 2,sizeof(cl_float)*blockSize*blockSize,NULL); //
		clSetKernelArg(Trapsposekernel, 3,sizeof(cl_int), (void*) &Mat_A_width);
		clSetKernelArg(Trapsposekernel, 4,sizeof(cl_int), (void*) &Mat_A_height);
		clSetKernelArg(Trapsposekernel, 5,sizeof(cl_mem), (void*) &blockSize);	//
	}

	else
	{
		Trapsposekernel = clCreateKernel(program,"TrapsposeMatrixSample",NULL);
		std::cout<<"CreateKernel in TrapsposeMatrixSample"<<std::endl;

		if(Trapsposekernel == NULL)
		{
			std::cerr<<"Faile to Create TrapsposeKernel."<< std::endl;
			return NULL;
		}

		clSetKernelArg(Trapsposekernel, 0,sizeof(cl_mem), (void*) &bufferC);
		clSetKernelArg(Trapsposekernel, 1,sizeof(cl_int), (void*) &Mat_A_width);
		clSetKernelArg(Trapsposekernel, 2,sizeof(cl_int), (void*) &Mat_A_height);
		clSetKernelArg(Trapsposekernel, 3,sizeof(cl_mem), (void*) &bufferA);
	}

	size_t localtr[2] = {Mat_A_height,Mat_A_width};
#ifdef MATRIXMULLTIPLY
	size_t globaltr[2] = {Mat_A_width,Mat_B_height}
#else
	size_t globaltr[2] = {Mat_A_height,Mat_A_width};
#endif //MATRIXMULLTIPLY
	cl_event  dev;

	//commandQueue the kernel up for executio across the array
	errNum = clEnqueueNDRangeKernel(commandQueue,Trapsposekernel,2,NULL,globaltr,localtr,0,NULL,&dev);
	if(errNum !=CL_SUCCESS)
	{
		std::cerr<<"Faile to Execte the kernel.."<<std::endl;
		return NULL;
	}

	std::cout<<"CommandQueue: "<<commandQueue<<std::endl;
	clFinish(commandQueue);

	cl_ulong startTime, endTime;
	clGetEventProfilingInfo(dev, CL_PROFILING_COMMAND_START,sizeof(cl_ulong), &startTime, NULL);
	clGetEventProfilingInfo(dev, CL_PROFILING_COMMAND_END,	sizeof(cl_ulong), &endTime, NULL);
	cl_ulong kernelExecTimeNs = endTime-startTime;
	printf("simple kernal exec time :%8.6f ms\n", kernelExecTimeNs*1e-6 );

	errNum = clEnqueueReadBuffer(commandQueue,bufferC,CL_TRUE,0,Mat_A_width*Mat_A_height*sizeof(float),(void*)MatC,0,NULL,NULL);

	std::cout<<"====Trapspose MatrixA : "<<Mat_A_height<<"X"<<Mat_A_width<<std::endl;
	for(int i =0; i< Mat_A_width*Mat_A_height; i++)
	{
		if((i != 0)&&(i%Mat_A_width == 0))
		{
			std::cout<<std::endl;
		}

		std::cout<<MatC[i]<<"\t";
	}
	std::cout << std::endl;

#endif

	clReleaseProgram(program);
	clReleaseCommandQueue(commandQueue);
	clReleaseContext(context);

	delete[] MatA;
	//delete[] MatB;
	delete[] MatC;

	return 0;
}

kernel代码

/*
 *@param outputC output Matrix
 *@param widthA is width of intputA in the Matrix A
 *@param heightA is height of intputA in the Matrix A
 *@param widthB is width of intputB in the Matrix B
 *@param heightB is height of intputB in the Matrix B
 *@param inputA is width of intputA in the Matrix A
 *@param inputB is width of intputA in the Matrix B
 */
__kernel void MulltiplySample(__global float* outputC,
						const int widthA,
						const int heightA,
						const int widthB,
						const int heightB,
						__global float* inputA,
						__global float* inputB)
{
	int row = get_global_id(1);	// Get global position in Y direction
	int col = get_global_id(0);	// Get global position in X direction

	float sum = 0.0f;

	//Calculat result of one element of Matrix C
	for( int i = 0; i< widthA; i++)
	{
		sum += inputA[row * widthA+i] * inputB[i * widthB + col];
	}

	outputC[row * widthB+col] = sum;
}

/*
 *@param TrapsposeMatrix  output Matrix
 *@param width  is InputMatrix width
 *@param height  is InputMatrix height
 *@param InputMatrix is Input Matrix
 */
__kernel void TrapsposeMatrixSample(__global float* TrapsposeMatrix,
									const uint width, const uint height,
									__global float* InputMatrix)
{
	int row = get_global_id(0);
	int col = get_global_id(1);

	TrapsposeMatrix[row * width +col] = InputMatrix[col * height + row];
}

/*
 * Copies a block to the local memory
 * and copies back the transpose from local memory to output
 * @param output output matrix
 * @param input  input matrix
 * @param block  local memory of size blockSize x blockSize
 * @param width  width of the input matrix
 * @param height height of the input matrix
 * @param blockSize size of the block
 */

__kernel void MatrixTranspose(__global float * output,
							  __global float * input,
							  __local  float * block,
							  const    uint    width,
							  const    uint    height,
							  const    uint blockSize)
{
	uint globalIdx = get_global_id(0);
	uint globalIdy = get_global_id(1);

	uint localIdx = get_local_id(0);
	uint localIdy = get_local_id(1);

    /* copy from input to local memory */
	block[localIdy*blockSize + localIdx] = input[globalIdy*width + globalIdx];

    /* wait until the whole block is filled */
	barrier(CLK_LOCAL_MEM_FENCE);

	uint groupIdx = get_group_id(0);
	uint groupIdy = get_group_id(1);

    /* calculate the corresponding target location for transpose  by inverting x and y values*/
	uint targetGlobalIdx = groupIdy*blockSize + localIdy;
	uint targetGlobalIdy = groupIdx*blockSize + localIdx;

    /* calculate the corresponding raster indices of source and target */
	uint targetIndex  = targetGlobalIdy*height     + targetGlobalIdx;
	uint sourceIndex  = localIdy       * blockSize + localIdx;

	output[targetIndex] = block[sourceIndex];
}

测试结果输出

完整代码二：

maincpp代码

// Matrix.cpp : Defines the entry point for the console application.

#include "stdafx.h"
#include <CL/cl.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#include <fstream>

using namespace std;
#pragma comment (lib,"OpenCL.lib")

#define M 2048

int convertToString(const char *filename, std::string& s)
{
	size_t size;
	char*  str;

	std::fstream f(filename, (std::fstream::in | std::fstream::binary));
	if(f.is_open())
	{
		size_t fileSize;
		f.seekg(0, std::fstream::end);
		size = fileSize = (size_t)f.tellg();
		f.seekg(0, std::fstream::beg);

		str = new char[size+1];
		if(!str)
		{
			f.close();
			return NULL;
		}

		f.read(str, fileSize);
		f.close();
		str[size] = '\0';

		s = str;
		delete[] str;
		return 0;
	}
	printf("Error: Failed to open file %s\n", filename);
	return 1;
}

int main(int argc, char* argv[])
{
	float *src1=0;
	float *src2=0;

	src1 = (float*)malloc(M*M*sizeof(float));
	src2 = (float*)malloc(M*M*sizeof(float));

	int i, j;
	srand( (unsigned)time( NULL ) );
	for(i = 0; i < M*M; i++)
		src1[i] = rand()%50;

	for( i=0; i < M; i++)
	{
		for(j=0; j < M; j++)
		{
			src2[i*M+j] = src1[j*M+i];
		}
	}

	cl_uint status;
	cl_platform_id platform;

	status = clGetPlatformIDs( 1, &platform, NULL );
	cl_device_id device;

	clGetDeviceIDs( platform, CL_DEVICE_TYPE_ALL,1,	&device,NULL);
	cl_context context = clCreateContext( NULL,	1,&device,NULL, NULL, NULL);
	cl_command_queue queue = clCreateCommandQueue( context,device,
		CL_QUEUE_PROFILING_ENABLE, NULL );

	cl_mem clsrc1 = clCreateBuffer(context,CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		M*M*sizeof(cl_float),src1,NULL );
	cl_mem clsrc2 = clCreateBuffer( context,CL_MEM_WRITE_ONLY,
		M*M * sizeof(cl_float),	NULL, NULL );

	const char * filename  = "transpose.cl";
	std::string  sourceStr;
	status = convertToString(filename, sourceStr);
	const char * source    = sourceStr.c_str();
	size_t sourceSize[]    = { strlen(source) };

	cl_program program = clCreateProgramWithSource(context,	1, &source,sourceSize,NULL);

	status = clBuildProgram( program, 1, &device, NULL, NULL, NULL );
	if(status != 0)
	{
		printf("clBuild failed:%d\n", status);
		char tbuf[0x10000];
		clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0x10000, tbuf, NULL);
		printf("\n%s\n", tbuf);
		return -1;
	}

	cl_kernel kernel = clCreateKernel( program, "matrixTransposeSimple", NULL );
	cl_int dimx = M;
	cl_int dimy = M;

	clSetKernelArg(kernel, 0, sizeof(cl_mem),  (void *)&clsrc2);
    clSetKernelArg(kernel, 1, sizeof(cl_mem),  (void *)&clsrc1);
	clSetKernelArg(kernel, 2, sizeof(cl_int),  (void *)&dimx);
	clSetKernelArg(kernel, 3, sizeof(cl_int),  (void *)&dimy);

	//Set local and global workgroup sizes
	size_t localws[2] = {16, 16} ;
	size_t globalws[2] = {M,M};

    cl_event ev;
	clEnqueueNDRangeKernel( queue ,kernel,2, 0, globalws, localws,0, NULL, &ev);
	clFinish( queue );

	cl_ulong startTime, endTime;
	clGetEventProfilingInfo(ev, CL_PROFILING_COMMAND_START,sizeof(cl_ulong), &startTime, NULL);
	clGetEventProfilingInfo(ev, CL_PROFILING_COMMAND_END,sizeof(cl_ulong), &endTime, NULL);
	cl_ulong kernelExecTimeNs = endTime-startTime;
	printf("simple kernal exec time :%8.6f ms\n ", kernelExecTimeNs*1e-6 );

    float *op_data = 0;
	// copy results from device back to host
	op_data = (cl_float *) clEnqueueMapBuffer(queue,clsrc2,CL_TRUE,	CL_MAP_READ,0,
		M*M*sizeof(cl_float),0, NULL, NULL, NULL );

	for(i = 0; i < M*M; i++)
	{
		if(abs(src2[i] - op_data[i]) > 0.0001)
		{
			printf("check failed\n");
			break;
		}
	}
	if(i == M*M)
		printf("check passed\n");

	cl_uint blockSize = 16;
	kernel = clCreateKernel( program, "matrixTranspose", NULL );

	clSetKernelArg(kernel, 0, sizeof(cl_mem),  (void *)&clsrc2);
	clSetKernelArg(kernel, 1, sizeof(cl_mem),  (void *)&clsrc1);
    clSetKernelArg(kernel, 2, sizeof(cl_float)*blockSize*blockSize, NULL);
	clSetKernelArg(kernel, 3, sizeof(cl_int),  (void *)&dimx);
	clSetKernelArg(kernel, 4, sizeof(cl_int),  (void *)&dimy);
	clSetKernelArg(kernel, 5, sizeof(cl_int),  (void *)&blockSize);

	clEnqueueNDRangeKernel(queue ,kernel,2, 0, globalws, localws,0, NULL, &ev);

	clFinish( queue );
	clGetEventProfilingInfo(ev, CL_PROFILING_COMMAND_START,	sizeof(cl_ulong), &startTime, NULL);
	clGetEventProfilingInfo(ev, CL_PROFILING_COMMAND_END,sizeof(cl_ulong), &endTime, NULL);
	kernelExecTimeNs = endTime-startTime;
	printf("kernal exec time :%8.6f ms\n ", kernelExecTimeNs*1e-6 );

	// copy results from device back to host
	op_data = (cl_float *) clEnqueueMapBuffer( queue,clsrc2,CL_TRUE,CL_MAP_READ,0,
		M*M*sizeof(cl_float),0, NULL, NULL, NULL );

	for(i = 0; i < M*M; i++)
	{
		if(abs(src2[i] - op_data[i]) > 0.0001)
		{
			printf("check failed\n");
			break;
		}
	}
	if(i == M*M)
		printf("check passed\n");

	if(src1)
		free(src1);
	if(src2)
		free(src2);

	clReleaseMemObject(clsrc1);
	clReleaseMemObject(clsrc2);
	clReleaseProgram(program);
	clReleaseCommandQueue(queue);
	clReleaseContext(context);
	return 0;
}

kernel代码

/*
 * Copies a block to the local memory
 * and copies back the transpose from local memory to output
 * @param output output matrix
 * @param input  input matrix
 * @param block  local memory of size blockSize x blockSize
 * @param width  width of the input matrix
 * @param height height of the input matrix
 * @param blockSize size of the block
 */

__kernel
void matrixTranspose(__global float * output,
                     __global float * input,
                     __local  float * block,
                     const    uint    width,
                     const    uint    height,
                     const    uint blockSize
                       )
{
	uint globalIdx = get_global_id(0);
	uint globalIdy = get_global_id(1);

	uint localIdx = get_local_id(0);
	uint localIdy = get_local_id(1);

    /* copy from input to local memory */
	block[localIdy*blockSize + localIdx] = input[globalIdy*width + globalIdx];

    /* wait until the whole block is filled */
	barrier(CLK_LOCAL_MEM_FENCE);

	uint groupIdx = get_group_id(0);
	uint groupIdy = get_group_id(1);

    /* calculate the corresponding target location for transpose  by inverting x and y values*/
	uint targetGlobalIdx = groupIdy*blockSize + localIdy;
	uint targetGlobalIdy = groupIdx*blockSize + localIdx;

    /* calculate the corresponding raster indices of source and target */
	uint targetIndex  = targetGlobalIdy*height     + targetGlobalIdx;
	uint sourceIndex  = localIdy       * blockSize + localIdx;

	output[targetIndex] = block[sourceIndex];
}

__kernel void matrixTransposeSimple(__global float * output,
                     __global float * input,
                     const    uint    width,
                     const    uint    height
                       )
{
	uint gdx = get_global_id(0);
	uint gdy = get_global_id(1);
	output[gdy*width+gdx] = input[gdx*height+gdy] ;
}

测试结果输出

========================================================

转载请注明出处：http://blog.csdn.net/songzitea/article/details/12178619

========================================================