Changeset 52329 in vbox for trunk/src/VBox/GuestHost

Timestamp:

Aug 8, 2014 6:34:02 PM (11 years ago)

Author:

vboxsync

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

95454

Message:

wddm/crOpenGL: prevent shared objects from being deleted till they can be used

Location:

trunk

Files:

• . (modified) (1 prop)
• src/VBox (modified) (1 prop)
• src/VBox/GuestHost/OpenGL/include/chromium.h (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/include/cr_glstate.h (modified) (2 diffs)
• src/VBox/GuestHost/OpenGL/include/state/cr_texture.h (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/packer/packer.py (modified) (2 diffs)
• src/VBox/GuestHost/OpenGL/state_tracker/state.h (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/state_tracker/state_init.c (modified) (5 diffs)
• src/VBox/GuestHost/OpenGL/state_tracker/state_texture.c (modified) (6 diffs)

trunk/src/VBox/GuestHost/OpenGL/include/chromium.h

@@ -737 +737 @@
 #define GL_SHARE_LISTS_CR             0x8B31
 
+/* ensure the resource is  */
+#define GL_PIN_TEXTURE_SET_CR         0x8B32
+#define GL_PIN_TEXTURE_CLEAR_CR       0x8B33
+
 /**********************************************************************/
 /*****                Chromium-specific API                       *****/

trunk/src/VBox/GuestHost/OpenGL/include/cr_glstate.h

@@ -283 +283 @@
 
 
+DECLEXPORT(void) crStateReleaseTexture(CRContext *pCtx, CRTextureObj *pObj);
+
 #ifndef IN_GUEST
 DECLEXPORT(int32_t) crStateSaveContext(CRContext *pContext, PSSMHANDLE pSSM);
@@ -298 +300 @@
 
 DECLEXPORT(void) crStateSetTextureUsed(GLuint texture, GLboolean used);
+DECLEXPORT(void) crStatePinTexture(GLuint texture, GLboolean pin);
 DECLEXPORT(void) crStateDeleteTextureCallback(void *texObj);
 

trunk/src/VBox/GuestHost/OpenGL/include/state/cr_texture.h

@@ -94 +94 @@
     GLboolean              generateMipmap;
 #endif
+    GLboolean              pinned; /* <- keep the texture alive if its ctxUsage reaches zero */
     CRbitvalue             dirty[CR_MAX_BITARRAY];
     CRbitvalue             imageBit[CR_MAX_BITARRAY];

trunk/src/VBox/GuestHost/OpenGL/packer/packer.py

@@ -215 +215 @@
 
 
+r0_funcs = [ 'ChromiumParameteriCR', 'WindowSize', 'WindowShow', 'WindowPosition' ]
 
 
@@ -259 +260 @@
         pointers_ok = 1
 
+    if not func_name in r0_funcs:
+        print '#ifndef IN_RING0'
+        
     PrintFunc( func_name, params, 0, pointers_ok )
     PrintFunc( func_name, params, 1, pointers_ok )
+    
+    if not func_name in r0_funcs:
+        print '#endif'
+    

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state.h

@@ -77 +77 @@
 void crStateGenNames(CRContext *g, CRHashTable *table, GLsizei n, GLuint *names);
 void crStateRegNames(CRContext *g, CRHashTable *table, GLsizei n, GLuint *names);
+void crStateOnTextureUsageRelease(CRSharedState *pS, CRTextureObj *pObj);
 #endif

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_init.c

@@ -50 +50 @@
 }
 
-
-
 /**
  * Callback used for crFreeHashtable().
@@ -70 +68 @@
 } CR_STATE_RELEASEOBJ, *PCR_STATE_RELEASEOBJ;
 
+void crStateOnTextureUsageRelease(CRSharedState *pS, CRTextureObj *pObj)
+{
+    if (!pObj->pinned)
+        crHashtableDelete(pS->textureTable, pObj->id, crStateDeleteTextureCallback);
+    else
+        Assert(crHashtableSearch(pS->textureTable, pObj->id));
+}
+
+void crStateReleaseTextureInternal(CRSharedState *pS, CRContext *pCtx, CRTextureObj *pObj)
+{
+    Assert(CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj) || pObj->pinned);
+    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pCtx);
+    if (CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
+        return;
+
+    crStateOnTextureUsageRelease(pS, pObj);
+}
+
+DECLEXPORT(void) crStateReleaseTexture(CRContext *pCtx, CRTextureObj *pObj)
+{
+    Assert(CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj));
+    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pCtx);
+    if (CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
+        return;
+
+    if (!gSharedState)
+    {
+        WARN(("no global shared"));
+        return;
+    }
+
+    crStateOnTextureUsageRelease(gSharedState, pObj);
+}
+
+void crStateReleaseBufferObjectInternal(CRSharedState *pS, CRContext *pCtx, CRBufferObject *pObj)
+{
+    Assert(CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj));
+    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pCtx);
+    if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
+        crHashtableDelete(pS->buffersTable, pObj->id, crStateFreeBufferObject);
+}
+
+void crStateReleaseFBOInternal(CRSharedState *pS, CRContext *pCtx, CRFramebufferObject *pObj)
+{
+    Assert(CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj));
+    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pCtx);
+    if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
+        crHashtableDelete(pS->fbTable, pObj->id, crStateFreeFBO);
+}
+
+void crStateReleaseRBOInternal(CRSharedState *pS, CRContext *pCtx, CRRenderbufferObject *pObj)
+{
+    Assert(CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj));
+    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pCtx);
+    if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
+        crHashtableDelete(pS->rbTable, pObj->id, crStateFreeRBO);
+}
+
 static void ReleaseTextureCallback(unsigned long key, void *data1, void *data2)
 {
     PCR_STATE_RELEASEOBJ pData = (PCR_STATE_RELEASEOBJ)data2;
     CRTextureObj *pObj = (CRTextureObj *)data1;
-    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pData->pCtx);
-    if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
-        crHashtableDelete(pData->s->textureTable, key, crStateDeleteTextureCallback);
+    crStateReleaseTextureInternal(pData->s, pData->pCtx, pObj);
 }
 
@@ -83 +137 @@
     PCR_STATE_RELEASEOBJ pData = (PCR_STATE_RELEASEOBJ)data2;
     CRBufferObject *pObj = (CRBufferObject *)data1;
-    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pData->pCtx);
-    if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
-        crHashtableDelete(pData->s->buffersTable, key, crStateFreeBufferObject);
+    crStateReleaseBufferObjectInternal(pData->s, pData->pCtx, pObj);
 }
 
@@ -92 +144 @@
     PCR_STATE_RELEASEOBJ pData = (PCR_STATE_RELEASEOBJ)data2;
     CRFramebufferObject *pObj = (CRFramebufferObject *)data1;
-    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pData->pCtx);
-    if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
-        crHashtableDelete(pData->s->fbTable, key, crStateFreeFBO);
+    crStateReleaseFBOInternal(pData->s, pData->pCtx, pObj);
 }
 
@@ -101 +151 @@
     PCR_STATE_RELEASEOBJ pData = (PCR_STATE_RELEASEOBJ)data2;
     CRRenderbufferObject *pObj = (CRRenderbufferObject *)data1;
-    CR_STATE_SHAREDOBJ_USAGE_CLEAR(pObj, pData->pCtx);
-    if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pObj))
-        crHashtableDelete(pData->s->rbTable, key, crStateFreeRBO);
+    crStateReleaseRBOInternal(pData->s, pData->pCtx, pObj);
 }
 

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_texture.c

@@ -754 +754 @@
 #endif
     }
-
-    CR_STATE_SHAREDOBJ_USAGE_CLEAR(tObj, g);
 }
 
@@ -795 +793 @@
 
             crStateCleanupTextureRefs(g, tObj);
+
+            CR_STATE_SHAREDOBJ_USAGE_CLEAR(tObj, g);
 
             CR_STATE_SHAREDOBJ_USAGE_FOREACH_USED_IDX(tObj, j)
@@ -804 +804 @@
                 CRContext *ctx = g_pAvailableContexts[j];
                 if (j && ctx)
+                {
                     crStateCleanupTextureRefs(ctx, tObj);
+                    CR_STATE_SHAREDOBJ_USAGE_CLEAR(tObj, g);
+                }
                 else
                     CR_STATE_SHAREDOBJ_USAGE_CLEAR_IDX(tObj, j);
@@ -894 +897 @@
 }
 
+#ifndef IN_GUEST
+# ifdef DEBUG
+static uint32_t gDbgNumPinned = 0;
+# endif
+
+DECLEXPORT(void) crStatePinTexture(GLuint texture, GLboolean pin)
+{
+    CRTextureObj * pTobj;
+    CRSharedState *pShared = crStateGlobalSharedAcquire();
+    if (pShared)
+    {
+        pTobj = (CRTextureObj*)crHashtableSearch(pShared->textureTable, texture);
+
+        if (pTobj)
+        {
+# ifdef DEBUG
+            if (!pTobj->pinned != !pin)
+            {
+                if (pin)
+                    ++gDbgNumPinned;
+                else
+                {
+                    Assert(gDbgNumPinned);
+                    --gDbgNumPinned;
+                }
+            }
+# endif
+            pTobj->pinned = !!pin;
+            if (!pin)
+            {
+                if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pTobj))
+                    crStateOnTextureUsageRelease(pShared, pTobj);
+            }
+        }
+        else
+            WARN(("texture %d not defined", texture));
+
+        crStateGlobalSharedRelease();
+    }
+    else
+        WARN(("no global shared"));
+}
+#endif
+
 DECLEXPORT(void) crStateSetTextureUsed(GLuint texture, GLboolean used)
 {
@@ -916 +963 @@
 #endif
         {
-            crWarning("crStateSetTextureUsed: failed to fined a HW name for texture(%d)!", texture);
+            WARN(("crStateSetTextureUsed: failed to fined a HW name for texture(%d)!", texture));
             return;
         }
@@ -931 +978 @@
         crStateCleanupTextureRefs(g, tobj);
 
-        if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(tobj))
-        {
-            /* on the host side, we need to delete an ogl texture object here as well, which crStateDeleteTextureCallback will do
-             * in addition to calling crStateDeleteTextureObject to delete a state object */
-            crHashtableDelete(g->shared->textureTable, texture, crStateDeleteTextureCallback);
-        }
+        crStateReleaseTexture(g, tobj);
 
         DIRTY(tb->dirty, g->neg_bitid);