//-----------------------------------------------------------------------------
int main(int argNumber, char **arguments) {
initialization(argNumber, arguments);
getPlatformDevice(&PLATFORM_ID, &DEVICE_ID);
platform = new Platform(PLATFORM_ID);
Context *context = platform->getContext();
Device device = platform->getDevice(DEVICE_ID);
setNDRangeSizes();
std::cout << "Device name: " << device.getName() << "\n";
hostMemoryAlloc();
deviceMemoryAlloc();
std::string kernelFile = KERNEL_DIR + kernelFileName;
Program program(context, std::string(kernelFile.c_str()));
Queue queue(*context, device, Queue::EnableProfiling);
enqueWriteCommands(queue);
if (!program.build(device)) {
std::cout << "Error building the program: "
<< "\n";
std::cout << program.getBuildLog(device) << "\n";
return 1;
}
kernel = program.createKernel(kernelName.c_str());
setKernelArguments();
run(queue);
enqueReadCommands(queue);
verify();
freeMemory();
return 0;
}
/*
* Sequential initialisation (1 kernel)
*/
void SequentialSimulation::initialize(int volumeSide)
{
Simulation::initialize(volumeSide);
fluidKernel = new cl::Kernel(*opencl.program, "fluid");
opencl.checkErr("Kernel::Kernel() (fluid)");
setKernelArguments();
}
void VolumeRaycasterCL::compileKernel() {
if (kernel_) {
removeKernel(kernel_);
}
std::stringstream defines;
if (light_.shadingMode != 0) defines << " -D SHADING_MODE=" << light_.shadingMode;
// Will compile kernel and make sure that it it
// recompiled whenever the file changes
// If the kernel fails to compile it will be set to nullptr
kernel_ = addKernel("volumeraycaster.cl", "raycaster", defines.str());
setKernelArguments();
}
/*
* Parallel initialisation (many kernels)
*/
void ParallelSimulation::initialize(int volumeSide)
{
Simulation::initialize(volumeSide);
diffuseKernel = new cl::Kernel(*opencl.program, "diffuse", &opencl.err);
//diffuseKernelImage3D = new cl::Kernel(*opencl.program, "diffuse_", &opencl.err);
advectKernel = new cl::Kernel(*opencl.program, "advect", &opencl.err);
setBoundKernel = new cl::Kernel(*opencl.program, "setBound", &opencl.err);
addSourceKernel = new cl::Kernel(*opencl.program, "addSource", &opencl.err);
projectKernel1 = new cl::Kernel(*opencl.program, "project1", &opencl.err);
projectKernel2 = new cl::Kernel(*opencl.program, "project2", &opencl.err);
projectKernel3 = new cl::Kernel(*opencl.program, "project3", &opencl.err);
setKernelArguments();
}
static CALresult runIntegral(const AstronomyParameters* ap,
const IntegralArea* ia,
EvaluationState* es,
const CLRequest* clr,
MWCALInfo* ci,
SeparationCALMem* cm)
{
CALresult err;
SeparationCALNames cn;
double t1, t2, dt, tAcc = 0.0;
SeparationCALChunks chunks;
memset(&cn, 0, sizeof(SeparationCALNames));
err = getModuleNames(ci, &cn, cm->numberStreams);
if (err != CAL_RESULT_OK)
{
cal_warn("Failed to get module names", err);
return err;
}
err = setKernelArguments(ci, cm, &cn);
if (err != CAL_RESULT_OK)
{
destroyModuleNames(&cn);
return err;
}
if (findCALChunks(ap, ci, clr, ia, &chunks) != CAL_RESULT_OK)
return CAL_RESULT_ERROR;
for (; es->nu_step < ia->nu_steps; es->nu_step++)
{
if (clr->enableCheckpointing && timeToCheckpointGPU(es, ia))
{
err = checkpointCAL(cm, ia, es);
if (err != CAL_RESULT_OK)
break;
}
t1 = mwGetTimeMilli();
err = runNuStep(ci, cm, ia, &chunks, clr->pollingMode, es->nu_step);
if (err != CAL_RESULT_OK)
break;
t2 = mwGetTimeMilli();
dt = t2 - t1;
tAcc += dt;
reportProgress(ap, ia, es, es->nu_step + 1, dt);
}
es->nu_step = 0;
warn("Integration time = %f s, average per iteration = %f ms\n", 1.0e-3 * tAcc, tAcc / ia->nu_steps);
destroyModuleNames(&cn);
freeCALChunks(&chunks);
if (err == CAL_RESULT_OK)
{
readResults(cm, ia, es);
addTmpSums(es); /* Add final episode to running totals */
}
return err;
}
//Resizes the simulation volume to newN
void Simulation::resize(int newN)
{
int N0 = N;
N = newN;
voxels = (N+2)*(N+2)*(N+2);
size = voxels * sizeof(float);
//Only dens, u, v, w need to be reallocated
float* u_new = new float[voxels];
float* v_new = new float[voxels];
float* w_new = new float[voxels];
float* dens_new = new float[voxels];
memset(u_new, 0, size);
memset(v_new, 0, size);
memset(w_new, 0, size);
memset(dens_new, 0, size);
//New buffer objects
cl::Buffer* buf_u_new = new cl::Buffer(*opencl.context, CL_MEM_USE_HOST_PTR, size, u_new, &opencl.err);
cl::Buffer* buf_v_new = new cl::Buffer(*opencl.context, CL_MEM_USE_HOST_PTR, size, v_new, &opencl.err);
cl::Buffer* buf_w_new = new cl::Buffer(*opencl.context, CL_MEM_USE_HOST_PTR, size, w_new, &opencl.err);
cl::Buffer* buf_dens_new = new cl::Buffer(*opencl.context, CL_MEM_USE_HOST_PTR, size, dens_new, &opencl.err);
/* Image3D:
cl_image_format imageFormat;
imageFormat.image_channel_order = CL_R;
imageFormat.image_channel_data_type = CL_FLOAT;
cl_mem image_dens_new = clCreateImage3D((*opencl.context)(), CL_MEM_READ_ONLY|CL_MEM_USE_HOST_PTR, &imageFormat, N+2, N+2, N+2, 0, 0, dens_new, &opencl.err);
*/
//Resample whole volume (including bounds)
resampleKernel->setArg(0, N + 2);
resampleKernel->setArg(1, N0 + 2);
resampleKernel->setArg(2, *buf_dens_new);
resampleKernel->setArg(3, *buf_dens);
resampleKernel->setArg(4, *buf_u_new);
resampleKernel->setArg(5, *buf_u);
resampleKernel->setArg(6, *buf_v_new);
resampleKernel->setArg(7, *buf_v);
resampleKernel->setArg(8, *buf_w_new);
resampleKernel->setArg(9, *buf_w);
opencl.enqueue(*resampleKernel, cl::NullRange, cl::NDRange(min(N,N0) + 2, min(N,N0) + 2, min(N,N0) + 2), cl::NullRange);
opencl.wait();
deallocateBuffers(); //delete all current buffers
allocateBuffers(false); //allocate only temporary buffers (_prev)
//Assign the non-_prev buffers to resized data
u = u_new;
v = v_new;
w = w_new;
dens = dens_new;
buf_u = buf_u_new;
buf_v = buf_v_new;
buf_w = buf_w_new;
buf_dens = buf_dens_new;
//image_dens = image_dens_new; //Image3D
setKernelArguments(); //N has changed, arguments need to be re-set
}
void VolumeRaycasterCL::notifyObserversKernelCompiled(const cl::Kernel* kernel) {
// Update kernel arguments that are only set once they are changed
setKernelArguments();
// Notify observers
KernelObservable::notifyObserversKernelCompiled(kernel);
}
