Changeset 53582 in vbox for trunk/src/VBox/HostServices/SharedOpenGL

Timestamp:

Dec 20, 2014 8:01:45 PM (10 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

97344

Message:

OpenGLTestDarwin.cpp: Replaced the home-cooked execute-once with RTONCE from IPRT. Cleaned up the code a little, dropping some duplicated code in VBoxOglIs3DAccelerationSupported among other things.

File:

• trunk/src/VBox/HostServices/SharedOpenGL/OpenGLTest/OpenGLTestDarwin.cpp (modified) (8 diffs)

trunk/src/VBox/HostServices/SharedOpenGL/OpenGLTest/OpenGLTestDarwin.cpp

@@ -1 +1 @@
 /* $Id$ */
-
 /** @file
  * VBox host opengl support test
@@ -18 +17 @@
 
 
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
+#include <VBox/VBoxOGLTest.h>
+
 #include <IOKit/IOKitLib.h>
 #include <OpenGL/OpenGL.h>
@@ -24 +28 @@
 #ifdef VBOX_WITH_COCOA_QT
 # include <OpenGL/glu.h>
-# include <iprt/log.h>
-#endif /* VBOX_WITH_COCOA_QT */
+#endif
+
 #include <iprt/env.h>
 #include <iprt/log.h>
+#include <iprt/once.h>
 
-#include <iprt/asm.h>
-#include <iprt/thread.h>
 
-#include <VBox/VBoxOGLTest.h>
 
-bool RTCALL VBoxOglIsOfflineRenderingAppropriate(void)
+/**
+ * @callback_method_impl{FNRTONCE,
+ *  For determining the cached VBoxOglIsOfflineRenderingAppropriate result.}
+ */
+static DECLCALLBACK(int32_t) vboxOglIsOfflineRenderingAppropriateOnce(void *pvUser)
 {
+    bool *pfAppropriate = (bool *)pvUser;
+
     /* It is assumed that it is makes sense to enable offline rendering
        only in case if host has more than one GPU installed. This routine
        counts all the PCI devices in IORegistry which have IOName property
-       set to "display". If the amount of such devices if greater than one,
-       it returns TRUE or FALSE otherwise. */
+       set to "display". If the number of such devices is greater than one,
+       it sets pfAppropriate to TRUE, otherwise to FALSE. */
 
-    kern_return_t   krc;
-    io_iterator_t   matchingServices;
-    CFDictionaryRef pMatchingDictionary;
-    static bool     fAppropriate = false;
+    CFStringRef ppDictionaryKeys[] = { CFSTR(kIOProviderClassKey), CFSTR(kIONameMatchKey) };
+    CFStringRef ppDictionaryVals[] = { CFSTR("IOPCIDevice"),       CFSTR("display") };
+    Assert(RT_ELEMENTS(ppDictionaryKeys) == RT_ELEMENTS(ppDictionaryVals));
 
-    /* In order to do not slowdown 3D engine which can ask about offline rendering several times,
-       let's cache the result and assume that renderers amount value is constant. Also prevent threads race
-       on startup. */
-
-#define VBOX_OGL_CHECK_UNINITIALIZED    (0)
-#define VBOX_OGL_CHECK_INITIALIZING     (1)
-#define VBOX_OGL_CHECK_INITIALIZED      (2)
-
-    /* Transition VBOX_OGL_CHECK_UNINITIALIZED -> VBOX_OGL_CHECK_INITIALIZING means the current thread
-       is the first one who entered the routine. In this case, it should detect number of GPUs, cache result
-       and return it. If it's not TRUE, then fInitialized is VBOX_OGL_CHECK_INITIALIZING (another thread is performing
-       the check; current thread should wait till result will be cached and return it) or VBOX_OGL_CHECK_INITIALIZED
-       (result is already cached; just return it.) */
-
-    static uint32_t volatile fInitialized = VBOX_OGL_CHECK_UNINITIALIZED;
-    if (!ASMAtomicCmpXchgU32(&fInitialized, VBOX_OGL_CHECK_INITIALIZING, VBOX_OGL_CHECK_UNINITIALIZED))
-    {
-        while (ASMAtomicReadU32(&fInitialized) != VBOX_OGL_CHECK_INITIALIZED)
-            RTThreadSleep(5);
-
-        return fAppropriate;
-    }
-
-#define VBOX_OGL_RENDERER_MATCH_KEYS_NUM    (2)
-
-    CFStringRef ppDictionaryKeys[VBOX_OGL_RENDERER_MATCH_KEYS_NUM] = { CFSTR(kIOProviderClassKey), CFSTR(kIONameMatchKey) };
-    CFStringRef ppDictionaryVals[VBOX_OGL_RENDERER_MATCH_KEYS_NUM] = { CFSTR("IOPCIDevice"),       CFSTR("display") };
-
-    pMatchingDictionary = CFDictionaryCreate(kCFAllocatorDefault,
-                                             (const void **)ppDictionaryKeys,
-                                             (const void **)ppDictionaryVals,
-                                             VBOX_OGL_RENDERER_MATCH_KEYS_NUM,
-                                             &kCFTypeDictionaryKeyCallBacks,
-                                             &kCFTypeDictionaryValueCallBacks);
+    CFDictionaryRef pMatchingDictionary = CFDictionaryCreate(kCFAllocatorDefault,
+                                                             (const void **)ppDictionaryKeys,
+                                                             (const void **)ppDictionaryVals,
+                                                             RT_ELEMENTS(ppDictionaryKeys),
+                                                             &kCFTypeDictionaryKeyCallBacks,
+                                                             &kCFTypeDictionaryValueCallBacks);
     if (pMatchingDictionary)
     {
         /* The reference to pMatchingDictionary is consumed by the function below => no IORelease(pMatchingDictionary)! */
-        krc = IOServiceGetMatchingServices(kIOMasterPortDefault, pMatchingDictionary, &matchingServices);
+        io_iterator_t matchingServices;
+        kern_return_t krc = IOServiceGetMatchingServices(kIOMasterPortDefault, pMatchingDictionary, &matchingServices);
         if (krc == kIOReturnSuccess)
         {
@@ -96 +76 @@
             }
 
-            fAppropriate = (cMatchingServices > 1);
+            *pfAppropriate = cMatchingServices > 1;
 
             IOObjectRelease(matchingServices);
         }
-
     }
 
-    LogRel(("OpenGL: Offline rendering support is %s (PID=%d)\n", fAppropriate ? "ON" : "OFF", (int)getpid()));
+    LogRel(("OpenGL: Offline rendering support is %s (pid=%d)\n", *pfAppropriate ? "ON" : "OFF", (int)getpid()));
+    return VINF_SUCCESS;
+}
 
