Changeset 43488 in vbox for trunk/src/VBox/Additions

Timestamp:

Oct 1, 2012 11:54:33 AM (12 years ago)

Author:

vboxsync

Message:

wined3d: profiling; export flushToHost and Finish commands

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Wine

Files:

• Makefile.kmk (modified) (1 diff)
• d3d9/d3d9wddm.def (modified) (1 diff)
• d3d9/device.c (modified) (1 diff)
• vbox/VBoxWineEx.h (modified) (2 diffs)
• vbox/libWineStub/include/wine/debug.h (modified) (1 diff)
• vbox/libWineStub/include/wine/wined3d.h (modified) (2 diffs)
• wined3d/device.c (modified) (4 diffs)
• wined3d/glsl_shader.c (modified) (1 diff)
• wined3d/wined3d_gl.h (modified) (2 diffs)
• wined3d/wined3d_private.h (modified) (2 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Wine/Makefile.kmk

@@ -225 +225 @@
         IN_VBOXLIBWINE \
         VBOX_WINE_WITH_SHADER_CACHE
+ifdef VBOX_WINE_WITH_PROFILE
+ wined3dwddm_DEFS       += VBOX_WINE_WITH_PROFILE
+endif
  wined3dwddm_INCS           = $(wined3d_INCS) \
         $(PATH_ROOT)/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm

trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9wddm.def

@@ -13 +13 @@
   Direct3DCreate9Ex
   VBoxWineExD3DDev9Flush
+  VBoxWineExD3DDev9FlushToHost
+  VBoxWineExD3DDev9Finish
   VBoxWineExD3DDev9CreateTexture
   VBoxWineExD3DDev9CreateCubeTexture

trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/device.c

@@ -786 +786 @@
     wined3d_mutex_lock();
     hr = IWineD3DDevice_Flush(This->WineD3DDevice);
+    wined3d_mutex_unlock();
+
+    return hr;
+}
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9FlushToHost(IDirect3DDevice9Ex *iface)
+{
+    IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+    HRESULT hr;
+
+    TRACE("iface %p, FlushToHost\n", iface);
+
+    wined3d_mutex_lock();
+    hr = IWineD3DDevice_FlushToHost(This->WineD3DDevice);
+    wined3d_mutex_unlock();
+
+    return hr;
+}
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Finish(IDirect3DDevice9Ex *iface)
+{
+    IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+    HRESULT hr;
+
+    TRACE("iface %p, Finish\n", iface);
+
+    wined3d_mutex_lock();
+    hr = IWineD3DDevice_Finish(This->WineD3DDevice);
     wined3d_mutex_unlock();
 

trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/VBoxWineEx.h

@@ -69 +69 @@
 typedef FNVBOXWINEEXD3DDEV9_FLUSH *PFNVBOXWINEEXD3DDEV9_FLUSH;
 
+typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_FLUSHTOHOST(IDirect3DDevice9Ex *iface);
+typedef FNVBOXWINEEXD3DDEV9_FLUSHTOHOST *PFNVBOXWINEEXD3DDEV9_FLUSHTOHOST;
+
+typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_FINISH(IDirect3DDevice9Ex *iface);
+typedef FNVBOXWINEEXD3DDEV9_FINISH *PFNVBOXWINEEXD3DDEV9_FINISH;
+
 typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_UPDATE(IDirect3DDevice9Ex *iface, D3DPRESENT_PARAMETERS * pParams, IDirect3DDevice9Ex **outIface);
 typedef FNVBOXWINEEXD3DDEV9_UPDATE *PFNVBOXWINEEXD3DDEV9_UPDATE;
@@ -114 +120 @@
 VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Flush(IDirect3DDevice9Ex *iface); /* perform glFlush */
 
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Finish(IDirect3DDevice9Ex *iface); /* perform glFinish */
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9FlushToHost(IDirect3DDevice9Ex *iface); /* flash data to host */
+
 VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Update(IDirect3DDevice9Ex *iface, D3DPRESENT_PARAMETERS * pParams,
                                                     IDirect3DDevice9Ex **outIface); /* update device parameters */

trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/libWineStub/include/wine/debug.h

@@ -359 +359 @@
 
 
-#ifdef DEBUG_misha
-//# define VBOXWINEDBG_SHADERS
-#endif
-
-#ifdef VBOXWINEDBG_SHADERS
+#if 1//fdef DEBUG_misha
+# define VBOXWINEDBG_SHADERS
+#endif
+
+#if defined(VBOXWINEDBG_SHADERS) || defined(VBOX_WINE_WITH_PROFILE)
 #include <stdio.h>
 #include <stdarg.h>
 
 void vboxWDbgPrintF(char * szString, ...);
-
+#endif
+
+#ifdef VBOXWINEDBG_SHADERS
 # define WDLOG(_m) do {\
         vboxWDbgPrintF _m ; \

trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/libWineStub/include/wine/wined3d.h

@@ -8252 +8252 @@
             const struct VBOXPOINT3D *pDstPoin3D
             );
