//----------------------------------------------------------------------------- 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); }