gpgpu/MonteCarlo/MonteCarlo.cpp

// MonteCarlo.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"
#include <iostream>
#include <fstream>
#include <OpenCLHandler.h>
#include "MonteCarloTests.h"

const bool writeOutRandoms = true;
const size_t randomNumbers = 1024;
const size_t threadCount = 512;

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/montecarlo.cl");
	cl::Program program = cl::Program(context, programSource);
	err = program.build(devices);
	if (!CheckCLError(err))
	{
		for (size_t devID = 0; devID < devices.size(); ++devID)
		{
			std::cout << "Device: " << devID << std::endl;
			std::cout << "Build Status: " << program.getBuildInfo<CL_PROGRAM_BUILD_STATUS>(devices[devID]) << std::endl;
			std::cout << "Build Options:\t" << program.getBuildInfo<CL_PROGRAM_BUILD_OPTIONS>(devices[devID]) << std::endl;
			std::cout << "Build Log:\t " << program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[devID]) << std::endl;
			std::cout << "--------------------------------------------------" << std::endl;
		}
	}
	

	// Get the kernel handle
	cl::Kernel kernel(program, "randomLCG", &err);
	CheckCLError(err);

	// Allocate memory for random numbers and random seeds
	// Every thread receives a private seed, stored in seedBuffer/clSeedBuffer
	// Every thread is supposed to generate randomNumbers random numbers
	std::vector<float> randomBuffer(threadCount * randomNumbers);
	std::vector<float> seedBuffer(threadCount);
	for (int i = 0; i < threadCount; ++i)
	{
		seedBuffer[i] = rand();
	}
	
	cl::Buffer clSeedBuffer = cl::Buffer(context, CL_MEM_READ_ONLY, sizeof(float) * threadCount, NULL, &err);
	queue.enqueueWriteBuffer(clSeedBuffer, true, 0, sizeof(float) * threadCount, seedBuffer.data());

	cl::Buffer clRandomBuffer = cl::Buffer(context, CL_MEM_WRITE_ONLY, sizeof(float) * threadCount * randomNumbers, NULL, &err);

	// Set the kernel parameters	
	kernel.setArg(0, randomNumbers);
	kernel.setArg(1, clSeedBuffer);
	kernel.setArg(2, clRandomBuffer);

	// Enqueue the kernel: threadCount threads in total, each generating random numbers in [0,1] randomNumbers times
	queue.enqueueNDRangeKernel(kernel,
		cl::NullRange,
		cl::NDRange(threadCount, 1),
		cl::NullRange,
		NULL,
		&event);
	event.wait();

	// Copy result back to host
	queue.enqueueReadBuffer(clRandomBuffer, true, 0, sizeof(float) * threadCount * randomNumbers, randomBuffer.data());

	// Write out the output to file as "index value" rows
	if(writeOutRandoms == true)
	{
		std::ofstream ofs("randoms2.txt", std::ofstream::out);
		for (int i = 0; i < threadCount; ++i) {
			for (int j = 0; j < randomNumbers; ++j) {
				ofs << j << " " << randomBuffer[i + j * threadCount] << std::endl;
			}
		}
		ofs.close();
	}
	
	std::cout << "Finished" << std::endl;
}

int main()
{
	//cppapi();
	OpenCLHandler handler("../kernels/montecarlo.cl");

	//handler.run_test(new LCG(randomNumbers, threadCount));
	//handler.run_test(new LFG(randomNumbers, threadCount, 256));
	//handler.run_test(new CTG(randomNumbers, threadCount));
	//handler.run_test(new Hybrid(randomNumbers, threadCount));
	handler.run_test(new Halton(randomNumbers, threadCount, 2));
	return 0;
}