void mydisplayfunc() { void *ptr; int count=0; glFinish(); clEnqueueAcquireGLObjects(mycommandqueue,1,&oclvbo,0,0,0); do_kernel(); clEnqueueReleaseGLObjects(mycommandqueue, 1, &oclvbo, 0,0,0); clFinish(mycommandqueue); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glBindBuffer(GL_ARRAY_BUFFER,OGL_VBO); glVertexPointer(4,GL_FLOAT,0,0); glEnableClientState(GL_VERTEX_ARRAY); glBindBuffer(GL_ARRAY_BUFFER,0); glColorPointer(4,GL_FLOAT,0,&host_color); glEnableClientState(GL_COLOR_ARRAY); glDrawArrays(GL_POINTS, 0, NUMBER_OF_PARTICLES); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glutSwapBuffers(); glutPostRedisplay(); writeToPPM(count++); }
//-------------------------------------------------------------- void RayTracingKernel::update() { // Transfer ownership of buffer from GL to CL #ifdef GL_INTEROP // Acquire PBO for OpenCL writing clErr = clEnqueueAcquireGLObjects(commandQ, 1, &pbo_cl, 0, 0, 0); if (!checkOpenClError(clErr, "clEnqueueAcquireGLObjects")) return; #endif clErr = clEnqueueWriteBuffer(commandQ, d_invViewMatrix,CL_FALSE, 0,12*sizeof(float), invViewMatrix, 0, 0, 0); // if (!checkOpenClError(clErr, "clEnqueueWriteBuffer")) return; enqueue(); #ifdef GL_INTEROP // Transfer ownership of buffer back from CL to GL clErr = clEnqueueReleaseGLObjects(commandQ, 1, &pbo_cl, 0, 0, 0); if (!checkOpenClError(clErr, "clEnqueueReleaseGLObjects")) return; #else // Explicit Copy // map the PBO to copy data from the CL buffer via host glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo); // map the buffer object into client's memory GLubyte* ptr = (GLubyte*)glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY_ARB); clErr = clEnqueueReadBuffer(commandQ, pbo_cl, CL_TRUE, 0, sizeof(unsigned int) * width * height, ptr, 0, NULL, NULL); // if (!checkOpenClError(clErr, "clEnqueueReadBuffer")) return; glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB); #endif }
///need to create memory for this ui object too void ui_element::tick() { correct_bounds(*this); int r_id = hologram_manager::get_real_id(ref_id); hologram_manager::acquire(r_id); clEnqueueAcquireGLObjects(cl::cqueue, 1, &g_ui, 0, NULL, NULL); //cl::cqueue.finish(); cl_uint global[2] = {(cl_uint)w, (cl_uint)h}; cl_uint local[2] = {16, 8}; cl_float2 offset = {finish.x - w/2.0f, finish.y - h/2.0f}; compute::buffer coords = compute::buffer(cl::context, sizeof(cl_float2), CL_MEM_COPY_HOST_PTR, &offset); compute::buffer g_id = compute::buffer(cl::context, sizeof(cl_uint), CL_MEM_COPY_HOST_PTR, &id); arg_list id_arg_list; id_arg_list.push_back(&hologram_manager::g_tex_mem_base[r_id]); id_arg_list.push_back(&hologram_manager::g_tex_mem[r_id]); id_arg_list.push_back(&g_ui); id_arg_list.push_back(&coords); id_arg_list.push_back(&hologram_manager::g_id_bufs[r_id]); id_arg_list.push_back(&g_id); run_kernel_with_list(cl::blit_with_id, global, local, 2, id_arg_list, true); clEnqueueReleaseGLObjects(cl::cqueue, 1, &g_ui, 0, NULL, NULL); hologram_manager::release(r_id); update_offset(); //time.stop(); }
void execute_kernel() { int err; cl_event kernel_event; /* Complete OpenGL processing */ glFinish(); /* Execute the kernel */ err = clEnqueueAcquireGLObjects(queue, 6, mem_objects, 0, NULL, NULL); if(err < 0) { perror("Couldn't acquire the GL objects"); exit(1); } err = clEnqueueTask(queue, kernel, 0, NULL, &kernel_event); if(err < 0) { perror("Couldn't enqueue the kernel"); exit(1); } err = clWaitForEvents(1, &kernel_event); if(err < 0) { perror("Couldn't enqueue the kernel"); exit(1); } clEnqueueReleaseGLObjects(queue, 6, mem_objects, 0, NULL, NULL); clFinish(queue); clReleaseEvent(kernel_event); }
void CopyArrayFromDevice(cl_command_queue cqCommandQueue, float *host, cl_mem device, cl_mem pboCL, int numBodies, bool bDouble) { cl_int ciErrNum; unsigned int size; if (pboCL) { ciErrNum = clEnqueueAcquireGLObjects(cqCommandQueue, 1, &pboCL, 0, NULL, NULL); oclCheckError(ciErrNum, CL_SUCCESS); } if (bDouble) { size = numBodies * 4 * sizeof(double); double *dHost = (double *)malloc(size); ciErrNum = clEnqueueReadBuffer(cqCommandQueue, device, CL_TRUE, 0, size, dHost, 0, NULL, NULL); for (int i = 0; i < numBodies * 4; i++) { host[i] = (float)(dHost[i]); } free(dHost); } else { size = numBodies * 4 * sizeof(float); ciErrNum = clEnqueueReadBuffer(cqCommandQueue, device, CL_TRUE, 0, size, host, 0, NULL, NULL); } oclCheckError(ciErrNum, CL_SUCCESS); if (pboCL) { ciErrNum = clEnqueueReleaseGLObjects(cqCommandQueue, 1, &pboCL, 0, NULL, NULL); oclCheckError(ciErrNum, CL_SUCCESS); } }
void FDMHeatWidget::updateSystemTexture() { cl_int error; error= clEnqueueAcquireGLObjects(clQueue, 1, &textureMem, 0, 0, 0); if(checkError(error, "clEnqueueAcquireGLObjects")) return; // Work group y NDRange de renderKernel size_t workGroupSize[2] = { 16, 16 }; size_t ndRangeSize[2]; ndRangeSize[0]= roundUp(system->getWidth(), workGroupSize[0]); ndRangeSize[1]= roundUp(system->getHeight(), workGroupSize[1]); bool suspended= system->isSuspended(); if(!suspended) system->suspend(); // Ejecutamos el kernel para renderizar el sistema en una imagen cl_mem systemData= system->getOutputData(); error = clSetKernelArg(renderKernel, 0, sizeof(cl_mem), (void*)&systemData); error |= clSetKernelArg(renderKernel, 1, sizeof(cl_mem), (void*)&textureMem); error |= clSetKernelArg(renderKernel, 2, sizeof(cl_mem), (void*)&paletteMem); error |= clEnqueueNDRangeKernel(clQueue, renderKernel, 2, NULL, ndRangeSize, workGroupSize, 0, NULL, NULL); checkError(error, "FDMHeatWidget::updateSystemTexture: clEnqueueNDRangeKernel"); if(!suspended) system->resume(); error= clEnqueueReleaseGLObjects(clQueue, 1, &textureMem, 0, 0, 0); if (checkError(error, "clEnqueueReleaseGLObjects")) return; }
void vglGlToCl(VglImage* img) { glFlush(); glFinish(); if (img->oclPtr == NULL) { vglClAlloc(img); } if (!vglIsInContext(img, VGL_CL_CONTEXT)) { //printf("==========ACQUIRE: vgl = %p, ocl = %d\n", img, img->oclPtr); cl_int err_cl = clFlush(cl.commandQueue); vglClCheckError(err_cl, (char*) "clFlush"); err_cl = clFinish(cl.commandQueue); vglClCheckError(err_cl, (char*) "clFinish"); err_cl = clEnqueueAcquireGLObjects(cl.commandQueue, 1 , (cl_mem*) &img->oclPtr, 0 , NULL, NULL); vglClCheckError(err_cl, (char*) "clEnqueueAcquireGLObjects"); vglSetContext(img, VGL_CL_CONTEXT); } //printf("Vai sair de %s\n", __FUNCTION__); }
//-------------------------------------------------------------------------------------- // Name: AcquireReleaseVBOs() // Desc: Acquire or release the VBO objects to OpenCL memory objects //-------------------------------------------------------------------------------------- BOOL CClothSimCL::AcquireReleaseVBOs(bool bAcquire) { cl_int errNum = 0; if( bAcquire ) { // Before acquiring, finish any pending OpenGL operations glFinish(); errNum = clEnqueueAcquireGLObjects( m_commandQueue, NUM_VBOS, &m_vboMem[0], 0, NULL, NULL ); if( errNum != CL_SUCCESS ) { FrmLogMessage( "Error acquiring OpenGL VBOs as OpenCL memory objects.\n"); return FALSE; } } else { errNum = clEnqueueReleaseGLObjects( m_commandQueue, NUM_VBOS, &m_vboMem[0], 0, NULL, NULL ); if( errNum != CL_SUCCESS ) { FrmLogMessage( "Error releasing OpenGL VBOs as OpenCL memory objects.\n"); return FALSE; } } return TRUE; }
void run_updates() { static int from = 0; static int t = 0; cl_event wait[1]; clSetKernelArg(mykrn_update,0,sizeof(cl_mem),(void *)&focl[from]); clSetKernelArg(mykrn_update,1,sizeof(cl_mem),(void *)&focl[1-from]); clEnqueueNDRangeKernel(mycq,mykrn_update,2,NULL,ws,lws,0,0,&wait[0]); clWaitForEvents(1,wait); if(t%RENDER_STEPS==0) { glFinish(); clEnqueueAcquireGLObjects(mycq,1,&rbuffer_ocl,0,0,0); clSetKernelArg(mykrn_heights,1,sizeof(cl_mem),(void *)&focl[1-from]); clEnqueueNDRangeKernel(mycq,mykrn_heights,2,NULL,ws,lws,0,0,&wait[0]); clWaitForEvents(1,wait); clEnqueueNDRangeKernel(mycq,mykrn_normals,2,NULL,ws,lws,0,0,&wait[0]); clWaitForEvents(1,wait); clEnqueueNDRangeKernel(mycq,mykrn_colors,2,NULL,ws,lws,0,0,&wait[0]); clWaitForEvents(1,wait); clEnqueueReleaseGLObjects(mycq,1,&rbuffer_ocl,0,0,0); clFinish(mycq); render(); } from = 1-from; t++; usleep(10000); glutPostRedisplay(); }
int create_cl_mem_from_gl_tex(const GLuint gl_tex, cl_mem* mem, size_t cq_i) { CLInfo* clinfo = CLInfo::instance(); if (!clinfo->initialized() || !clinfo->has_command_queue(cq_i)) return -1; cl_int err; *mem = clCreateFromGLTexture2D(clinfo->context, CL_MEM_READ_WRITE, GL_TEXTURE_2D,0, gl_tex,&err); if (error_cl(err, "clCreateFromGLTexture2D")) return 1; err = clEnqueueAcquireGLObjects(clinfo->get_command_queue(cq_i), 1, mem, 0,0,0); if (error_cl(err, "clEnqueueAcquireGLObjects")) return 1; err = clFinish(clinfo->get_command_queue(cq_i)); if (error_cl(err, "clFinish")) return 1; return 0; }
void GLWidget::runKernel() { cl_int error; // block until all gl functions are completed glFinish(); // Le doy a OpenCL el vbo que estaba usando OpenGL para renderizar error = clEnqueueAcquireGLObjects(clQueue, 1, &clvbo, 0, 0, 0); if (checkError(error, "clEnqueueAcquireGLObjects")) { return; } localWorkSize = 1024; globalWorkSize = roundUp(vertexNumber, localWorkSize); error = clEnqueueNDRangeKernel(clQueue, clKernel, 1, NULL, &globalWorkSize, &localWorkSize, 0, 0, 0); if (checkError(error, "clEnqueueNDRangeKernel")) { return; } // unmap buffer object error = clEnqueueReleaseGLObjects(clQueue, 1, &clvbo, 0, 0, 0); if (checkError(error, "clEnqueueReleaseGLObjects")) { return; } clFinish(clQueue); }
sge::opencl::memory_object::scoped_objects::scoped_objects( sge::opencl::command_queue::object &_queue, sge::opencl::memory_object::base_ref_sequence const &_objects) : queue_( _queue ), objects_( _objects ) { FCPPT_ASSERT_PRE( !_objects.empty()); glFinish(); typedef std::vector< cl_mem > mem_vector; mem_vector const impls( fcppt::algorithm::map< mem_vector >( _objects, []( fcppt::reference< sge::opencl::memory_object::base > const _ref ) { return _ref.get().impl(); } ) ); cl_int const error_code{ clEnqueueAcquireGLObjects( _queue.impl(), fcppt::cast::size< cl_uint >( impls.size() ), impls.data(), 0, nullptr, nullptr ) }; sge::opencl::impl::handle_error( error_code, FCPPT_TEXT("clEnqueueAcquireGLObjects") ); }
cl_int OpenCLKernel::bindOpenGLInterOp(){ cl_int err = CL_SUCCESS; if (!mOpenGLInteropArguments.empty()){ // we have to acquire our opengl interop objects first. err = clEnqueueAcquireGLObjects(pOpenCL->getQueue(), mOpenGLInteropArguments.size() , mOpenGLInteropArguments.data(), 0, NULL, NULL); } return err; }
//------------------------------------------------------- coResult simtCommandQueue_cl::pushAcquireSharedObject (simtImage& _image) { const simtImage_cl& image = static_cast<simtImage_cl&>(_image); const cl_mem mem_cl = image.getMem_cl(); const cl_int res_cl = clEnqueueAcquireGLObjects(m_commandQueue_cl, 1, &mem_cl, 0, nullptr, nullptr); coTRY(res_cl == CL_SUCCESS, "clEnqueueAcquireGLObjects("<<_image.getName()<<")"); return coSUCCESS; }
void DarkenManager::postProcess() { cl_int errNum; // activate destination buffer glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, m_src_pbo); //// read data into pbo. note: use BGRA format for optimal performance glReadPixels(0, 0, WINDOW_SIZE_WIDTH, WINDOW_SIZE_HEIGHT, GL_BGRA, GL_UNSIGNED_BYTE, NULL); glFlush(); clEnqueueAcquireGLObjects(m_queue, 1, &m_cl_src_buffer, 0, NULL, NULL); clEnqueueAcquireGLObjects(m_queue, 1, &m_cl_dst_buffer, 0, NULL, NULL); size_t *global_work_offset = NULL; size_t global_work_size[] = {WINDOW_SIZE_WIDTH, WINDOW_SIZE_HEIGHT}; size_t local_work_size[] = {WORKGROUP_DIM_X, WORKGROUP_DIM_Y}; if(1) { errNum=clEnqueueNDRangeKernel(m_queue, m_darken_kernel, 2, global_work_offset, global_work_size, local_work_size, 0, NULL, NULL); ASSERT_CL(errNum); } else { std::vector<unsigned char> tmp(WINDOW_SIZE_HEIGHT*WINDOW_SIZE_WIDTH*4, 0); clEnqueueWriteBuffer(m_queue, m_cl_dst_buffer, CL_TRUE, 0, WINDOW_SIZE_HEIGHT*WINDOW_SIZE_HEIGHT*4, &tmp[0], 0, NULL, NULL); } clEnqueueReleaseGLObjects(m_queue,1, &m_cl_src_buffer, 0, NULL, NULL); clEnqueueReleaseGLObjects(m_queue,1, &m_cl_dst_buffer, 0, NULL, NULL); clFinish(m_queue); glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, m_dst_pbo); glBindTexture(GL_TEXTURE_2D, m_tex); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, WINDOW_SIZE_WIDTH, WINDOW_SIZE_HEIGHT, GL_BGRA, GL_UNSIGNED_BYTE, NULL); ASSERT_GL; }
JNIEXPORT jint JNICALL Java_org_lwjgl_opencl_CL10GL_nclEnqueueAcquireGLObjects(JNIEnv *env, jclass clazz, jlong command_queue, jint num_objects, jlong mem_objects, jint num_events_in_wait_list, jlong event_wait_list, jlong event, jlong function_pointer) { const cl_mem *mem_objects_address = (const cl_mem *)(intptr_t)mem_objects; const cl_event *event_wait_list_address = (const cl_event *)(intptr_t)event_wait_list; cl_event *event_address = (cl_event *)(intptr_t)event; clEnqueueAcquireGLObjectsPROC clEnqueueAcquireGLObjects = (clEnqueueAcquireGLObjectsPROC)((intptr_t)function_pointer); cl_int __result = clEnqueueAcquireGLObjects((cl_command_queue)(intptr_t)command_queue, num_objects, mem_objects_address, num_events_in_wait_list, event_wait_list_address, event_address); return __result; }
void OsdCLGLVertexBuffer::map(cl_command_queue queue) { if (_clMapped) return; // XXX: what if another queue is given? _clQueue = queue; clEnqueueAcquireGLObjects(queue, 1, &_clMemory, 0, 0, 0); _clMapped = true; }
cl_int QHoneycombWidget::computeTexture() { cl_int errNum = 0; size_t tex_globalWorkSize[2] = { imWidth, imHeight }; glFinish(); errNum = clEnqueueAcquireGLObjects(commandQueue, 1, &cl_tex_mem, 0, NULL, NULL); if (m_RunKernel) { int err = 0; err = clSetKernelArg(m_KernelIteration, 0, sizeof(cl_mem), (void*)&m_GPUTabNbPixelByColorInitial); err = clSetKernelArg(m_KernelIteration, 1, sizeof(cl_mem), (void*)&m_GPUTabNbPixelByColor); err = clSetKernelArg(m_KernelIteration, 2, sizeof(cl_mem), (void*)&m_GPUTab2D); err = clSetKernelArg(m_KernelIteration, 3, sizeof(cl_mem), (void*)&m_OutputBuffer); size_t GridSize[2] = { m_NbCell, m_NbCell }; err = clEnqueueNDRangeKernel(commandQueue, m_KernelIteration, 2, 0, GridSize, 0, 0, NULL, NULL); /////////////////////////////////////////////////////////// errNum = clSetKernelArg(m_KernelCopyIntoTexture, 0, sizeof(cl_mem), &cl_tex_mem); errNum = clSetKernelArg(m_KernelCopyIntoTexture, 1, sizeof(cl_int), &imWidth); errNum = clSetKernelArg(m_KernelCopyIntoTexture, 2, sizeof(cl_int), &imHeight); errNum = clSetKernelArg(m_KernelCopyIntoTexture, 3, sizeof(cl_int), &m_OutputBuffer); errNum = clSetKernelArg(m_KernelCopyIntoTexture, 4, sizeof(cl_int), &m_GPUTab2D); errNum = clSetKernelArg(m_KernelCopyIntoTexture, 5, sizeof(cl_mem), &m_GPUTabNbPixelByColor); errNum = clEnqueueNDRangeKernel(commandQueue, m_KernelCopyIntoTexture, 2, NULL, tex_globalWorkSize, 0, NULL, NULL, NULL); if (errNum != CL_SUCCESS) { std::cerr << "Error queuing kernel for execution." << std::endl; } } else { errNum = clSetKernelArg(m_KernelCopyIntoTextureBasic, 0, sizeof(cl_mem), &cl_tex_mem); errNum = clSetKernelArg(m_KernelCopyIntoTextureBasic, 1, sizeof(cl_int), &imWidth); errNum = clSetKernelArg(m_KernelCopyIntoTextureBasic, 2, sizeof(cl_int), &imHeight); errNum = clSetKernelArg(m_KernelCopyIntoTextureBasic, 3, sizeof(cl_int), &m_GPUTab2D); errNum = clEnqueueNDRangeKernel(commandQueue, m_KernelCopyIntoTextureBasic, 2, NULL, tex_globalWorkSize, 0, NULL, NULL, NULL); if (errNum != CL_SUCCESS) { std::cerr << "Error queuing kernel for execution." << std::endl; } } errNum = clEnqueueReleaseGLObjects(commandQueue, 1, &cl_tex_mem, 0, NULL, NULL); clFinish(commandQueue); return 0; }
cl_event CLCommandQueue::enqueueAcquireGLObjects(cl_mem glObject) { int err = 0; cl_event event = 0; err = clEnqueueAcquireGLObjects(*_commands, 1, &glObject, 0, NULL, &event); if (err != 0) { LFATAL("Could not aquire GL object: " << getErrorString(err)); } return event; }
void GL2CL(CLPhysicsDemo& demo, GLInstancingRenderer& render) { BT_PROFILE("simulationLoop"); int VBOsize = demo.m_maxShapeBufferCapacityInBytes+demo.m_numPhysicsInstances*(4+4+4+3)*sizeof(float); cl_int ciErrNum = CL_SUCCESS; if(useInterop) { #ifndef __APPLE__ clBuffer = g_interopBuffer->getCLBUffer(); BT_PROFILE("clEnqueueAcquireGLObjects"); { BT_PROFILE("clEnqueueAcquireGLObjects"); ciErrNum = clEnqueueAcquireGLObjects(g_cqCommandQue, 1, &clBuffer, 0, 0, NULL); clFinish(g_cqCommandQue); } #else assert(0); #endif } else { glBindBuffer(GL_ARRAY_BUFFER, render.getInternalData()->m_vbo); glFlush(); BT_PROFILE("glMapBuffer and clEnqueueWriteBuffer"); blocking= CL_TRUE; hostPtr= (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_READ_WRITE);//GL_WRITE_ONLY if (!clBuffer) { int maxVBOsize = demo.m_maxShapeBufferCapacityInBytes+MAX_CONVEX_BODIES_CL*(4+4+4+3)*sizeof(float); clBuffer = clCreateBuffer(g_cxMainContext, CL_MEM_READ_WRITE,maxVBOsize, 0, &ciErrNum); clFinish(g_cqCommandQue); oclCHECKERROR(ciErrNum, CL_SUCCESS); ciErrNum = clEnqueueWriteBuffer ( g_cqCommandQue, clBuffer, blocking, 0, VBOsize, hostPtr,0,0,0 ); clFinish(g_cqCommandQue); } } gFpIO.m_clObjectsBuffer = clBuffer; gFpIO.m_positionOffset = demo.m_maxShapeBufferCapacityInBytes/4; }
JNIEXPORT jint JNICALL Java_org_lwjgl_opencl_CL10GL_nclEnqueueAcquireGLObjects(JNIEnv *__env, jclass clazz, jlong command_queueAddress, jint num_objects, jlong mem_objectsAddress, jint num_events_in_wait_list, jlong event_wait_listAddress, jlong eventAddress, jlong __functionAddress) { cl_command_queue command_queue = (cl_command_queue)(intptr_t)command_queueAddress; const cl_mem *mem_objects = (const cl_mem *)(intptr_t)mem_objectsAddress; const cl_event *event_wait_list = (const cl_event *)(intptr_t)event_wait_listAddress; cl_event *event = (cl_event *)(intptr_t)eventAddress; clEnqueueAcquireGLObjectsPROC clEnqueueAcquireGLObjects = (clEnqueueAcquireGLObjectsPROC)(intptr_t)__functionAddress; UNUSED_PARAMS(__env, clazz) return (jint)clEnqueueAcquireGLObjects(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event); }
void CLContextWrapper::executeSafeAndSyncronized(BufferId * textureToLock, unsigned int count, std::function<void()> exec) { clEnqueueAcquireGLObjects(_this->commandQueue, count, reinterpret_cast<cl_mem*>(textureToLock), 0, nullptr, nullptr); exec(); clEnqueueReleaseGLObjects(_this->commandQueue, count, reinterpret_cast<cl_mem*>(textureToLock), 0, nullptr, nullptr); clFinish(_this->commandQueue); }
void Animate( ) { cl_int status; double time0, time1; // acquire the vertex buffers from opengl: glutSetWindow( MainWindow ); glFinish( ); status = clEnqueueAcquireGLObjects( CmdQueue, 1, &dPobj, 0, NULL, NULL ); PrintCLError( status, "clEnqueueAcquireGLObjects (1): " ); status = clEnqueueAcquireGLObjects( CmdQueue, 1, &dCobj, 0, NULL, NULL ); PrintCLError( status, "clEnqueueAcquireGLObjects (2): " ); if( ShowPerformance ) time0 = omp_get_wtime( ); // 11. enqueue the Kernel object for execution: cl_event wait; status = clEnqueueNDRangeKernel( CmdQueue, Kernel, 1, NULL, GlobalWorkSize, LocalWorkSize, 0, NULL, &wait ); PrintCLError( status, "clEnqueueNDRangeKernel: " ); if( ShowPerformance ) { status = clWaitForEvents( 1, &wait ); PrintCLError( status, "clWaitForEvents: " ); time1 = omp_get_wtime( ); ElapsedTime = time1 - time0; } clFinish( CmdQueue ); status = clEnqueueReleaseGLObjects( CmdQueue, 1, &dCobj, 0, NULL, NULL ); PrintCLError( status, "clEnqueueReleaseGLObjects (2): " ); status = clEnqueueReleaseGLObjects( CmdQueue, 1, &dPobj, 0, NULL, NULL ); PrintCLError( status, "clEnqueueReleaseGLObjects (2): " ); glutSetWindow( MainWindow ); glutPostRedisplay( ); }
void OpenCLWaveSimulation::computeFiniteDifferenceScheme() { if(clEnqueueAcquireGLObjects(m_queue, 1, &m_clNormalInteropBuffer, 0, 0, 0) != CL_SUCCESS) { std::cerr << "Failed to acquire gl normal buffer\n"; } if(clEnqueueAcquireGLObjects(m_queue, 1, &m_clTangentInteropBuffer, 0, 0, 0) != CL_SUCCESS) { std::cerr << "Failed to acquire gl tangent buffer\n"; } if(m_pingpong) { clSetKernelArg(m_finiteDifferenceSchemeKernel, 0, sizeof(cl_mem), (void*)&m_clPong); } else { clSetKernelArg(m_finiteDifferenceSchemeKernel, 0, sizeof(cl_mem), (void*)&m_clPing); } clSetKernelArg(m_finiteDifferenceSchemeKernel, 1, sizeof(cl_mem), (void*)&m_clNormalInteropBuffer); clSetKernelArg(m_finiteDifferenceSchemeKernel, 2, sizeof(cl_mem), (void*)&m_clTangentInteropBuffer); clSetKernelArg(m_finiteDifferenceSchemeKernel, 3, sizeof(int), &m_gridWidth); clSetKernelArg(m_finiteDifferenceSchemeKernel, 4, sizeof(float), m_waves.spatialStep()); if(clEnqueueNDRangeKernel(m_queue, m_finiteDifferenceSchemeKernel, 2, NULL, m_global, NULL, 0, 0, 0) != CL_SUCCESS) { std::cerr << "Finite Difference Scheme Kernel Execution failed\n"; } if(clEnqueueReleaseGLObjects(m_queue, 1, &m_clNormalInteropBuffer, 0, 0, 0) != CL_SUCCESS) { std::cerr << "Failed to release gl normal buffers\n"; } if(clEnqueueReleaseGLObjects(m_queue, 1, &m_clTangentInteropBuffer, 0, 0, 0) != CL_SUCCESS) { std::cerr << "Failed to release gl tangent buffers\n"; } clFinish(m_queue); }
void ocl_acquire(sotl_device_t *dev) { cl_int err; // error code returned from api calls glFinish(); if (dev->compute == SOTL_COMPUTE_OCL) { err = clEnqueueAcquireGLObjects(dev->queue, 1, &vbo_buffer, 0, NULL, NULL); check(err, "Failed to acquire lock"); } }
cl_event CLCommandQueue::enqueueAcquireGLObjects(std::vector<cl_mem> glObjects) { int err = 0; cl_event event = 0; if (glObjects.size() > 0) { err = clEnqueueAcquireGLObjects(*_commands, glObjects.size(), &glObjects[0], 0, NULL, &event); if (err != 0) { LFATAL("Could not aquire GL object: " << getErrorString(err)); } } return event; }
// render image using OpenCL //***************************************************************************** void render() { ciErrNum = CL_SUCCESS; // Transfer ownership of buffer from GL to CL if( g_glInterop ) { // Acquire PBO for OpenCL writing glFlush(); ciErrNum |= clEnqueueAcquireGLObjects(cqCommandQueue, 1, &pbo_cl, 0, 0, 0); //printf("Enqueue acquired GL objects error is %i \n",ciErrNum); } ciErrNum |= clEnqueueWriteBuffer(cqCommandQueue,d_invViewMatrix,CL_FALSE, 0,12*sizeof(float), invViewMatrix, 0, 0, 0); //printf("Write buffer error is %i \n",ciErrNum); // execute OpenCL kernel, writing results to PBO size_t localSize[] = {LOCAL_SIZE_X,LOCAL_SIZE_Y}; ciErrNum |= clSetKernelArg(ckKernel, 3, sizeof(float), &density); ciErrNum |= clSetKernelArg(ckKernel, 4, sizeof(float), &brightness); ciErrNum |= clSetKernelArg(ckKernel, 5, sizeof(float), &transferOffset); ciErrNum |= clSetKernelArg(ckKernel, 6, sizeof(float), &transferScale); ciErrNum |= clEnqueueNDRangeKernel(cqCommandQueue, ckKernel, 2, NULL, gridSize, localSize, 0, 0, 0); //printf("Enqueue ND range kernel error is %i \n",ciErrNum); ////oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup); clFinish( cqCommandQueue ); if( g_glInterop ) { // Transfer ownership of buffer back from CL to GL ciErrNum |= clEnqueueReleaseGLObjects(cqCommandQueue, 1, &pbo_cl, 0, 0, 0); //printf("Release GL object error is %i \n",ciErrNum); ////oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup); clFinish( cqCommandQueue ); } else { // Explicit Copy // map the PBO to copy data from the CL buffer via host glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo); // map the buffer object into client's memory GLubyte* ptr = (GLubyte*)glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY_ARB); clEnqueueReadBuffer(cqCommandQueue, pbo_cl, CL_TRUE, 0, sizeof(unsigned int) * height * width, ptr, 0, NULL, NULL); ////oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup); glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB); } }
/// Enqueues a command to acquire the specified OpenGL memory objects. /// /// \see_opencl_ref{clEnqueueAcquireGLObjects} inline void opengl_enqueue_acquire_gl_objects(size_t num_objects, const cl_mem *mem_objects, command_queue &queue) { cl_int ret = clEnqueueAcquireGLObjects(queue.get(), num_objects, mem_objects, 0, 0, 0); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(runtime_exception(ret)); } }
bool CLGLVertexBuffer::allocate(cl_context clContext) { assert(clContext); // create GL buffer first int size = _numElements * _numVertices * sizeof(float); glGenBuffers(1, &_vbo); #if defined(GL_EXT_direct_state_access) if (glNamedBufferDataEXT) { glNamedBufferDataEXT(_vbo, size, 0, GL_DYNAMIC_DRAW); } else { #else { #endif GLint prev = 0; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &prev); glBindBuffer(GL_ARRAY_BUFFER, _vbo); glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, prev); } // register vbo as cl memory cl_int err; _clMemory = clCreateFromGLBuffer(clContext, CL_MEM_READ_WRITE, _vbo, &err); if (err != CL_SUCCESS) return false; return true; } void CLGLVertexBuffer::map(cl_command_queue queue) { if (_clMapped) return; // XXX: what if another queue is given? _clQueue = queue; clEnqueueAcquireGLObjects(queue, 1, &_clMemory, 0, 0, 0); _clMapped = true; } void CLGLVertexBuffer::unmap() { if (! _clMapped) return; clEnqueueReleaseGLObjects(_clQueue, 1, &_clMemory, 0, 0, 0); _clMapped = false; } } // end namespace Osd
void BounceKernel::Run(float time) { m_success = true; cl_int cl_err; cl_err = clEnqueueAcquireGLObjects(m_system.CommandQueue(), 1, &m_position, 0, NULL, NULL); if (cl_err != CL_SUCCESS) { m_success = false; m_log += "[FAIL] Error acquiring GLObject Position: EC = " + std::to_string(cl_err) + "\n"; return; } cl_err = clSetKernelArg(m_kernel, 0, sizeof(cl_mem), &m_position); if (cl_err != CL_SUCCESS) { m_log += "[FAIL] Error setting kernel argument Position: EC = " + std::to_string(cl_err) + "\n"; m_success = false; } else { //cl_ret = clSetKernelArg(m_cl_kernel, 1, sizeof(cl_mem), &m_cl_time); cl_err = clSetKernelArg(m_kernel, 1, sizeof(float), &time); if (cl_err != CL_SUCCESS) { m_log += "[FAIL] Error setting kernel argument Time: EC = " + std::to_string(cl_err) + "\n"; m_success = false; } else { cl_err = clEnqueueNDRangeKernel(m_system.CommandQueue(), m_kernel, 1, NULL, &m_num_objects, NULL, 0, NULL, NULL); if (cl_err != CL_SUCCESS) { m_log += "[FAIL] Error executing kernel: EC = " + std::to_string(cl_err) + "\n"; m_success = false; } } } cl_err = clEnqueueReleaseGLObjects(m_system.CommandQueue(), 1, &m_position, 0, NULL, NULL); if (cl_err != CL_SUCCESS) { m_success = false; m_log += "[FAIL] Error releasing GLObject Position: EC = " + std::to_string(cl_err) + "\n"; } clFinish(m_system.CommandQueue()); }