Executing OpenCL kernel and OpenGL compute shader in the same program

[Dark_Photon]

@hterrolle

I was wondering if running OpenCL Kernel and OpenGL Compute shader would not cause any problem [accessing] the GPU. …

Or it may have some problem in case or Kernel instruction and OpenGL instruction could be superposed. …

So at some time it may be possible that Kernel instruction and OpenGL instruction could be interlaced … And that is this case make some problem. Or will i need to do some flush after each kernel instruction and OpenGL instruction.

Sorry for my english. But i hope the question is anderstandable ;))

I think I understand you.

To interleave (interlace, entrelacer, etc.), you’re going to want to look at what OpenGL / OpenCL interop synchronization that your target GPUs/GPU drivers support.

Method #1: The absolute most inefficient method is when the drivers don’t support any efficient synchronization and you basically have to flush all of the work out of the GPU pipeline (via clFinish() / glFinish()) before you can flip to queuing commands with the other API.

To use the GPU more efficiently, you do not want to have to do these flushes. In fact, many modern GPUs support parallel graphics and compute queues on the GPU, and this sledgehammer approach to synchronization I believe precludes use of this capability.

Method #2: A more efficient alternative to this is to use pipeline events to synchronize work between CL and GL via:

• ARB_cl_event, and
• cl_khr_gl_event

So check and see if the GPU driver(s) you’re targeting support these event sharing extensions in both their OpenCL and OpenGL implementations.

---

Years ago when I was first trying to interleave OpenCL and OpenGL use of the GPU in a single program, I hit this problem. On NVIDIA GeForce GPUs/drivers, I had to (and would still have to AFAIK!) use the first, ugly sledgehammer flush method (clFinish() / glFinish()) of synchronization. This because NVIDIA did not (and still does not AFAICT) support the above OpenCL/OpenGL event sharing extensions in their drivers for most GeForce GPUs:

Sharing textures with OpenCL (avoiding glFinish/clFinish)

Currently to pass a texture (or renderbuffer) to OpenCL for some fast crunching on the GPU, and to pass the result back to OpenGL, I’m doing: << generate with OpenGL >> glFinish clEnqueueAcquireGLObjects << crunch with OpenCL >> clEnqueueReleaseGLObjects clFinish << process with OpenGL >> Is there a faster method of synchronization than glFinish/clFinish currently supported on NVidia? Is Flush good enough? Any word on when ARB_cl_event will be supported? (Usage example: here on Slide 37) T…

Apparently these extensions are only supported in their drivers for high-end Quadro and Titan GPUs. More confirmation of that here: in the OpenGL Hardware Database (gpuinfo.org) (type in Quadro and GeForce in the first column).

It would seem, NVIDIA really does not want you to use OpenCL in an OpenGL program on their consumer GPUs, providing their proprietary CUDA compute language/libs as an option instead.

As far as OpenGL Compute Shaders, I don’t know whether they (by contrast) are supported efficiently on NVIDIA GeForce GPUs/drivers, or whether NVIDIA has tied one or both of their hands behind their back too. If anyone does know more about this though, I’d love to hear from you!