Make COpenGLSync public, allowing for Interoperation with SDKs also using the OpenGL API

Author: devshgraphicsprogramming

include/nbl/video/COpenGLSync.h

@@ -0,0 +1,73 @@
+#ifndef _NBL_C_OPENGL_SYNC_H_INCLUDED_
+#define _NBL_C_OPENGL_SYNC_H_INCLUDED_
+
+#include "nbl/core/IReferenceCounted.h"
+
+namespace nbl::video
+{
+
+class IOpenGL_LogicalDevice;
+class IOpenGL_FunctionTable;
+
+class COpenGLSync final : public core::IReferenceCounted
+{
+    protected:
+        virtual ~COpenGLSync();
+
+    public:
+        enum E_STATUS : uint32_t
+        {
+            //! Indicates that an error occurred. Additionally, an OpenGL error will be generated.
+            ES_FAIL = 0,
+            //! If it returns GL_TIMEOUT_EXPIRED, then the sync object did not signal within the given timeout period (includes before us calling the func).
+            ES_TIMEOUT_EXPIRED,
+            //! Indicates that sync​ was signaled before the timeout expired.
+            ES_CONDITION_SATISFIED,
+            //! GPU already completed work before we even asked == THIS IS WHAT WE WANT
+            ES_ALREADY_SIGNALED
+        };
+
+        // External GLsync Import constructor. If you leave the `_dev` parameter null, then you're in charge of deleting the `_sync` by yourself.
+        inline COpenGLSync(GLsync _sync, core::smart_refctd_ptr<IOpenGL_LogicalDevice>&& _dev=nullptr)
+            : device(std::move(_dev)), lockedTable(nullptr), haveNotWaitedOnQueueMask(~0ull), cachedRetval(ES_TIMEOUT_EXPIRED), sync(_sync) {}
+
+        //
+        inline GLsync getOpenGLName() const {return sync;}
+
+        // Whether Nabla flushed after placing a fence or not, counting on an implicit flush from waiting on the same context.
+        // You can still wait on the fence with a different context, but it the context it was placed on needs a flush first.
+        inline bool initializedWithImplicitFlush() const {return lockedTable;}
+
+        // whether `init` has been called and there is a valid `sync` to wait for
+        bool isInitialized() const
+        {
+            // (!sync && (cachedRetval == ES_ALREADY_SIGNALED)) means initialized as signaled
+            return static_cast<bool>(sync) || cachedRetval == ES_ALREADY_SIGNALED;
+        }
+
+
+        // for internal Nabla usage
+        void init(core::smart_refctd_ptr<IOpenGL_LogicalDevice>&& _dev, IOpenGL_FunctionTable* _gl, bool _lockToQueue = false);
+        uint64_t prewait() const;
+        E_STATUS waitCPU(IOpenGL_FunctionTable* _gl, uint64_t timeout);
+        void waitGPU(IOpenGL_FunctionTable* _gl);
+        
+        // Empty (waiting to be made pending a signal) not yet initialized sync constructor
+        inline COpenGLSync() : COpenGLSync(nullptr,nullptr) {}
+        // Already signalled constructor (for IGPUFence)
+        struct signalled_t {};
+        constexpr static inline signalled_t signalled = {};
+        inline COpenGLSync(core::smart_refctd_ptr<IOpenGL_LogicalDevice>&& _dev, IOpenGL_FunctionTable* _gl, signalled_t signalled);
+
+    private:
+        core::smart_refctd_ptr<IOpenGL_LogicalDevice> device;
+        IOpenGL_FunctionTable* lockedTable;
+        std::atomic_uint64_t haveNotWaitedOnQueueMask;
+        E_STATUS cachedRetval;
+        // maybe atomic instead of volatile would work better?
+        volatile GLsync sync;
+};
+
+}
+
+#endif

src/nbl/video/COpenGLFence.h

@@ -19,8 +19,7 @@ class COpenGLFence final : public IGPUFence, public IOpenGLSyncPrimitiveBase
         // signaled ctor
         COpenGLFence(core::smart_refctd_ptr<IOpenGL_LogicalDevice>&& dev, IOpenGL_FunctionTable* gl) : IGPUFence(core::smart_refctd_ptr<const ILogicalDevice>(dev), ECF_SIGNALED_BIT)
         {
-            auto sync = core::make_smart_refctd_ptr<COpenGLSync>();
-            sync->initSignaled(dev.get(), gl);
+            auto sync = core::make_smart_refctd_ptr<COpenGLSync>(std::move(dev),gl,COpenGLSync::signalled);
             associateGLSync(std::move(sync));
         }
         // un-signaled ctor

src/nbl/video/COpenGLSync.cpp