+
+    HRESULT (STDMETHODCALLTYPE *FlushToHost)(
+            IWineD3DDevice *iface);
+
+    HRESULT (STDMETHODCALLTYPE *Finish)(
+        IWineD3DDevice* This);
 #endif
 
@@ -8427 +8433 @@
 #define IWineD3DDevice_VolBlt(This, pSourceVolume, pDestinationVolume, pSrcBoxArg, pDstPoin3D) (This)->lpVtbl->VolBlt(This, pSourceVolume, pDestinationVolume, pSrcBoxArg, pDstPoin3D)
 #define IWineD3DDevice_VolTexBlt(This, pSourceTexture, pDestinationTexture, pSrcBoxArg, pDstPoin3D) (This)->lpVtbl->VolTexBlt(This, pSourceTexture, pDestinationTexture, pSrcBoxArg, pDstPoin3D)
+#define IWineD3DDevice_FlushToHost(This) (This)->lpVtbl->FlushToHost(This)
+#define IWineD3DDevice_Finish(This) (This)->lpVtbl->Finish(This)
 #endif
 #endif

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c

@@ -1871 +1871 @@
     if(!This->d3d_initialized) return WINED3DERR_INVALIDCALL;
 
+#ifdef VBOX_WINE_WITH_PROFILE
+    VBOXWINEPROFILE_DRAWPRIM_TERM(&This->DrawPrimProfile);
+#endif
+
     /* I don't think that the interface guarantees that the device is destroyed from the same thread
      * it was created. Thus make sure a context is active for the glDelete* calls
@@ -7269 +7273 @@
     return WINED3D_OK;
 }
+
+static HRESULT WINAPI IWineD3DDeviceImpl_Finish(IWineD3DDevice *iface)
+{
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
+    struct wined3d_context *context;
+    int i;
+
+    /* first call swapchain flush to ensure all swapchain-pending data gets flushed */
+    for (i = 0; i < This->NumberOfSwapChains; ++i)
+    {
+        IWineD3DSwapChain *pSwapchain = This->swapchains[i];
+        IWineD3DSwapChain_Flush(pSwapchain);
+    }
+
+    for (i = 0; i < This->numContexts; ++i)
+    {
+        context = This->contexts[i];
+        if (context_acquire_context(context, NULL, CTXUSAGE_RESOURCELOAD, TRUE))
+        {
+            Assert(context->valid);
+            wglFinish();
+            context_release(context);
+        }
+        else
+        {
+            WARN("Invalid context, skipping flush.\n");
+        }
+    }
+    return WINED3D_OK;
+}
+
+static HRESULT WINAPI IWineD3DDeviceImpl_FlushToHost(IWineD3DDevice *iface)
+{
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
+    struct wined3d_context *context;
+    int i;
+
+    /* no context acquisition is needed */
+    for (i = 0; i < This->numContexts; ++i)
+    {
+        context = This->contexts[i];
+        pVBoxFlushToHost(context->glCtx);
+    }
+    return WINED3D_OK;
+}
+
 
 /* context activation is done by the caller */
