gyulaid
/
gpgpu
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity
Browse Source

MonteCarlo

master
Daniel Gyulai 3 years ago
parent
351197c53c
commit
26d9534bf3
8 changed files with 230 additions and 30 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 42
      MonteCarlo/CTG.cpp
  2. 40
      MonteCarlo/Halton.cpp
  3. 40
      MonteCarlo/Hybrid.cpp
  4. 40
      MonteCarlo/LCG.cpp
  5. 40
      MonteCarlo/LFG.cpp
  6. 18
      MonteCarlo/MonteCarlo.cpp
  7. 25
      MonteCarlo/MonteCarloTests.h
  8. 15
      kernels/montecarlo.cl

42
MonteCarlo/CTG.cpp
View File

@ -2,13 +2,16 @@
#include "MonteCarloTests.h"
#include "Common.h"
#include <iostream>
CTG::CTG(size_t _randomNumbers, size_t _threadCount)
CTG::CTG(size_t _randomNumbers, size_t _threadCount, size_t _bucketNum)
{
randomNumbers = _randomNumbers;
threadCount = _threadCount;
bucketNum = _bucketNum;
randomBuffer = std::vector<float>(threadCount * randomNumbers);
seedBuffer = std::vector<float>(threadCount);
histoBuffer = std::vector<int>(bucketNum);
kernel_name = "randomCTG";
for (int i = 0; i < threadCount; ++i)
@ -18,7 +21,8 @@ CTG::CTG(size_t _randomNumbers, size_t _threadCount)
}
void CTG::collect_results(cl::CommandQueue* queue) {
queue->enqueueReadBuffer(clResultBuffer, true, 0, sizeof(float) * threadCount * randomNumbers, randomBuffer.data());
queue->enqueueReadBuffer(clHistoBuffer, true, 0, sizeof(int) * bucketNum, histoBuffer.data());
}
void CTG::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event) {
@ -43,6 +47,22 @@ void CTG::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program
cl::NullRange,
NULL,
Event);
Event->wait();
cl::Kernel kernel_histo = cl::Kernel(*program, "testUniform1D", &err);
CheckCLError(err);
clHistoBuffer = cl::Buffer(*context, CL_MEM_WRITE_ONLY, sizeof(int) * bucketNum, NULL, &err);
kernel_histo.setArg(0, threadCount * randomNumbers);
kernel_histo.setArg(1, clResultBuffer);
kernel_histo.setArg(2, bucketNum);
kernel_histo.setArg(3, clHistoBuffer);
queue->enqueueNDRangeKernel(kernel_histo,
cl::NullRange,
cl::NDRange(threadCount, 1),
cl::NullRange,
NULL,
Event);
}
void CTG::cpu_compute()
@ -51,13 +71,27 @@ void CTG::cpu_compute()
bool CTG::validate_results()
{
std::ofstream ofs("randoms_" + description() + ".txt", std::ofstream::out);
float min = 1000.0;
float max = -1000.0;
std::ofstream ofs(description() + "_randoms.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 << j << "\t" << randomBuffer[i + j * threadCount] << std::endl;
if (randomBuffer[i + j * threadCount] > max) {
max = randomBuffer[i + j * threadCount];
}
if (randomBuffer[i + j * threadCount] < min) {
min = randomBuffer[i + j * threadCount];
}
}
}
ofs.close();
std::ofstream ofsh(description() + "_histo.txt", std::ofstream::out);
for (int i = 0; i < bucketNum; ++i) {
ofsh << i << "\t" << histoBuffer[i] << std::endl;
}
ofsh.close();
std::cout << "CTG: Min: " << min << ", max: " << max << std::endl;
return true;
}

40
MonteCarlo/Halton.cpp
View File

