feature/ocl: Improve Linux CL/GL sharing support

opencl/source/helpers/gl_helper.h

@@ -21,6 +21,9 @@ class GlFunctionHelper {
     ConvertibleProcAddr operator[](const char *name) {
         return ConvertibleProcAddr{reinterpret_cast<void *>(glFunctionPtr(name))};
     }
+    bool ready() const {
+        return glFunctionPtr != nullptr;
+    }
 
   protected:
     GLFunctionType glFunctionPtr = nullptr;

opencl/source/sharings/gl/linux/CMakeLists.txt

@@ -14,7 +14,6 @@ if(UNIX)
       ${CMAKE_CURRENT_SOURCE_DIR}/gl_arb_sync_event_linux.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/gl_buffer_linux.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/gl_context_guard_linux.cpp
-      ${CMAKE_CURRENT_SOURCE_DIR}/gl_library_linux.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/gl_sharing_linux.h
       ${CMAKE_CURRENT_SOURCE_DIR}/gl_sharing_linux.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/gl_sync_event_linux.cpp

opencl/source/sharings/gl/linux/gl_buffer_linux.cpp

@@ -20,19 +20,72 @@
 
 #include "config.h"
 
+#include <poll.h>
+#include <unistd.h>
+
 using namespace NEO;
 
 Buffer *GlBuffer::createSharedGlBuffer(Context *context, cl_mem_flags flags, unsigned int bufferId, cl_int *errcodeRet) {
     ErrorCodeHelper errorCode(errcodeRet, CL_SUCCESS);
-    CL_GL_BUFFER_INFO bufferInfo = {0};
-    bufferInfo.bufferName = bufferId;
 
+    /* Prepare export request */
+    struct mesa_glinterop_export_in objIn = {};
+    struct mesa_glinterop_export_out objOut = {};
+
+    objIn.version = 2;
+    objIn.target = GL_ARRAY_BUFFER;
+    objIn.obj = bufferId;
+
+    switch (flags) {
+    case CL_MEM_READ_ONLY:
+        objIn.access = MESA_GLINTEROP_ACCESS_READ_ONLY;
+        break;
+    case CL_MEM_WRITE_ONLY:
+        objIn.access = MESA_GLINTEROP_ACCESS_WRITE_ONLY;
+        break;
+    case CL_MEM_READ_WRITE:
+        objIn.access = MESA_GLINTEROP_ACCESS_READ_WRITE;
+        break;
+    default:
+        errorCode.set(CL_INVALID_VALUE);
+        return nullptr;
+    }
+
+    objOut.version = 2;
+
+    /* Call MESA interop */
     GLSharingFunctionsLinux *sharingFunctions = context->getSharing<GLSharingFunctionsLinux>();
-    if (sharingFunctions->acquireSharedBufferINTEL(&bufferInfo) == GL_FALSE) {
-        errorCode.set(CL_INVALID_GL_OBJECT);
+
+    int retValue = sharingFunctions->exportObject(&objIn, &objOut);
+    if ((retValue != MESA_GLINTEROP_SUCCESS) || (objOut.version != 2)) {
+        switch (retValue) {
+        case MESA_GLINTEROP_INVALID_DISPLAY:
+        case MESA_GLINTEROP_INVALID_CONTEXT:
+            errorCode.set(CL_INVALID_CONTEXT);
+            break;
+        case MESA_GLINTEROP_INVALID_OBJECT:
+            errorCode.set(CL_INVALID_GL_OBJECT);
+            break;
+        case MESA_GLINTEROP_OUT_OF_HOST_MEMORY:
+            errorCode.set(CL_OUT_OF_HOST_MEMORY);
+            break;
+        case MESA_GLINTEROP_OUT_OF_RESOURCES:
+        default:
+            errorCode.set(CL_OUT_OF_RESOURCES);
+            break;
+        }
+
         return nullptr;
     }
 
+    /* Map result for rest of the function */
+    CL_GL_BUFFER_INFO bufferInfo = {
+        .bufferName = bufferId,
+        .globalShareHandle = static_cast<unsigned int>(objOut.dmabuf_fd),
+        .bufferSize = static_cast<GLint>(objOut.buf_size),
+        .bufferOffset = static_cast<GLint>(objOut.buf_offset),
+    };
+
     auto graphicsAllocation = GlBuffer::createGraphicsAllocation(context, bufferId, bufferInfo);
     if (!graphicsAllocation) {
         errorCode.set(CL_INVALID_GL_OBJECT);
@@ -50,20 +103,36 @@ Buffer *GlBuffer::createSharedGlBuffer(Context *context, cl_mem_flags flags, uns
 void GlBuffer::synchronizeObject(UpdateData &updateData) {
     auto sharingFunctions = static_cast<GLSharingFunctionsLinux *>(this->sharingFunctions);
 
-    CL_GL_BUFFER_INFO bufferInfo = {};
-    bufferInfo.bufferName = this->clGlObjectId;
-    sharingFunctions->acquireSharedBufferINTEL(&bufferInfo);
+    /* Prepare flush request */
+    struct mesa_glinterop_export_in objIn = {};
+    struct mesa_glinterop_flush_out syncOut = {};
+    int fenceFd = -1;
 
-    auto graphicsAllocation = updateData.memObject->getGraphicsAllocation(updateData.rootDeviceIndex);
+    objIn.version = 2;
+    objIn.target = GL_ARRAY_BUFFER;
+    objIn.obj = this->clGlObjectId;
 
-    updateData.sharedHandle = bufferInfo.globalShareHandle;
-    updateData.synchronizationStatus = SynchronizeStatus::ACQUIRE_SUCCESFUL;
-    graphicsAllocation->setAllocationOffset(bufferInfo.bufferOffset);
+    syncOut.version = 1;
+    syncOut.fence_fd = &fenceFd;
 
-    const auto currentSharedHandle = graphicsAllocation->peekSharedHandle();
-    if (currentSharedHandle != updateData.sharedHandle) {
-        updateData.updateData = new CL_GL_BUFFER_INFO(bufferInfo);
+    /* Call MESA interop */
+    int retValue = sharingFunctions->flushObjects(1, &objIn, &syncOut);
+    if (retValue != MESA_GLINTEROP_SUCCESS) {
+        updateData.synchronizationStatus = SynchronizeStatus::SYNCHRONIZE_ERROR;
+        return;
     }
+
+    /* Wait on the fence fd */
+    struct pollfd fp = {
+        .fd = fenceFd,
+        .events = POLLIN,
+        .revents = 0,
+    };
+    poll(&fp, 1, 1000);
+    close(fenceFd);
+
+    /* Done */
+    updateData.synchronizationStatus = SynchronizeStatus::ACQUIRE_SUCCESFUL;
 }
 
 void GlBuffer::resolveGraphicsAllocationChange(osHandle currentSharedHandle, UpdateData *updateData) {
@@ -153,7 +222,7 @@ GraphicsAllocation *GlBuffer::createGraphicsAllocation(Context *context, unsigne
                                            context->getDeviceBitfieldForAllocation(context->getDevice(0)->getRootDeviceIndex())};
         // couldn't find allocation for reuse - create new
         graphicsAllocation =
-            context->getMemoryManager()->createGraphicsAllocationFromSharedHandle(bufferInfo.globalShareHandle, properties, true, false, false, nullptr);
+            context->getMemoryManager()->createGraphicsAllocationFromSharedHandle(bufferInfo.globalShareHandle, properties, false, false, false, nullptr);
     }
 
     if (!graphicsAllocation) {
@@ -167,15 +236,20 @@ GraphicsAllocation *GlBuffer::createGraphicsAllocation(Context *context, unsigne
             DEBUG_BREAK_IF(graphicsAllocation->getDefaultGmm() != nullptr);
             auto helper = context->getDevice(0)->getRootDeviceEnvironment().getGmmHelper();
             graphicsAllocation->setDefaultGmm(new Gmm(helper, bufferInfo.pGmmResInfo));
+        } else {
+            auto helper = context->getDevice(0)->getRootDeviceEnvironment().getGmmHelper();
+            StorageInfo storageInfo = {};
+            GmmRequirements gmmRequirements{};
+
+            graphicsAllocation->setDefaultGmm(new Gmm(helper,
+                                                      nullptr, bufferInfo.bufferSize, 1, GMM_RESOURCE_USAGE_UNKNOWN, storageInfo, gmmRequirements));
         }
     }
 
     return graphicsAllocation;
 }
 
 void GlBuffer::releaseResource(MemObj *memObject, uint32_t rootDeviceIndex) {
-    auto sharingFunctions = static_cast<GLSharingFunctionsLinux *>(this->sharingFunctions);
-    CL_GL_BUFFER_INFO bufferInfo = {};
-    bufferInfo.bufferName = this->clGlObjectId;
-    sharingFunctions->releaseSharedBufferINTEL(&bufferInfo);
+    auto memoryManager = memObject->getMemoryManager();
+    memoryManager->closeSharedHandle(memObject->getGraphicsAllocation(rootDeviceIndex));
 }

opencl/source/sharings/gl/linux/gl_context_guard_linux.cpp

@@ -10,29 +10,8 @@
 
 namespace NEO {
 GLContextGuard::GLContextGuard(GLSharingFunctions &sharingFcns) : sharingFunctions(&sharingFcns) {
-    auto &sharing = *static_cast<GLSharingFunctionsLinux *>(sharingFunctions);
-
-    currentContextHandle = sharing.getCurrentContext();
-    currentDisplayHandle = sharing.getCurrentDisplay();
-    auto ctxToMakeCurrent = sharing.getContextHandle();
-
-    if (currentContextHandle == 0) {
-        ctxToMakeCurrent = sharing.getBackupContextHandle();
-    }
-
-    if (currentContextHandle != sharing.getContextHandle() && currentContextHandle != sharing.getBackupContextHandle()) {
-        if (sharing.makeCurrent(ctxToMakeCurrent) == GL_FALSE) {
-            while (sharing.makeCurrent(sharing.getBackupContextHandle()) == GL_FALSE) {
-                ;
-            }
-        }
-    }
 }
 
 GLContextGuard::~GLContextGuard() {
-    auto &sharing = *static_cast<GLSharingFunctionsLinux *>(sharingFunctions);
-    if (currentContextHandle != sharing.getContextHandle()) {
-        sharing.makeCurrent(currentContextHandle, currentDisplayHandle);
-    }
 }
 } // namespace NEO

opencl/source/sharings/gl/linux/gl_sharing_linux.cpp

@@ -11,43 +11,13 @@
 #include "opencl/source/helpers/gl_helper.h"
 #include "opencl/source/sharings/gl/gl_arb_sync_event.h"
 
-namespace Os {
-extern const char *eglDllName;
-extern const char *openglDllName;
-} // namespace Os
-
 namespace NEO {
 GLSharingFunctionsLinux::GLSharingFunctionsLinux(GLType glhdcType, GLContext glhglrcHandle, GLContext glhglrcHandleBkpCtx, GLDisplay glhdcHandle)
     : glHDCType(glhdcType), glHGLRCHandle(glhglrcHandle), glHGLRCHandleBkpCtx(glhglrcHandleBkpCtx), glHDCHandle(glhdcHandle) {
     GLSharingFunctionsLinux::initGLFunctions();
-    updateOpenGLContext();
 }
 GLSharingFunctionsLinux::~GLSharingFunctionsLinux() = default;
 
-bool GLSharingFunctionsLinux::isGlSharingEnabled() {
-    static bool oglLibAvailable = std::unique_ptr<OsLibrary>(OsLibrary::load(Os::eglDllName)).get() != nullptr;
-    return oglLibAvailable;
-}
-
-void GLSharingFunctionsLinux::createBackupContext() {
-    if (pfnEglCreateContext) {
-        glHGLRCHandleBkpCtx = pfnEglCreateContext(glHDCHandle);
-        pfnEglShareLists(glHGLRCHandle, glHGLRCHandleBkpCtx);
-    }
-}
-
-GLboolean GLSharingFunctionsLinux::setSharedOCLContextState() {
-    ContextInfo contextInfo{};
-    GLboolean retVal = glSetSharedOCLContextState(glHDCHandle, glHGLRCHandle, CL_TRUE, &contextInfo);
-    if (retVal == GL_FALSE) {
-        return GL_FALSE;
-    }
-    glContextHandle = contextInfo.contextHandle;
-    glDeviceHandle = contextInfo.deviceHandle;
-
-    return retVal;
-}
-
 bool GLSharingFunctionsLinux::isOpenGlExtensionSupported(const unsigned char *pExtensionString) {
     if (glGetStringi == nullptr || glGetIntegerv == nullptr) {
         return false;
@@ -123,26 +93,26 @@ void GLSharingFunctionsLinux::removeGlArbSyncEventMapping(Event &baseEvent) {
 }
 
 GLboolean GLSharingFunctionsLinux::initGLFunctions() {
-    eglLibrary.reset(OsLibrary::load(Os::eglDllName));
-    glLibrary.reset(OsLibrary::load(Os::openglDllName));
-
-    if (eglLibrary->isLoaded()) {
-        GlFunctionHelper eglGetProc(eglLibrary.get(), "eglGetProcAddress");
-        glGetCurrentContext = eglGetProc["eglGetCurrentContext"];
-        glGetCurrentDisplay = eglGetProc["eglGetCurrentDisplay"];
-        pfnEglCreateContext = eglGetProc["eglCreateContext"];
-        pfnEglDeleteContext = eglGetProc["eglDestroyContext"];
-        eglMakeCurrent = eglGetProc["eglMakeCurrent"];
-        eglCreateImage = eglGetProc["eglCreateImage"];
-        eglDestroyImage = eglGetProc["eglDestroyImage"];
-        glAcquireSharedTexture = eglGetProc["eglExportDMABUFImageMESA"];
+    std::unique_ptr<OsLibrary> dynLibrary(OsLibrary::load(""));
+
+    GlFunctionHelper glXGetProc(dynLibrary.get(), "glXGetProcAddress");
+    if (glXGetProc.ready()) {
+        glXGLInteropQueryDeviceInfo = glXGetProc["glXGLInteropQueryDeviceInfoMESA"];
+        glXGLInteropExportObject = glXGetProc["glXGLInteropExportObjectMESA"];
+        glXGLInteropFlushObjects = glXGetProc["glXGLInteropFlushObjectsMESA"];
     }
-    if (glLibrary->isLoaded()) {
-        glGetString = (*glLibrary)["glGetString"];
-        glGetStringi = (*glLibrary)["glGetStringi"];
-        glGetIntegerv = (*glLibrary)["glGetIntegerv"];
-        glGetTexLevelParameteriv = (*glLibrary)["glGetTexLevelParameteriv"];
+
+    GlFunctionHelper eglGetProc(dynLibrary.get(), "eglGetProcAddress");
+    if (eglGetProc.ready()) {
+        eglGLInteropQueryDeviceInfo = eglGetProc["eglGLInteropQueryDeviceInfoMESA"];
+        eglGLInteropExportObject = eglGetProc["eglGLInteropExportObjectMESA"];
+        eglGLInteropFlushObjects = eglGetProc["eglGLInteropFlushObjectsMESA"];
     }
+
+    glGetString = (*dynLibrary)["glGetString"];
+    glGetStringi = (*dynLibrary)["glGetStringi"];
+    glGetIntegerv = (*dynLibrary)["glGetIntegerv"];
+
     this->pfnGlArbSyncObjectCleanup = cleanupArbSyncObject;
     this->pfnGlArbSyncObjectSetup = setupArbSyncObject;
     this->pfnGlArbSyncObjectSignal = signalArbSyncObject;