-    ASMAtomicWriteU32(&fInitialized, VBOX_OGL_CHECK_INITIALIZED);
 
-    return fAppropriate;
+bool RTCALL VBoxOglIsOfflineRenderingAppropriate(void)
+{
+    /* In order to do not slowdown 3D engine which can ask about offline rendering several times,
+       let's cache the result and assume that renderers amount value is constant. Use the IPRT
+       execute once construct to make sure there aren't any threading issues. */
+    static RTONCE s_Once = RTONCE_INITIALIZER;
+    static bool   s_fCached = false;
+    int rc = RTOnce(&s_Once, vboxOglIsOfflineRenderingAppropriateOnce, &s_fCached);
+    AssertRC(rc);
+    return s_fCached;
 }
+
 
 bool RTCALL VBoxOglIs3DAccelerationSupported(void)
@@ -118 +108 @@
     }
 
-    CGDirectDisplayID   display = CGMainDisplayID ();
-    CGOpenGLDisplayMask cglDisplayMask = CGDisplayIDToOpenGLDisplayMask (display);
-    CGLPixelFormatObj   pixelFormat = NULL;
-    GLint numPixelFormats = 0;
-    CGLError            rcCgl;
-
-    CGLPixelFormatAttribute attribs[] = {
+    CGOpenGLDisplayMask     cglDisplayMask = CGDisplayIDToOpenGLDisplayMask(CGMainDisplayID());
+    CGLPixelFormatAttribute aAttribs[] =
+    {
         kCGLPFADisplayMask,
         (CGLPixelFormatAttribute)cglDisplayMask,
@@ -133 +119 @@
         (CGLPixelFormatAttribute)NULL
     };
-
-    display = CGMainDisplayID();
-    cglDisplayMask = CGDisplayIDToOpenGLDisplayMask(display);
-    rcCgl = CGLChoosePixelFormat(attribs, &pixelFormat, &numPixelFormats);
+    CGLPixelFormatObj pPixelFormat = NULL;
+    GLint             cPixelFormatsIgnored = 0;
+    CGLError rcCgl = CGLChoosePixelFormat(aAttribs, &pPixelFormat, &cPixelFormatsIgnored);
     if (rcCgl != kCGLNoError)
     {
@@ -143 +128 @@
     }
 
-    if (pixelFormat)
+    if (pPixelFormat)
     {
-        CGLContextObj cglContext = 0;
-        rcCgl = CGLCreateContext(pixelFormat, NULL, &cglContext);
-        CGLDestroyPixelFormat(pixelFormat);
+        CGLContextObj pCglContext = 0;
+        rcCgl = CGLCreateContext(pPixelFormat, NULL, &pCglContext);
+        CGLDestroyPixelFormat(pPixelFormat);
 
         if (rcCgl != kCGLNoError)
@@ -155 +140 @@
         }
 
-        if (cglContext)
+        if (pCglContext)
         {
             GLboolean isSupported = GL_TRUE;
+
 #ifdef VBOX_WITH_COCOA_QT
-            /* On the Cocoa port we depend on the GL_EXT_framebuffer_object &
+            /*
+             * In the Cocoa port we depend on the GL_EXT_framebuffer_object &
              * the GL_EXT_texture_rectangle extension. If they are not
-             * available, disable 3D support. */
-            CGLSetCurrentContext(cglContext);
-            const GLubyte* strExt;
-            strExt = glGetString(GL_EXTENSIONS);
-            isSupported = gluCheckExtension((const GLubyte*)"GL_EXT_framebuffer_object", strExt);
+             * available, disable 3D support.
+             */
+            CGLSetCurrentContext(pCglContext);
+            const GLubyte *pszExts = glGetString(GL_EXTENSIONS);
+            isSupported = gluCheckExtension((const GLubyte *)"GL_EXT_framebuffer_object", pszExts);
             if (isSupported)
             {
-                isSupported = gluCheckExtension((const GLubyte*)"GL_EXT_texture_rectangle", strExt);
+                isSupported = gluCheckExtension((const GLubyte *)"GL_EXT_texture_rectangle", pszExts);
                 if (!isSupported)
-                    LogRel(("OpenGL Info: 3D test found that GL_EXT_texture_rectangle extension not supported\n"));
+                    LogRel(("OpenGL Info: 3D test found that GL_EXT_texture_rectangle extension not supported.\n"));
             }
             else
-                LogRel(("OpenGL Info: 3D test found that GL_EXT_framebuffer_object extension not supported\n"));
+                LogRel(("OpenGL Info: 3D test found that GL_EXT_framebuffer_object extension not supported.\n"));
 #endif /* VBOX_WITH_COCOA_QT */
-            CGLDestroyContext(cglContext);
+
+            CGLDestroyContext(pCglContext);
             LogRel(("OpenGL Info: 3D test %spassed\n", isSupported == GL_TRUE ? "" : "not "));
-            return isSupported == GL_TRUE ? true : false;
+            return isSupported == GL_TRUE;
         }
-        else
-            LogRel(("OpenGL Info: 3D test unable to create context (internal error)\n"));
+
+        LogRel(("OpenGL Info: 3D test unable to create context (internal error).\n"));
     }
     else
-        LogRel(("OpenGL Info: 3D test unable to choose pixel format (internal error)\n"));
+        LogRel(("OpenGL Info: 3D test unable to choose pixel format (internal error).\n"));
 
     return false;