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