@ -2,18 +2,22 @@
#include "MonteCarloTests.h"
#include "Common.h"
#include <iostream>
Halton::Halton(size_t _randomNumbers, size_t _threadCount, size_t _base) {
Halton::Halton(size_t _randomNumbers, size_t _threadCount, size_t _base, size_t _bucketNum) {
randomNumbers = _randomNumbers;
threadCount = _threadCount;
base = _base;
bucketNum = _bucketNum;
randomBuffer = std::vector<float>(threadCount * randomNumbers);
histoBuffer = std::vector<int>(bucketNum);
kernel_name = "haltonSequence";
}
void Halton::collect_results(cl::CommandQueue* queue)
{
queue->enqueueReadBuffer(clResultBuffer, true, 0, sizeof(float) * threadCount * randomNumbers, randomBuffer.data());
queue->enqueueReadBuffer(clHistoBuffer, true, 0, sizeof(int) * bucketNum, histoBuffer.data());
}
void Halton::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event)
@ -36,6 +40,22 @@ void Halton::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Prog
cl::NullRange,
NULL,
Event);
Event->wait();
cl::Kernel kernel_histo = cl::Kernel(*program, "testUniform1D", &err);
CheckCLError(err);
clHistoBuffer = cl::Buffer(*context, CL_MEM_WRITE_ONLY, sizeof(int) * bucketNum, NULL, &err);
kernel_histo.setArg(0, threadCount * randomNumbers);
kernel_histo.setArg(1, clResultBuffer);
kernel_histo.setArg(2, bucketNum);
kernel_histo.setArg(3, clHistoBuffer);
queue->enqueueNDRangeKernel(kernel_histo,
cl::NullRange,
cl::NDRange(threadCount, 1),
cl::NullRange,
NULL,
Event);
}
void Halton::cpu_compute()
@ -44,13 +64,27 @@ void Halton::cpu_compute()
bool Halton::validate_results()
{
std::ofstream ofs("randoms_" + description() + ".txt", std::ofstream::out);
float min = 1000.0;
float max = -1000.0;
std::ofstream ofs(description() + "_randoms.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 << j << "\t" << randomBuffer[i + j * threadCount] << std::endl;
if (randomBuffer[i + j * threadCount] > max) {
max = randomBuffer[i + j * threadCount];
}
if (randomBuffer[i + j * threadCount] < min) {
min = randomBuffer[i + j * threadCount];
}
}
}
ofs.close();
std::ofstream ofsh(description() + "_histo.txt", std::ofstream::out);
for (int i = 0; i < bucketNum; ++i) {
ofsh << i << "\t" << histoBuffer[i] << std::endl;
}
ofsh.close();
std::cout << "Halton: Min: " << min << ", max: " << max << std::endl;
return true;
}

40
MonteCarlo/Hybrid.cpp
View File