@@ -7474 +7524 @@
     IWineD3DDeviceImpl_VolBlt,
     IWineD3DDeviceImpl_VolTexBlt,
+    IWineD3DDeviceImpl_FlushToHost,
+    IWineD3DDeviceImpl_Finish,
 #endif
 };
@@ -7519 +7571 @@
     device->createParms.hFocusWindow = focus_window;
     device->createParms.BehaviorFlags = flags;
+
+#ifdef VBOX_WINE_WITH_PROFILE
+    VBOXWINEPROFILE_DRAWPRIM_INIT(&device->DrawPrimProfile);
+#endif
 
     device->devType = device_type;

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/glsl_shader.c

@@ -5335 +5335 @@
 };
 
-#ifdef VBOXWINEDBG_SHADERS
+#if defined(VBOXWINEDBG_SHADERS) || defined(VBOX_WINE_WITH_PROFILE)
 void vboxWDbgPrintF(char * szString, ...)
 {

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_gl.h

@@ -1383 +1383 @@
 
 HGLRC (WINAPI *pVBoxCreateContext)(HDC, struct VBOXUHGSMI*) DECLSPEC_HIDDEN;
+void (WINAPI *pVBoxFlushToHost)(HGLRC) DECLSPEC_HIDDEN;
 
 #define GL_FUNCS_GEN \
@@ -1731 +1732 @@
 
 #define VBOX_FUNCS_GEN \
-    USE_WGL_FUNC(VBoxCreateContext)
+    USE_WGL_FUNC(VBoxCreateContext) \
+    USE_WGL_FUNC(VBoxFlushToHost)
 
 /* OpenGL extensions. */

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_private.h

@@ -1676 +1676 @@
 #define WINED3DCREATE_MULTITHREADED 0x00000004
 
+#ifdef VBOX_WINE_WITH_PROFILE
+
+#include <iprt/time.h>
+
+#define VBOXWINEPROFILE_GET_TIME_NANO() RTTimeNanoTS()
+#define VBOXWINEPROFILE_GET_TIME_MILLI() RTTimeMilliTS()
+
+# define PRLOG(_m) do {\
+        vboxWDbgPrintF _m ; \
+    } while (0)
+
+typedef struct VBOXWINEPROFILE_ELEMENT
+{
+    uint64_t u64Time;
+    uint32_t cu32Calls;
+} VBOXWINEPROFILE_ELEMENT, *PVBOXWINEPROFILE_ELEMENT;
+
+typedef struct VBOXWINEPROFILE_HASHMAP_ELEMENT
+{
+    VBOXEXT_HASHMAP_ENTRY MapEntry;
+    VBOXWINEPROFILE_ELEMENT Data;
+} VBOXWINEPROFILE_HASHMAP_ELEMENT, *PVBOXWINEPROFILE_HASHMAP_ELEMENT;
+
+#define VBOXWINEPROFILE_HASHMAP_ELEMENT_FROMENTRY(_p) ((PVBOXWINEPROFILE_HASHMAP_ELEMENT)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXWINEPROFILE_HASHMAP_ELEMENT, MapEntry)))
+
+#define VBOXWINEPROFILE_ELEMENT_DUMP(_p, _pn) do { \
+        PRLOG(("%s: t(%u);c(%u)\n", \
+            (_pn), \
+            (uint32_t)((_p)->u64Time / 1000000), \
+            (_p)->cu32Calls \
+            )); \
+    } while (0)
+
+#define VBOXWINEPROFILE_ELEMENT_RESET(_p) do { \
+        memset(_p, 0, sizeof (*(_p))); \
+    } while (0)
+
+#define VBOXWINEPROFILE_ELEMENT_STEP(_p, _t) do { \
+        (_p)->u64Time += (_t); \
+        ++(_p)->cu32Calls; \
+    } while (0)
+
+#define VBOXWINEPROFILE_HASHMAP_ELEMENT_CREATE()  ( (PVBOXWINEPROFILE_HASHMAP_ELEMENT)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (VBOXWINEPROFILE_HASHMAP_ELEMENT)) )
+
+#define VBOXWINEPROFILE_HASHMAP_ELEMENT_TERM(_pe) do { \
+        HeapFree(GetProcessHeap(), 0, (_pe)); \
+    } while (0)
+
+DECLINLINE(PVBOXWINEPROFILE_HASHMAP_ELEMENT) vboxWineProfileHashMapElementGet(PVBOXEXT_HASHMAP pMap, void *pvKey)
+{
+    PVBOXEXT_HASHMAP_ENTRY pEntry = VBoxExtHashGet(pMap, pvKey);
+    if (pEntry)
+    {
+        return VBOXWINEPROFILE_HASHMAP_ELEMENT_FROMENTRY(pEntry);
+    }
+    else
+    {
+        PVBOXWINEPROFILE_HASHMAP_ELEMENT pElement = VBOXWINEPROFILE_HASHMAP_ELEMENT_CREATE();
+        Assert(pElement);
+        if (pElement)
+            VBoxExtHashPut(pMap, pvKey, &pElement->MapEntry);
+        return pElement;
+    }
+}
+
+#define VBOXWINEPROFILE_HASHMAP_ELEMENT_STEP(_pm, _pk, _t) do { \
+        PVBOXWINEPROFILE_HASHMAP_ELEMENT pElement = vboxWineProfileHashMapElementGet(_pm, _pk); \
+        VBOXWINEPROFILE_ELEMENT_STEP(&pElement->Data, _t); \
+    } while (0)
+
+static DECLCALLBACK(bool) vboxWineProfileElementResetCb(struct VBOXEXT_HASHMAP *pMap, void *pvKey, struct VBOXEXT_HASHMAP_ENTRY *pValue, void *pvVisitor)
+{
+    PVBOXWINEPROFILE_HASHMAP_ELEMENT pElement = VBOXWINEPROFILE_HASHMAP_ELEMENT_FROMENTRY(pValue);
+    VBOXWINEPROFILE_ELEMENT_RESET(&pElement->Data);
+    return true;
+}
+
+static DECLCALLBACK(bool) vboxWineProfileElementDumpCb(struct VBOXEXT_HASHMAP *pMap, void *pvKey, struct VBOXEXT_HASHMAP_ENTRY *pValue, void *pvVisitor)
+{
+    PVBOXWINEPROFILE_HASHMAP_ELEMENT pElement = VBOXWINEPROFILE_HASHMAP_ELEMENT_FROMENTRY(pValue);
+    char *pName = (char*)pvVisitor;
+    PRLOG(("%s[%d]:", pName, (uint32_t)pvKey));
+    VBOXWINEPROFILE_ELEMENT_DUMP(&pElement->Data, "");
+    return true;
+}
+
+#define VBOXWINEPROFILE_HASHMAP_RESET(_pm) do { \
+        VBoxExtHashVisit((_pm), vboxWineProfileElementResetCb, NULL); \
+    } while (0)
+
+#define VBOXWINEPROFILE_HASHMAP_DUMP(_pm, _pn) do { \
+        VBoxExtHashVisit((_pm), vboxWineProfileElementDumpCb, (_pn)); \
+    } while (0)
+
+static DECLCALLBACK(bool) vboxWineProfileElementCleanupCb(struct VBOXEXT_HASHMAP *pMap, void *pvKey, struct VBOXEXT_HASHMAP_ENTRY *pValue, void *pvVisitor)
+{
+    PVBOXWINEPROFILE_HASHMAP_ELEMENT pElement = VBOXWINEPROFILE_HASHMAP_ELEMENT_FROMENTRY(pValue);
+    VBOXWINEPROFILE_HASHMAP_ELEMENT_TERM(pElement);
+    return true;
+}
+
+#define VBOXWINEPROFILE_HASHMAP_TERM(_pm) do { \
+        VBoxExtHashCleanup((_pm), vboxWineProfileElementCleanupCb, NULL); \
+        VBoxExtHashVisit((_pm), vboxWineProfileElementResetCb, NULL); \
+    } while (0)
+
+typedef struct VBOXWINEPROFILE_DRAWPRIM
+{
+    uint64_t u64LoadLocationTime;
+    uint64_t u64CtxAcquireTime;
+    uint64_t u64PostProcess;
+    VBOXEXT_HASHMAP MapDrawPrimSlowVs;
+    VBOXEXT_HASHMAP MapDrawPrimSlow;
+    VBOXEXT_HASHMAP MapDrawPrimStrided;
+    VBOXEXT_HASHMAP MapDrawPrimFast;
+    uint32_t cu32Calls;
+} VBOXWINEPROFILE_DRAWPRIM, *PVBOXWINEPROFILE_DRAWPRIM;
+
+#define VBOXWINEPROFILE_DRAWPRIM_RESET_NEXT(_p) do { \
+        (_p)->u64LoadLocationTime = 0; \
+        (_p)->u64CtxAcquireTime = 0; \
+        (_p)->u64PostProcess = 0; \
+        VBOXWINEPROFILE_HASHMAP_RESET(&(_p)->MapDrawPrimSlowVs); \
+        VBOXWINEPROFILE_HASHMAP_RESET(&(_p)->MapDrawPrimSlow); \
+        VBOXWINEPROFILE_HASHMAP_RESET(&(_p)->MapDrawPrimStrided); \
+        VBOXWINEPROFILE_HASHMAP_RESET(&(_p)->MapDrawPrimFast); \
+    } while (0)
+
+static DECLCALLBACK(uint32_t) vboxWineProfileDrawPrimHashMapHash(void *pvKey)
+{
+    return (uint32_t)pvKey;
+}
+
+static DECLCALLBACK(bool) vboxWineProfileDrawPrimHashMapEqual(void *pvKey1, void *pvKey2)
+{
+    return ((uint32_t)pvKey1) == ((uint32_t)pvKey2);
+}
+
+#define VBOXWINEPROFILE_DRAWPRIM_INIT(_p) do { \
+        memset((_p), 0, sizeof (*(_p))); \
+        VBoxExtHashInit(&(_p)->MapDrawPrimSlowVs, vboxWineProfileDrawPrimHashMapHash, vboxWineProfileDrawPrimHashMapEqual); \
+        VBoxExtHashInit(&(_p)->MapDrawPrimSlow, vboxWineProfileDrawPrimHashMapHash, vboxWineProfileDrawPrimHashMapEqual); \
+        VBoxExtHashInit(&(_p)->MapDrawPrimStrided, vboxWineProfileDrawPrimHashMapHash, vboxWineProfileDrawPrimHashMapEqual); \
+        VBoxExtHashInit(&(_p)->MapDrawPrimFast, vboxWineProfileDrawPrimHashMapHash, vboxWineProfileDrawPrimHashMapEqual); \
+    } while (0)
+
+#define VBOXWINEPROFILE_DRAWPRIM_TERM(_p) do { \
+        memset((_p), 0, sizeof (*(_p))); \
+        VBOXWINEPROFILE_HASHMAP_TERM(&(_p)->MapDrawPrimSlowVs); \
+        VBOXWINEPROFILE_HASHMAP_TERM(&(_p)->MapDrawPrimSlow); \
+        VBOXWINEPROFILE_HASHMAP_TERM(&(_p)->MapDrawPrimStrided); \
+        VBOXWINEPROFILE_HASHMAP_TERM(&(_p)->MapDrawPrimFast); \
+    } while (0)
+#else
+# define PRLOG(_m) do {} while (0)
+#endif
 struct IWineD3DDeviceImpl
 {
@@ -1812 +1968 @@
     VBOXEXT_HASHCACHE vshaderCache;
     VBOXEXT_HASHCACHE pshaderCache;
+#endif
+
+#ifdef VBOX_WINE_WITH_PROFILE
+    VBOXWINEPROFILE_DRAWPRIM DrawPrimProfile;
 #endif