8 changed files with 13638 additions and 0 deletions
@ -0,0 +1,149 @@ |
|||
#pragma once |
|||
|
|||
#include <cstdio> |
|||
#include <cstdlib> |
|||
#include <iostream> |
|||
#include <fstream> |
|||
#include <sstream> |
|||
|
|||
#include "cl.hpp" |
|||
|
|||
#pragma warning( disable : 4996 ) |
|||
|
|||
void WriteTGA_RGB(const char* filename, unsigned char* data, unsigned int width, unsigned int height) |
|||
{ |
|||
FILE *f = fopen(filename, "wb"); |
|||
if (!f) { |
|||
fprintf(stderr, "Unable to create output TGA image `%s'\n", filename); |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
|
|||
fputc(0x00, f); /* ID Length, 0 => No ID */ |
|||
fputc(0x00, f); /* Color Map Type, 0 => No color map included */ |
|||
fputc(0x02, f); /* Image Type, 2 => Uncompressed, True-color Image */ |
|||
fputc(0x00, f); /* Next five bytes are about the color map entries */ |
|||
fputc(0x00, f); /* 2 bytes Index, 2 bytes length, 1 byte size */ |
|||
fputc(0x00, f); |
|||
fputc(0x00, f); |
|||
fputc(0x00, f); |
|||
fputc(0x00, f); /* X-origin of Image */ |
|||
fputc(0x00, f); |
|||
fputc(0x00, f); /* Y-origin of Image */ |
|||
fputc(0x00, f); |
|||
fputc(width & 0xff, f); /* Image Width */ |
|||
fputc((width >> 8) & 0xff, f); |
|||
fputc(height & 0xff, f); /* Image Height */ |
|||
fputc((height >> 8) & 0xff, f); |
|||
fputc(0x18, f); /* Pixel Depth, 0x18 => 24 Bits */ |
|||
fputc(0x20, f); /* Image Descriptor */ |
|||
|
|||
for (int y = height - 1; y >= 0; y--) { |
|||
for (size_t x = 0; x < width; x++) { |
|||
const size_t i = (y * width + x) * 3; |
|||
fputc(data[i + 2], f); /* write blue */ |
|||
fputc(data[i + 1], f); /* write green */ |
|||
fputc(data[i], f); /* write red */ |
|||
} |
|||
} |
|||
} |
|||
|
|||
std::string FileToString(const std::string& path) { |
|||
std::ifstream file(path, std::ios::in | std::ios::binary); |
|||
if (file) |
|||
{ |
|||
std::ostringstream contents; |
|||
contents << file.rdbuf(); |
|||
file.close(); |
|||
return(contents.str()); |
|||
} |
|||
return std::string(); |
|||
|
|||
} |
|||
|
|||
const char *getErrorString(cl_int error) |
|||
{ |
|||
switch (error) { |
|||
// run-time and JIT compiler errors
|
|||
case 0: return "CL_SUCCESS"; |
|||
case -1: return "CL_DEVICE_NOT_FOUND"; |
|||
case -2: return "CL_DEVICE_NOT_AVAILABLE"; |
|||
case -3: return "CL_COMPILER_NOT_AVAILABLE"; |
|||
case -4: return "CL_MEM_OBJECT_ALLOCATION_FAILURE"; |
|||
case -5: return "CL_OUT_OF_RESOURCES"; |
|||
case -6: return "CL_OUT_OF_HOST_MEMORY"; |
|||
case -7: return "CL_PROFILING_INFO_NOT_AVAILABLE"; |
|||
case -8: return "CL_MEM_COPY_OVERLAP"; |
|||
case -9: return "CL_IMAGE_FORMAT_MISMATCH"; |
|||
case -10: return "CL_IMAGE_FORMAT_NOT_SUPPORTED"; |
|||
case -11: return "CL_BUILD_PROGRAM_FAILURE"; |
|||
case -12: return "CL_MAP_FAILURE"; |
|||
case -13: return "CL_MISALIGNED_SUB_BUFFER_OFFSET"; |
|||
case -14: return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST"; |
|||
case -15: return "CL_COMPILE_PROGRAM_FAILURE"; |
|||
case -16: return "CL_LINKER_NOT_AVAILABLE"; |
|||
case -17: return "CL_LINK_PROGRAM_FAILURE"; |
|||
case -18: return "CL_DEVICE_PARTITION_FAILED"; |
|||
case -19: return "CL_KERNEL_ARG_INFO_NOT_AVAILABLE"; |
|||
|
|||
// compile-time errors
|
|||
case -30: return "CL_INVALID_VALUE"; |
|||
case -31: return "CL_INVALID_DEVICE_TYPE"; |
|||
case -32: return "CL_INVALID_PLATFORM"; |
|||
case -33: return "CL_INVALID_DEVICE"; |
|||
case -34: return "CL_INVALID_CONTEXT"; |
|||
case -35: return "CL_INVALID_QUEUE_PROPERTIES"; |
|||
case -36: return "CL_INVALID_COMMAND_QUEUE"; |
|||
case -37: return "CL_INVALID_HOST_PTR"; |
|||
case -38: return "CL_INVALID_MEM_OBJECT"; |
|||
case -39: return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"; |
|||
case -40: return "CL_INVALID_IMAGE_SIZE"; |
|||
case -41: return "CL_INVALID_SAMPLER"; |
|||
case -42: return "CL_INVALID_BINARY"; |
|||
case -43: return "CL_INVALID_BUILD_OPTIONS"; |
|||
case -44: return "CL_INVALID_PROGRAM"; |
|||
case -45: return "CL_INVALID_PROGRAM_EXECUTABLE"; |
|||
case -46: return "CL_INVALID_KERNEL_NAME"; |
|||
case -47: return "CL_INVALID_KERNEL_DEFINITION"; |
|||
case -48: return "CL_INVALID_KERNEL"; |
|||
case -49: return "CL_INVALID_ARG_INDEX"; |
|||
case -50: return "CL_INVALID_ARG_VALUE"; |
|||
case -51: return "CL_INVALID_ARG_SIZE"; |
|||
case -52: return "CL_INVALID_KERNEL_ARGS"; |
|||
case -53: return "CL_INVALID_WORK_DIMENSION"; |
|||
case -54: return "CL_INVALID_WORK_GROUP_SIZE"; |
|||
case -55: return "CL_INVALID_WORK_ITEM_SIZE"; |
|||
case -56: return "CL_INVALID_GLOBAL_OFFSET"; |
|||
case -57: return "CL_INVALID_EVENT_WAIT_LIST"; |
|||
case -58: return "CL_INVALID_EVENT"; |
|||
case -59: return "CL_INVALID_OPERATION"; |
|||
case -60: return "CL_INVALID_GL_OBJECT"; |
|||
case -61: return "CL_INVALID_BUFFER_SIZE"; |
|||
case -62: return "CL_INVALID_MIP_LEVEL"; |
|||
case -63: return "CL_INVALID_GLOBAL_WORK_SIZE"; |
|||
case -64: return "CL_INVALID_PROPERTY"; |
|||
case -65: return "CL_INVALID_IMAGE_DESCRIPTOR"; |
|||
case -66: return "CL_INVALID_COMPILER_OPTIONS"; |
|||
case -67: return "CL_INVALID_LINKER_OPTIONS"; |
|||
case -68: return "CL_INVALID_DEVICE_PARTITION_COUNT"; |
|||
|
|||
// extension errors
|
|||
case -1000: return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR"; |
|||
case -1001: return "CL_PLATFORM_NOT_FOUND_KHR"; |
|||
case -1002: return "CL_INVALID_D3D10_DEVICE_KHR"; |
|||
case -1003: return "CL_INVALID_D3D10_RESOURCE_KHR"; |
|||
case -1004: return "CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR"; |
|||
case -1005: return "CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR"; |
|||
default: return "Unknown OpenCL error"; |
|||
} |
|||
} |
|||
|
|||
bool CheckCLError(cl_int err) |
|||
{ |
|||
if(err != CL_SUCCESS) |
|||
{ |
|||
std::cout << "OpenCL error: " << getErrorString(err) << std::endl; |
|||
return false; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
@ -0,0 +1,200 @@ |
|||
// 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" |
|||
|
|||
const bool writeOutRandoms = true; |
|||
const size_t randomNumbers = 1024; |
|||
const size_t threadCount = 512; |
|||
|
|||
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, "randomLCG", &err); |
|||
if(!CheckCLError(err)) exit(-1); |
|||
|
|||
// 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_mem randomBufferDev; |
|||
randomBufferDev = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)* threadCount * randomNumbers, NULL, &err); |
|||
if (!CheckCLError(err)) exit(-1); |
|||
cl_mem seedBufferDev; |
|||
seedBufferDev = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float) * threadCount, NULL, &err); |
|||
if (!CheckCLError(err)) exit(-1); |
|||
|
|||
clEnqueueWriteBuffer(queue, seedBufferDev, CL_TRUE, 0, sizeof(float) * threadCount, seedBuffer.data(), 0, NULL, NULL); |
|||
|
|||
// Set the kernel paramateres
|
|||
clSetKernelArg(kernel, 0, sizeof(int), &randomNumbers); |
|||
clSetKernelArg(kernel, 1, sizeof(cl_mem), &seedBufferDev); |
|||
clSetKernelArg(kernel, 2, sizeof(cl_mem), &randomBufferDev); |
|||
// Enqueue the kernel: threadCount threads in total, each generating randomNumbers random numbers in [0,1]
|
|||
clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &threadCount, NULL, 0, NULL, NULL); |
|||
// Copy the result back to the host
|
|||
clEnqueueReadBuffer(queue, randomBufferDev, CL_TRUE, 0, sizeof(float) * threadCount * randomNumbers, randomBuffer.data(), 0, NULL, NULL); |
|||
|
|||
// Write out the output
|
|||
if(writeOutRandoms == true) |
|||
{ |
|||
std::ofstream ofs("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 << std::endl; |
|||
} |
|||
ofs.close(); |
|||
} |
|||
|
|||
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); |
|||
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() |
|||
{ |
|||
capi(); |
|||
cppapi(); |
|||
return 0; |
|||
} |
|||
|
|||
@ -0,0 +1,87 @@ |
|||
<?xml version="1.0" encoding="utf-8"?> |
|||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|||
<ItemGroup Label="ProjectConfigurations"> |
|||
<ProjectConfiguration Include="Debug|Win32"> |
|||
<Configuration>Debug</Configuration> |
|||
<Platform>Win32</Platform> |
|||
</ProjectConfiguration> |
|||
<ProjectConfiguration Include="Release|Win32"> |
|||
<Configuration>Release</Configuration> |
|||
<Platform>Win32</Platform> |
|||
</ProjectConfiguration> |
|||
</ItemGroup> |
|||
<PropertyGroup Label="Globals"> |
|||
<ProjectGuid>{4B53AC9F-C842-4E17-93EB-1362CFD08104}</ProjectGuid> |
|||
<RootNamespace>MonteCarlo</RootNamespace> |
|||
<WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion> |
|||
</PropertyGroup> |
|||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration"> |
|||
<ConfigurationType>Application</ConfigurationType> |
|||
<UseDebugLibraries>true</UseDebugLibraries> |
|||
<CharacterSet>MultiByte</CharacterSet> |
|||
<PlatformToolset>v143</PlatformToolset> |
|||
</PropertyGroup> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration"> |
|||
<ConfigurationType>Application</ConfigurationType> |
|||
<UseDebugLibraries>false</UseDebugLibraries> |
|||
<WholeProgramOptimization>true</WholeProgramOptimization> |
|||
<CharacterSet>MultiByte</CharacterSet> |
|||
<PlatformToolset>v100</PlatformToolset> |
|||
</PropertyGroup> |
|||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> |
|||
<ImportGroup Label="ExtensionSettings"> |
|||
</ImportGroup> |
|||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> |
|||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> |
|||
</ImportGroup> |
|||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> |
|||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> |
|||
</ImportGroup> |
|||
<PropertyGroup Label="UserMacros" /> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> |
|||
<OutDir>$(SolutionDir)bin\</OutDir> |
|||
</PropertyGroup> |
|||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> |
|||
<ClCompile> |
|||
<WarningLevel>Level3</WarningLevel> |
|||
<Optimization>Disabled</Optimization> |
|||
<AdditionalIncludeDirectories>$(CUDA_PATH)\include</AdditionalIncludeDirectories> |
|||
</ClCompile> |
|||
<Link> |
|||
<GenerateDebugInformation>true</GenerateDebugInformation> |
|||
<AdditionalLibraryDirectories>$(CUDA_PATH)\lib\Win32\</AdditionalLibraryDirectories> |
|||
<AdditionalDependencies>OpenCL.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies> |
|||
</Link> |
|||
</ItemDefinitionGroup> |
|||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> |
|||
<ClCompile> |
|||
<WarningLevel>Level3</WarningLevel> |
|||
<Optimization>MaxSpeed</Optimization> |
|||
<FunctionLevelLinking>true</FunctionLevelLinking> |
|||
<IntrinsicFunctions>true</IntrinsicFunctions> |
|||
<AdditionalIncludeDirectories>$(CUDA_PATH)\include</AdditionalIncludeDirectories> |
|||
</ClCompile> |
|||
<Link> |
|||
<GenerateDebugInformation>true</GenerateDebugInformation> |
|||
<EnableCOMDATFolding>true</EnableCOMDATFolding> |
|||
<OptimizeReferences>true</OptimizeReferences> |
|||
<AdditionalLibraryDirectories>$(CUDA_PATH)\lib\Win32\</AdditionalLibraryDirectories> |
|||
<AdditionalDependencies>OpenCL.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies> |
|||
</Link> |
|||
</ItemDefinitionGroup> |
|||
<ItemGroup> |
|||
<ClInclude Include="cl.hpp" /> |
|||
<ClInclude Include="Common.h" /> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ClCompile Include="MonteCarlo.cpp" /> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<None Include="..\kernels\mersenneTwister.cl" /> |
|||
<None Include="..\kernels\montecarlo.cl" /> |
|||
</ItemGroup> |
|||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> |
|||
<ImportGroup Label="ExtensionTargets"> |
|||
</ImportGroup> |
|||
</Project> |
|||
@ -0,0 +1,41 @@ |
|||
<?xml version="1.0" encoding="utf-8"?> |
|||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|||
<ItemGroup> |
|||
<Filter Include="Source Files"> |
|||
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier> |
|||
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions> |
|||
</Filter> |
|||
<Filter Include="Header Files"> |
|||
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier> |
|||
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions> |
|||
</Filter> |
|||
<Filter Include="Resource Files"> |
|||
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier> |
|||
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions> |
|||
</Filter> |
|||
<Filter Include="Kernels"> |
|||
<UniqueIdentifier>{fd13ccc5-a98b-4e30-9eba-12f62c7dd566}</UniqueIdentifier> |
|||
</Filter> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ClInclude Include="cl.hpp"> |
|||
<Filter>Header Files</Filter> |
|||
</ClInclude> |
|||
<ClInclude Include="Common.h"> |
|||
<Filter>Header Files</Filter> |
|||
</ClInclude> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ClCompile Include="MonteCarlo.cpp"> |
|||
<Filter>Source Files</Filter> |
|||
</ClCompile> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<None Include="..\kernels\montecarlo.cl"> |
|||
<Filter>Kernels</Filter> |
|||
</None> |
|||
<None Include="..\kernels\mersenneTwister.cl"> |
|||
<Filter>Kernels</Filter> |
|||
</None> |
|||
</ItemGroup> |
|||
</Project> |
|||
File diff suppressed because it is too large
@ -0,0 +1,75 @@ |
|||
/* -*- mode: c++ -*- */ |
|||
|
|||
/* |
|||
|
|||
Some parts are derived from NVIDIA's MersenneTwister SDK example. |
|||
|
|||
*/ |
|||
|
|||
typedef struct{ |
|||
unsigned int matrix_a; |
|||
unsigned int mask_b; |
|||
unsigned int mask_c; |
|||
unsigned int seed; |
|||
} mt_struct_stripped; |
|||
|
|||
#define MT_RNG_COUNT 4096 |
|||
#define MT_MM 9 |
|||
#define MT_NN 19 |
|||
#define MT_WMASK 0xFFFFFFFFU |
|||
#define MT_UMASK 0xFFFFFFFEU |
|||
#define MT_LMASK 0x1U |
|||
#define MT_SHIFT0 12 |
|||
#define MT_SHIFTB 7 |
|||
#define MT_SHIFTC 15 |
|||
#define MT_SHIFT1 18 |
|||
#define PI 3.14159265358979f |
|||
|
|||
__kernel void MersenneTwister(__global float* d_Rand, |
|||
__global mt_struct_stripped* d_MT, |
|||
int nPerRng) |
|||
{ |
|||
int globalID = get_global_id(0); |
|||
|
|||
int iState, iState1, iStateM, iOut; |
|||
unsigned int mti, mti1, mtiM, x; |
|||
unsigned int mt[MT_NN], matrix_a, mask_b, mask_c; |
|||
|
|||
//Load bit-vector Mersenne Twister parameters |
|||
matrix_a = d_MT[globalID].matrix_a; |
|||
mask_b = d_MT[globalID].mask_b; |
|||
mask_c = d_MT[globalID].mask_c; |
|||
|
|||
//Initialize current state |
|||
mt[0] = d_MT[globalID].seed; |
|||
for (iState = 1; iState < MT_NN; iState++) |
|||
mt[iState] = (1812433253U * (mt[iState - 1] ^ (mt[iState - 1] >> 30)) + iState) & MT_WMASK; |
|||
|
|||
iState = 0; |
|||
mti1 = mt[0]; |
|||
for (iOut = 0; iOut < nPerRng; iOut++) { |
|||
iState1 = iState + 1; |
|||
iStateM = iState + MT_MM; |
|||
if(iState1 >= MT_NN) iState1 -= MT_NN; |
|||
if(iStateM >= MT_NN) iStateM -= MT_NN; |
|||
mti = mti1; |
|||
mti1 = mt[iState1]; |
|||
mtiM = mt[iStateM]; |
|||
|
|||
// MT recurrence |
|||
x = (mti & MT_UMASK) | (mti1 & MT_LMASK); |
|||
x = mtiM ^ (x >> 1) ^ ((x & 1) ? matrix_a : 0); |
|||
|
|||
mt[iState] = x; |
|||
iState = iState1; |
|||
|
|||
//Tempering transformation |
|||
x ^= (x >> MT_SHIFT0); |
|||
x ^= (x << MT_SHIFTB) & mask_b; |
|||
x ^= (x << MT_SHIFTC) & mask_c; |
|||
x ^= (x >> MT_SHIFT1); |
|||
|
|||
//Convert to (0, 1] float and write to global memory |
|||
d_Rand[globalID + iOut * MT_RNG_COUNT] = ((float)x + 1.0f) / 4294967296.0f; |
|||
} |
|||
} |
|||
Binary file not shown.
@ -0,0 +1,150 @@ |
|||
/* -*- mode: c++ -*- */ |
|||
|
|||
// Linear Congruential Generator |
|||
uint stepLCG(uint *z, uint A, uint C){ |
|||
return (*z) = (A * (*z) + C); |
|||
} |
|||
|
|||
__kernel |
|||
void randomLCG(const int randomNumbers, __global float* randomsSeed, __global float* randomGPU){ |
|||
int id = get_global_id(0); |
|||
int maxID = get_global_size(0); |
|||
|
|||
uint rng = randomsSeed[id]; |
|||
for(int i=0; i < randomNumbers; ++i){ |
|||
randomGPU[id + i * maxID] = (float)stepLCG(&rng, 1664525, 1013904223UL) / 0xffffffff; |
|||
} |
|||
} |
|||
|
|||
uint stepLFG(uint *z, __global uint *znmk, uint A, uint C){ |
|||
return (*znmk) = (*z) = (A * (*z) + C) + (*znmk); |
|||
} |
|||
|
|||
// Lagged Fibonacci Generator |
|||
__kernel |
|||
void randomLFG(const int randomNumbers, __global float* randomsSeed, const int randomStateSize, __global uint* randomState, __global float* randomGPU){ |
|||
int id = get_global_id(0); |
|||
int maxID = get_global_size(0); |
|||
|
|||
// bootstrap |
|||
uint rng = randomsSeed[id]; |
|||
for(int i=0; i < randomStateSize; ++i){ |
|||
randomState[id + i * maxID] = stepLCG(&rng, 1664525, 1013904223UL); |
|||
} |
|||
|
|||
// Lagged Fibonacci Generator |
|||
int nmkIndex = 0; |
|||
for(int i=0; i < randomNumbers; ++i){ |
|||
randomGPU[id + i * maxID] = (float)stepLFG(&rng, &randomState[nmkIndex], 1664525, 1013904223UL) / 0xffffffff; |
|||
nmkIndex = (nmkIndex + 1) % randomStateSize; |
|||
} |
|||
|
|||
} |
|||
|
|||
// Combined Tausworthe Generator |
|||
uint stepCTG(uint *z, uint S1, uint S2, uint S3, uint M){ |
|||
uint b=((((*z)<<S1)^(*z))>>S2); |
|||
return (*z) = ((((*z)&M)<<S3)^b); |
|||
} |
|||
|
|||
__kernel |
|||
void randomCTG(const int randomNumbers, __global float2* randomsSeed, __global float* randomGPU){ |
|||
int id = get_global_id(0); |
|||
int maxID = get_global_size(0); |
|||
|
|||
uint rng1 = randomsSeed[id].x; |
|||
uint rng2 = randomsSeed[id].y; |
|||
for(int i=0; i < randomNumbers; ++i){ |
|||
randomGPU[id + i * maxID] = (float)(stepCTG(&rng1, 13, 19, 12, 4294967294UL) ^ |
|||
stepCTG(&rng2, 2, 25, 4, 4294967288UL)) / 0xffffffff; |
|||
} |
|||
} |
|||
|
|||
// Hybrid RNG |
|||
float stepHybrid(uint* rng1, uint* rng2, uint* rng3, uint* rng4){ |
|||
return 2.3283064365387e-10 * ( |
|||
stepCTG(rng1, 13, 19, 12, 4294967294UL) ^ |
|||
stepCTG(rng2, 2, 25, 4, 4294967288UL) ^ |
|||
stepCTG(rng3, 3, 11, 17, 4294967280UL) ^ |
|||
stepLCG(rng4,1664525,1013904223UL) |
|||
); |
|||
} |
|||
|
|||
__kernel |
|||
void hybridRNG(const int randomNumbers, __global float* randomsSeed, __global float* randomGPU){ |
|||
int id = get_global_id(0); |
|||
int maxID = get_global_size(0); |
|||
|
|||
uint rng1 = randomsSeed[id * 4 + 0]; |
|||
uint rng2 = randomsSeed[id * 4 + 1]; |
|||
uint rng3 = randomsSeed[id * 4 + 2]; |
|||
uint rng4 = randomsSeed[id * 4 + 3]; |
|||
|
|||
for(int i = 0; i < randomNumbers; ++i){ |
|||
randomGPU[id + i * maxID] = (float)stepHybrid(&rng1, &rng2, &rng3, &rng4); |
|||
} |
|||
} |
|||
|
|||
// Halton sequence |
|||
float stepHalton(float *value, float inv_base){ |
|||
float r = 1.0 - (*value) - 0.0000000001; |
|||
if(inv_base < r) { |
|||
(*value) += inv_base; |
|||
} else { |
|||
float h = inv_base, hh; |
|||
do{ |
|||
hh = h; |
|||
h *= inv_base; |
|||
} while (h >= r); |
|||
(*value) += hh + h - 1.0; |
|||
} |
|||
return (*value); |
|||
} |
|||
|
|||
void seedHalton(ulong i, int base, float* inv_base, float* value){ |
|||
float f = (*inv_base) = 1.0/base; |
|||
(*value) = 0.0; |
|||
while( i > 0){ |
|||
(*value) += f * (float)(i % base); |
|||
i /= base; |
|||
f *= (*inv_base); |
|||
} |
|||
} |
|||
|
|||
__kernel |
|||
void haltonSequence(const int randomNumbers, const int base, __global float* randomGPU){ |
|||
int id = get_global_id(0); |
|||
int maxID = get_global_size(0); |
|||
|
|||
float inv_base = 0.0; |
|||
float rng = 0.0; |
|||
seedHalton(id * randomNumbers, base, &inv_base, &rng); |
|||
|
|||
for(int i=0; i < randomNumbers; ++i){ |
|||
randomGPU[id + i * maxID] = stepHalton(&rng, inv_base); |
|||
} |
|||
} |
|||
|
|||
// 1D uniformity test |
|||
// TODO |
|||
// Generate a quantized histogram |
|||
// randomNums = number of randoms per thread |
|||
// randoms = array of random numbers |
|||
// bucketNum = number of histogram buckets |
|||
// buckets = array of histogram buckets |
|||
__kernel |
|||
void testUniform1D(const int randomNums, __global float* randoms, const int bucketNum, __global int* buckets){ |
|||
|
|||
} |
|||
|
|||
// 1D Monte-Carlo integral |
|||
// TODO |
|||
// Implement a Monte Carlo integrator: sin(x) ; x := [0:PI/2] |
|||
// sampleNumber = number of samples per thread |
|||
// seed = float4 seed array for the random number generator |
|||
// integral = partial integral |
|||
#define M_PIP2 1.57796327f |
|||
__kernel |
|||
void mcInt1D(const int sampleNumber, __global float4* seed, __global float* integral){ |
|||
|
|||
} |
|||
Loading…
Reference in new issue