gpgpu/Linear/Linear.cpp

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

#include <string>
#include <vector>
#include "Common.h"

// OpenCL C API
#include <CL/opencl.h>

// OpenCL C++ API
#include "cl.hpp"

// Gaussian elimination
const int GAn = 4;
const int GAm = 3;

float GA[] = { 2,  1, -1,   8,
			  -3, -1,  2, -11,
			  -2,  1,  2,  -3  };

int GBn = 6;
int GBm = 3;
float GB[] = {  2, -1,  0,  1, 0, 0,
			   -1,  2, -1,  0, 1, 0,
			    0, -1,  2,  0, 0, 1  };


void scalarMV(int n, int m, float* y, const float* A, const float* x, const float* b) {
	for (int i = 0; i<n; ++i) {
		float yi = b[i];
		for (int j = 0; j<m; ++j) {
			yi += A[i * m + j] * x[j];
		}
		y[i] = yi;
	}
}

// Jacobi iteration
const int Jn = 8;
float* Jx[2] = { NULL, NULL };
float* JA = NULL;
float* Jb = NULL;

void generateLinEq()
{
	Jx[0] = new float[Jn];
	Jx[1] = new float[Jn];
	for (int i = 0; i < Jn; ++i) {
		Jx[0][i] = 0.0f;
		Jx[1][i] = 0.0f;
	}

	JA = new float[Jn * Jn];
	for (int i = 0; i < Jn; ++i) {
		for (int j = 0; j < Jn; ++j) {
			float v = 0.0f;
			if (i == j) {
				v = 0.5f;
			}
			JA[i + j * Jn] = v;
		}
	}

	Jb = new float[Jn];
	for (int i = 0; i < Jn; ++i) {
		Jb[i] = 1.0f;
	}
}

void releaseLinEq()
{
	if (Jx[0] == 0) delete[] Jx[0];
	if (Jx[1] == 0) delete[] Jx[1];
	if (JA == 0) delete[] JA;
	if (Jb == 0) delete[] Jb;
}

void capi()
{
	// Get a platform ID
	cl_platform_id platformID;
	clGetPlatformIDs(1, &platformID, NULL);
	
	// Get a device ID
	cl_device_id deviceID;
	clGetDeviceIDs(platformID, CL_DEVICE_TYPE_GPU, 1, &deviceID, NULL);
	
	// Create a context
	cl_context context;
	cl_context_properties contextProperties[] =
	{ CL_CONTEXT_PLATFORM, (cl_context_properties)platformID, 0 };
	context = clCreateContext(contextProperties, 1, &deviceID, NULL, NULL, NULL);
	
	// Create a command queue
	cl_command_queue queue;
	queue = clCreateCommandQueue(context, deviceID, CL_QUEUE_PROFILING_ENABLE, NULL);
	
	// Create an OpenCL program
	std::string source = FileToString("../kernels/programs.cl");
	const char* csource = source.c_str();
	cl_program program = clCreateProgramWithSource(context, 1, &csource, NULL, NULL);
	cl_int err = clBuildProgram(program, 1, &deviceID, NULL, NULL, NULL);
	if (err != CL_SUCCESS)
	{
		cl_uint logLength;
		clGetProgramBuildInfo(program, deviceID, CL_PROGRAM_BUILD_LOG, 0, NULL, &logLength);
		char* log = new char[logLength];
		clGetProgramBuildInfo(program, deviceID, CL_PROGRAM_BUILD_LOG, logLength, log, 0);
		std::cout << log << std::endl;
		delete[] log;
		exit(-1);
	}

	// Get the kernel handle
	cl_kernel kernel = clCreateKernel(program, "gaussian", &err);
	if(!CheckCLError(err)) exit(-1);

	// Allocate and upload the input data
	// ...

	cl_mem inputBuffer;
	inputBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(float) * GAn * GAm, NULL, &err);
	if (!CheckCLError(err)) exit(-1);

	clEnqueueWriteBuffer(queue, inputBuffer, CL_TRUE, 0, sizeof(float) * GAn * GAm, GA, 0, NULL, NULL);

	
	// Set the kernel paramateres
	clSetKernelArg(kernel, 0, sizeof(int), &GAn);
	clSetKernelArg(kernel, 1, sizeof(int), &GAm);
	clSetKernelArg(kernel, 2, sizeof(cl_mem), &inputBuffer);
	// Enqueue the kernel
	size_t workSize = GAm;
	size_t workGroupSize = GAm;
	clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &workSize, &workGroupSize, 0, NULL, NULL);
	
	// Copy the result back to the host
	clEnqueueReadBuffer(queue, inputBuffer, CL_TRUE, 0, sizeof(float) * GAm * GAn, GA, 0, NULL, NULL);

	for (int i = 0; i < GAm; ++i) {
		for (int j = 0; j < GAn; ++j) {
			std::cout << GA[j + i * GAn];
			if (j < GAn - 1) std::cout << ", ";
		}
		std::cout << std::endl;
	}

	clReleaseMemObject(inputBuffer);
	clReleaseKernel(kernel);

	std::cout << "Finished" << std::endl;
}

void cppapi()
{
	cl_int err = CL_SUCCESS;

	// Get a platform ID
	std::vector<cl::Platform> platforms;
	cl::Platform::get(&platforms);
	if (platforms.size() == 0)
	{
		std::cout << "Unable to find suitable platform." << std::endl;
		exit(-1);
	}

	// Create a context
	cl_context_properties properties[] =
	{ CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(), 0 };
	cl::Context context(CL_DEVICE_TYPE_GPU, properties);

	// Enumerate the devices
	std::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();

	// Create the command queue
	cl::Event event;
	cl::CommandQueue queue(context, devices[0], 0, &err);

	// Create the OpenCL program
	std::string programSource = FileToString("../kernels/programs.cl");
	cl::Program program = cl::Program(context, programSource);
	program.build(devices);
	
	// Get the kernel handle
	cl::Kernel kernel(program, "gaussian", &err);
	CheckCLError(err);

	// Allocate and upload the input data
	// ...

	cl::Buffer clInputBuffer = cl::Buffer(context, CL_MEM_READ_ONLY, sizeof(float) * GAn * GAm, NULL, &err);
	queue.enqueueWriteBuffer(clInputBuffer, true, 0, sizeof(float) * GAn * GAm, GA);

	
	// Set the kernel parameters	
	kernel.setArg(0, GAn);
	kernel.setArg(1, GAm);
	kernel.setArg(2, clInputBuffer);

	// Enqueue the kernel
	queue.enqueueNDRangeKernel(kernel,
		cl::NullRange,
		cl::NDRange(GAm, 1),
		cl::NDRange(GAm, 1),
		NULL,
		&event);
	event.wait();

	// Copy result back to host
	queue.enqueueReadBuffer(clInputBuffer, true, 0, sizeof(float) * GAn * GAm, GA);

	// Validate the result
	for (int i = 0; i < GAm; ++i) {
		for (int j = 0; j < GAn; ++j) {
			std::cout << GA[j + i * GAn];
			if (j < GAn - 1) std::cout << ", ";
		}
		std::cout << std::endl;
	}
	
	std::cout << "Finished" << std::endl;
}

int main()
{
	capi();
	cppapi();
    return 0;
}