@ -2,13 +2,16 @@
#include "MonteCarloTests.h"
#include "Common.h"
#include <iostream>
Hybrid::Hybrid(size_t _randomNumbers, size_t _threadCount)
Hybrid::Hybrid(size_t _randomNumbers, size_t _threadCount, size_t _bucketNum)
{
randomNumbers = _randomNumbers;
threadCount = _threadCount;
bucketNum = _bucketNum;
randomBuffer = std::vector<float>(threadCount * randomNumbers);
seedBuffer = std::vector<float>(threadCount);
histoBuffer = std::vector<int>(bucketNum);
kernel_name = "hybridRNG";
for (int i = 0; i < threadCount; ++i)
@ -20,6 +23,7 @@ Hybrid::Hybrid(size_t _randomNumbers, size_t _threadCount)
void Hybrid::collect_results(cl::CommandQueue* queue)
{
queue->enqueueReadBuffer(clResultBuffer, true, 0, sizeof(float) * threadCount * randomNumbers, randomBuffer.data());
queue->enqueueReadBuffer(clHistoBuffer, true, 0, sizeof(int) * bucketNum, histoBuffer.data());
}
void Hybrid::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event)
@ -45,6 +49,22 @@ void Hybrid::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Prog
cl::NullRange,
NULL,
Event);
Event->wait();
cl::Kernel kernel_histo = cl::Kernel(*program, "testUniform1D", &err);
CheckCLError(err);
clHistoBuffer = cl::Buffer(*context, CL_MEM_WRITE_ONLY, sizeof(int) * bucketNum, NULL, &err);
kernel_histo.setArg(0, threadCount * randomNumbers);
kernel_histo.setArg(1, clResultBuffer);
kernel_histo.setArg(2, bucketNum);
kernel_histo.setArg(3, clHistoBuffer);
queue->enqueueNDRangeKernel(kernel_histo,
cl::NullRange,
cl::NDRange(threadCount, 1),
cl::NullRange,
NULL,
Event);
}
void Hybrid::cpu_compute()
@ -53,13 +73,27 @@ void Hybrid::cpu_compute()
bool Hybrid::validate_results()
{
std::ofstream ofs("randoms_" + description() + ".txt", std::ofstream::out);
float min = 1000.0;
float max = -1000.0;
std::ofstream ofs(description() + "_randoms.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 << j << "\t" << randomBuffer[i + j * threadCount] << std::endl;
if (randomBuffer[i + j * threadCount] > max) {
max = randomBuffer[i + j * threadCount];
}
if (randomBuffer[i + j * threadCount] < min) {
min = randomBuffer[i + j * threadCount];
}
}
}
ofs.close();
std::ofstream ofsh(description() + "_histo.txt", std::ofstream::out);
for (int i = 0; i < bucketNum; ++i) {
ofsh << i << "\t" << histoBuffer[i] << std::endl;
}
ofsh.close();
std::cout << "Hybrid: Min: " << min << ", max: " << max << std::endl;
return true;
}

40
MonteCarlo/LCG.cpp
View File

@ -2,13 +2,16 @@
#include "MonteCarloTests.h"
#include "Common.h"
#include <iostream>
LCG::LCG(size_t _randomNumbers, size_t _threadCount)
LCG::LCG(size_t _randomNumbers, size_t _threadCount, size_t _bucketNum)
{
randomNumbers = _randomNumbers;
threadCount = _threadCount;
bucketNum = _bucketNum;
randomBuffer = std::vector<float>(threadCount * randomNumbers);
seedBuffer = std::vector<float>(threadCount);
histoBuffer = std::vector<int>(bucketNum);
kernel_name = "randomLCG";
for (int i = 0; i < threadCount; ++i)
@ -20,6 +23,7 @@ LCG::LCG(size_t _randomNumbers, size_t _threadCount)
void LCG::collect_results(cl::CommandQueue* queue)
{
queue->enqueueReadBuffer(clResultBuffer, true, 0, sizeof(float) * threadCount * randomNumbers, randomBuffer.data());
queue->enqueueReadBuffer(clHistoBuffer, true, 0, sizeof(int) * bucketNum, histoBuffer.data());
}
void LCG::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event)
@ -45,6 +49,22 @@ void LCG::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program
cl::NullRange,
NULL,
Event);
Event->wait();
cl::Kernel kernel_histo = cl::Kernel(*program, "testUniform1D", &err);
CheckCLError(err);
clHistoBuffer = cl::Buffer(*context, CL_MEM_WRITE_ONLY, sizeof(int) * bucketNum, NULL, &err);
kernel_histo.setArg(0, threadCount * randomNumbers);
kernel_histo.setArg(1, clResultBuffer);
kernel_histo.setArg(2, bucketNum);
kernel_histo.setArg(3, clHistoBuffer);
queue->enqueueNDRangeKernel(kernel_histo,
cl::NullRange,
cl::NDRange(threadCount, 1),
cl::NullRange,
NULL,
Event);
}
void LCG::cpu_compute()
@ -53,13 +73,27 @@ void LCG::cpu_compute()
bool LCG::validate_results()
{
std::ofstream ofs("randoms_" + description() + ".txt", std::ofstream::out);
float min = 1000.0;
float max = -1000.0;
std::ofstream ofs(description() + "_randoms.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 << j << "\t" << randomBuffer[i + j * threadCount] << std::endl;
if (randomBuffer[i + j * threadCount] > max) {
max = randomBuffer[i + j * threadCount];
}
if (randomBuffer[i + j * threadCount] < min) {
min = randomBuffer[i + j * threadCount];
}
}
}
ofs.close();
std::ofstream ofsh(description() + "_histo.txt", std::ofstream::out);
for (int i = 0; i < bucketNum; ++i) {
ofsh << i << "\t" << histoBuffer[i] << std::endl;
}
ofsh.close();
std::cout << "LCG: Min: " << min << ", max: " << max << std::endl;
return true;
}

