#include <cl.h>
#include <string.h>
#include <windows.h>
#include <fstream>
#include <string>
#include "profiler.h"
#pragma comment (lib, "opencl.lib")

size_t var_size = 0x4000000;
int mem_size = sizeof(float)*var_size;

float *outH1 = new float[var_size];
float *outH2 = new float[var_size];
float *outH3 = new float[var_size];

cl_kernel kernel;
cl_command_queue queue;

cl_mem buf1;
cl_mem buf2;
cl_mem buf3;

void openClFunc();
void cpuFunc();

int main(int argc, char *argv[])
{
	const int platforms = 0xff;
	cl_int error;
	cl_uint num_platforms;
	cl_platform_id platform[platforms];
	error = clGetPlatformIDs(platforms, platform, &num_platforms);

	const int devices = 0xff;
	cl_uint num_devices;
	cl_device_id device[devices];

	clGetDeviceIDs(platform[0], CL_DEVICE_TYPE_GPU, devices, device, &num_devices);

	cl_context_properties cprops[3] = {CL_CONTEXT_PLATFORM, (cl_context_properties)platform[0], 0};

	cl_context context = clCreateContext(cprops, 1, &device[0], 0, 0, &error);

	for(int i=0; i<var_size; i++)
	{
		outH1[i] = 1;
		outH2[i] = 2;
	}	

	buf1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, mem_size, outH1, &error);
	buf2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, mem_size, outH2, &error);
	buf3 = clCreateBuffer(context, CL_MEM_WRITE_ONLY, mem_size, 0, &error);
	
	queue = clCreateCommandQueue(context, device[0], 0, &error);

	std::ifstream ifs = std::ifstream("VectorAdd.cl");
	bool bopen = ifs.is_open();
	ifs.seekg(0, std::ios::end);
	std::ifstream::pos_type filesize = ifs.tellg();
	ifs.seekg(0, std::ios::beg);
	char* progs[1];
	char prog[0xffff];
	progs[0] = prog;
	memset(prog, 0, 0xffff);
	ifs.read(prog, filesize);

	cl_program program = clCreateProgramWithSource(context, 1, (const char**)progs,  0, &error);

	char* build_log;
	size_t log_size;

	cl_int res = clBuildProgram(program, 1, device, 0, 0, 0);

	clGetProgramBuildInfo(program, device[0],CL_PROGRAM_BUILD_LOG, 0, 0, &log_size);

	build_log = new char[log_size+1];

	clGetProgramBuildInfo(program, device[0],CL_PROGRAM_BUILD_LOG, log_size, build_log, &log_size);

	OutputDebugString(build_log);

	kernel = clCreateKernel(program, "vector_add_gpu", &error);

	res = clSetKernelArg(kernel, 0, sizeof(cl_mem), &buf1);
	res = clSetKernelArg(kernel, 1, sizeof(cl_mem), &buf2);
	res = clSetKernelArg(kernel, 2, sizeof(cl_mem), &buf3);

	int size = var_size;
	res = clSetKernelArg(kernel, 3, sizeof(cl_int), &size);

	std::cout << "start" << std::endl;
	cpuFunc();
	openClFunc();
}

void openClFunc()
{
	Profile p("openClFunc");
	const size_t local_ws = 1;
	const size_t global_ws = var_size;

	cl_int res1 = clEnqueueNDRangeKernel(queue, kernel, 1, 0, &global_ws, &local_ws, 0, 0, 0);

	//CL_SUCCESS

	// Reading back
	float* check = new float[var_size];
	cl_int res2 = clEnqueueReadBuffer(queue, buf3, CL_TRUE, 0, mem_size, check, 0, NULL, NULL);
}


void cpuFunc()
{
	Profile p("cpuFunc");
	for(int i=0; i<var_size; i++)
	{
		outH3[i] = outH1[i] + outH2[i];
	}
}