@@ -4,11 +4,89 @@
 
 namespace nbl::video
 {
+    
+COpenGLSync::COpenGLSync(core::smart_refctd_ptr<IOpenGL_LogicalDevice>&& _dev, IOpenGL_FunctionTable* _gl, signalled_t signalled)
+    : device(_dev), lockedTable(nullptr), haveNotWaitedOnQueueMask(~(0x1ull<<_gl->getGUID())), cachedRetval(ES_ALREADY_SIGNALED), sync(nullptr)
+{
+}
 
 COpenGLSync::~COpenGLSync()
 {
-    if (sync)
+    if (device && sync)
         device->destroySync(sync);
 }
 
+void COpenGLSync::init(core::smart_refctd_ptr<IOpenGL_LogicalDevice>&& _dev, IOpenGL_FunctionTable* _gl, bool _lockToQueue)
+{
+    device = _dev;
+    sync = _gl->glSync.pglFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+    if (_lockToQueue)
+        lockedTable = _gl;
+    else
+        _gl->glGeneral.pglFlush();
+    haveNotWaitedOnQueueMask ^= (1ull << _gl->getGUID());
+}
+
+uint64_t COpenGLSync::prewait() const
+{
+    if (sync)
+        return 0ull;
+
+    using clock_t = std::chrono::high_resolution_clock;
+    auto start = clock_t::now();
+    while (!sync)
+    { 
+        std::this_thread::yield();
+    }
+
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(clock_t::now() - start).count();
+}
+
+COpenGLSync::E_STATUS COpenGLSync::waitCPU(IOpenGL_FunctionTable* _gl, uint64_t timeout)
+{
+    assert(!lockedTable || lockedTable==_gl);
+    if (cachedRetval != ES_TIMEOUT_EXPIRED)
+        return cachedRetval;
+            
+    const uint64_t spintime = prewait();
+    if (spintime > timeout)
+        return (cachedRetval = ES_TIMEOUT_EXPIRED);
+    timeout -= spintime;
+
+    GLenum status = _gl->glSync.pglClientWaitSync(sync, lockedTable?GL_SYNC_FLUSH_COMMANDS_BIT:0, timeout); // GL_SYNC_FLUSH_COMMANDS_BIT to flags?
+    switch (status)
+    {
+    case GL_ALREADY_SIGNALED:
+        return (cachedRetval = ES_ALREADY_SIGNALED);
+        break;
+    case GL_TIMEOUT_EXPIRED:
+        return (cachedRetval = ES_TIMEOUT_EXPIRED);
+        break;
+    case GL_CONDITION_SATISFIED:;
+        return (cachedRetval = ES_CONDITION_SATISFIED);
+        break;
+    default:
+        break;
+    }
+    return (cachedRetval = ES_FAIL);
+}
+
+void COpenGLSync::waitGPU(IOpenGL_FunctionTable* _gl)
+{
+    if (!lockedTable) // OpenGL device does not need to wait on itself within the same context
+    {
+        const uint64_t queueMask = 1ull << _gl->getGUID();
+        if (haveNotWaitedOnQueueMask.load() & queueMask)
+        {
+            prewait();
+            _gl->glSync.pglWaitSync(sync, 0, GL_TIMEOUT_IGNORED);
+            haveNotWaitedOnQueueMask ^= queueMask;
+        }
+    }
+    else
+    {
+        assert(lockedTable==_gl);
+    }
+}
+
 }

src/nbl/video/COpenGLSync.h

@@ -263,7 +263,7 @@ class COpenGL_Queue final : public IGPUQueue
 
                     if (submit.syncToInit)
                     {
-                        submit.syncToInit->init(m_device, &gl);
+                        submit.syncToInit->init(core::smart_refctd_ptr<IOpenGL_LogicalDevice>(m_device), &gl);
                     }
                     else // need to flush, otherwise OpenGL goes gaslighting the user with wrong error messages
                         gl.glGeneral.pglFlush();

src/nbl/video/COpenGL_Queue.h

@@ -258,7 +258,7 @@ class COpenGL_Swapchain final : public ISwapchain
             for (uint32_t i = 0u; i < fboCount; ++i)
             {
                 syncs[i] = core::make_smart_refctd_ptr<COpenGLSync>();
-                syncs[i]->init(m_device, &gl, false);
+                syncs[i]->init(core::smart_refctd_ptr<IOpenGL_LogicalDevice>(m_device), &gl, false);
             }
 
             gl.glGeneral.pglFinish();
@@ -283,7 +283,7 @@ class COpenGL_Swapchain final : public ISwapchain
 
             gl.extGlBlitNamedFramebuffer(fbos[imgix], 0, 0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
             syncs[imgix] = core::make_smart_refctd_ptr<COpenGLSync>();
-            syncs[imgix]->init(m_device, &gl, false);
+            syncs[imgix]->init(core::smart_refctd_ptr<IOpenGL_LogicalDevice>(m_device), &gl, false);
             // swap buffers performs an implicit flush before swapping 
             // https://www.khronos.org/registry/EGL/sdk/docs/man/html/eglSwapBuffers.xhtml
             egl->call.peglSwapBuffers(egl->display, glctx.surface);