40
MonteCarlo/LFG.cpp
View File

@ -2,13 +2,16 @@
#include "MonteCarloTests.h"
#include "Common.h"
#include <iostream>
LFG::LFG(size_t _randomNumbers, size_t _threadCount, size_t _randomStateSize)
LFG::LFG(size_t _randomNumbers, size_t _threadCount, size_t _randomStateSize, size_t _bucketNum)
{
randomNumbers = _randomNumbers;
threadCount = _threadCount;
bucketNum = _bucketNum;
randomBuffer = std::vector<float>(threadCount * randomNumbers);
seedBuffer = std::vector<float>(threadCount);
histoBuffer = std::vector<int>(bucketNum);
kernel_name = "randomLFG";
randomStateSize = _randomStateSize;
@ -21,6 +24,7 @@ LFG::LFG(size_t _randomNumbers, size_t _threadCount, size_t _randomStateSize)
void LFG::collect_results(cl::CommandQueue* queue)
{
queue->enqueueReadBuffer(clResultBuffer, true, 0, sizeof(float) * threadCount * randomNumbers, randomBuffer.data());
queue->enqueueReadBuffer(clHistoBuffer, true, 0, sizeof(int) * bucketNum, histoBuffer.data());
}
void LFG::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event)
@ -49,6 +53,22 @@ void LFG::gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program
cl::NullRange,
NULL,
Event);
Event->wait();
cl::Kernel kernel_histo = cl::Kernel(*program, "testUniform1D", &err);
CheckCLError(err);
clHistoBuffer = cl::Buffer(*context, CL_MEM_WRITE_ONLY, sizeof(int) * bucketNum, NULL, &err);
kernel_histo.setArg(0, threadCount * randomNumbers);
kernel_histo.setArg(1, clResultBuffer);
kernel_histo.setArg(2, bucketNum);
kernel_histo.setArg(3, clHistoBuffer);
queue->enqueueNDRangeKernel(kernel_histo,
cl::NullRange,
cl::NDRange(threadCount, 1),
cl::NullRange,
NULL,
Event);
}
void LFG::cpu_compute()
@ -57,13 +77,27 @@ void LFG::cpu_compute()
bool LFG::validate_results()
{
std::ofstream ofs("randoms_" + description() + ".txt", std::ofstream::out);
float min = 1000.0;
float max = -1000.0;
std::ofstream ofs(description() + "_randoms.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 << j << "\t" << randomBuffer[i + j * threadCount] << std::endl;
if (randomBuffer[i + j * threadCount] > max) {
max = randomBuffer[i + j * threadCount];
}
if (randomBuffer[i + j * threadCount] < min) {
min = randomBuffer[i + j * threadCount];
}
}
}
ofs.close();
std::ofstream ofsh(description() + "_histo.txt", std::ofstream::out);
for (int i = 0; i < bucketNum; ++i) {
ofsh << i << "\t" << histoBuffer[i] << std::endl;
}
ofsh.close();
std::cout << "LFG: Min: " << min << ", max: " << max << std::endl;
return true;
}

18
MonteCarlo/MonteCarlo.cpp
View File

@ -14,9 +14,9 @@
#include <OpenCLHandler.h>
#include "MonteCarloTests.h"
const bool writeOutRandoms = true;
const size_t randomNumbers = 1024;
const size_t threadCount = 512;
const bool writeOutRandoms = false;
const size_t randomNumbers = 512;
const size_t threadCount = 512; // was 512
void cppapi()
{
@ -116,11 +116,13 @@ 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));
size_t bucketNum = 50;
//handler.run_test(new LCG(randomNumbers, threadCount, bucketNum));
//handler.run_test(new LFG(randomNumbers, threadCount, 256, bucketNum));
handler.run_test(new CTG(randomNumbers, threadCount, bucketNum));
//handler.run_test(new Hybrid(randomNumbers, threadCount, bucketNum));
//handler.run_test(new Halton(randomNumbers, threadCount, 2, bucketNum));
return 0;
}

25
MonteCarlo/MonteCarloTests.h
View File

@ -9,8 +9,11 @@ private:
std::vector<float> randomBuffer;
std::vector<float> seedBuffer;
std::string kernel_name;
cl::Buffer clHistoBuffer;
std::vector<int> histoBuffer;
size_t bucketNum;
public:
LCG(size_t _randomNumbers, size_t _threadCount);
LCG(size_t _randomNumbers, size_t _threadCount, size_t _bucketNum);
void collect_results(cl::CommandQueue* queue);
void gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event);
void cpu_compute();
@ -26,8 +29,11 @@ private:
std::vector<float> seedBuffer;
std::string kernel_name;
size_t randomStateSize;
cl::Buffer clHistoBuffer;
size_t bucketNum;
std::vector<int> histoBuffer;
public:
LFG(size_t _randomNumbers, size_t _threadCount, size_t _randomStateSize);
LFG(size_t _randomNumbers, size_t _threadCount, size_t _randomStateSize, size_t _bucketNum);
void collect_results(cl::CommandQueue* queue);
void gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event);
void cpu_compute();
@ -42,8 +48,11 @@ private:
std::vector<float> randomBuffer;
std::vector<float> seedBuffer;
std::string kernel_name;
cl::Buffer clHistoBuffer;
size_t bucketNum;
std::vector<int> histoBuffer;
public:
CTG(size_t _randomNumbers, size_t _threadCount);
CTG(size_t _randomNumbers, size_t _threadCount, size_t _bucketNum);
void collect_results(cl::CommandQueue* queue);
void gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event);
void cpu_compute();
@ -58,8 +67,11 @@ private:
std::vector<float> randomBuffer;
std::vector<float> seedBuffer;
std::string kernel_name;
cl::Buffer clHistoBuffer;
size_t bucketNum;
std::vector<int> histoBuffer;
public:
Hybrid(size_t _randomNumbers, size_t _threadCount);
Hybrid(size_t _randomNumbers, size_t _threadCount, size_t _bucketNum);
void collect_results(cl::CommandQueue* queue);
void gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event);
void cpu_compute();
@ -74,8 +86,11 @@ private:
size_t base;
std::vector<float> randomBuffer;
std::string kernel_name;
cl::Buffer clHistoBuffer;
size_t bucketNum;
std::vector<int> histoBuffer;
public:
Halton(size_t _randomNumbers, size_t _threadCount, size_t _base);
Halton(size_t _randomNumbers, size_t _threadCount, size_t _base, size_t _bucketNum);
void collect_results(cl::CommandQueue* queue);
void gpu_compute(cl::Context* context, cl::CommandQueue* queue, cl::Program* program, cl::Event* Event);
void cpu_compute();

15
kernels/montecarlo.cl
View File

@ -134,7 +134,20 @@ void haltonSequence(const int randomNumbers, const int base, __global float* ran
// buckets = array of histogram buckets
__kernel
void testUniform1D(const int randomNums, __global float* randoms, const int bucketNum, __global int* buckets){
int id = get_global_id(0); // ID
int threadCount = get_global_size(0); // threadCount
float bucketWidth = 1.0 / bucketNum;
int target = 0;
for (size_t i = id; i < randomNums; i += threadCount) {
if (i < randomNums) {
// random numbers are between 0 and 1
target = (int)(randoms[i] / bucketWidth);
atomic_add(&buckets[target], 1);
}
}
}
// 1D Monte-Carlo integral

Write Preview
Loading…
Cancel
Save