Changeset 33306 in vbox

Timestamp:

Oct 21, 2010 12:52:37 PM (14 years ago)

Author:

vboxsync

Message:

wddm/3d: scrolling with aero 8x speedup, bugfixing + profiling

Location:

trunk

Files:

• include/VBox/VBoxCrHgsmi.h (modified) (1 diff)
• src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxCrHgsmi.cpp (modified) (4 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp (modified) (4 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h (modified) (1 diff)
• src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp (modified) (4 diffs)
• src/VBox/Additions/WINNT/Graphics/Wine/wined3d/surface.c (modified) (3 diffs)
• src/VBox/Devices/Graphics/DevVGA_VDMA.cpp (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/util/vboxhgsmi.c (modified) (31 diffs)

trunk/include/VBox/VBoxCrHgsmi.h

@@ -48 +48 @@
 VBOXCRHGSMI_DECL(HVBOXCRHGSMI_CLIENT) VBoxCrHgsmiQueryClient();
 
+VBOXCRHGSMI_DECL(void) VBoxCrHgsmiLog(char * szString);
+
 RT_C_DECLS_END
 

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxCrHgsmi.cpp

@@ -8 +8 @@
 static uint32_t g_cVBoxCrHgsmiProvider = 0;
 
+static VBOXDISPKMT_CALLBACKS g_VBoxCrHgsmiKmtCallbacks;
+
 typedef VBOXWDDMDISP_DECL(int) FNVBOXDISPCRHGSMI_INIT(PVBOXCRHGSMI_CALLBACKS pCallbacks);
 typedef FNVBOXDISPCRHGSMI_INIT *PFNVBOXDISPCRHGSMI_INIT;
@@ -23 +25 @@
 VBOXCRHGSMI_DECL(int) VBoxCrHgsmiInit(PVBOXCRHGSMI_CALLBACKS pCallbacks)
 {
+    static int bKmtCallbacksInited = 0;
+    if (!bKmtCallbacksInited)
+    {
+        HRESULT hr = vboxDispKmtCallbacksInit(&g_VBoxCrHgsmiKmtCallbacks);
+        Assert(hr == S_OK);
+        if (hr == S_OK)
+            bKmtCallbacksInited = 1;
+        else
+            bKmtCallbacksInited = -1;
+    }
+
+    Assert(bKmtCallbacksInited);
+    if (bKmtCallbacksInited < 0)
+    {
+        Assert(0);
+        return VERR_NOT_SUPPORTED;
+    }
+
     g_VBoxCrHgsmiCallbacks = *pCallbacks;
     if (!g_hVBoxCrHgsmiProvider)
@@ -77 +97 @@
     {
         hClient = g_pfnVBoxDispCrHgsmiQueryClient();
-#ifdef DEBUG_misha
-        Assert(hClient);
-#endif
+//#ifdef DEBUG_misha
+//        Assert(hClient);
+//#endif
         if (hClient)
             return hClient;
@@ -125 +145 @@
 }
 
+VBOXCRHGSMI_DECL(void) VBoxCrHgsmiLog(char * szString)
+{
+    VBOXDISPKMT_ADAPTER Adapter;
+    HRESULT hr = vboxDispKmtOpenAdapter(&g_VBoxCrHgsmiKmtCallbacks, &Adapter);
+    Assert(hr == S_OK);
+    if (hr == S_OK)
+    {
+        uint32_t cbString = (uint32_t)strlen(szString) + 1;
+        uint32_t cbCmd = RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, aStringBuf[cbString]);
+        PVBOXDISPIFESCAPE_DBGPRINT pCmd = (PVBOXDISPIFESCAPE_DBGPRINT)RTMemAllocZ(cbCmd);
+        Assert(pCmd);
+        if (pCmd)
+        {
+            pCmd->EscapeHdr.escapeCode = VBOXESC_DBGPRINT;
+            memcpy(pCmd->aStringBuf, szString, cbString);
+
+            D3DKMT_ESCAPE EscapeData = {0};
+            EscapeData.hAdapter = Adapter.hAdapter;
+            //EscapeData.hDevice = NULL;
+            EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
+    //        EscapeData.Flags.HardwareAccess = 1;
+            EscapeData.pPrivateDriverData = pCmd;
+            EscapeData.PrivateDriverDataSize = cbCmd;
+            //EscapeData.hContext = NULL;
+
+            int Status = g_VBoxCrHgsmiKmtCallbacks.pfnD3DKMTEscape(&EscapeData);
+            Assert(!Status);
+
+            RTMemFree(pCmd);
+        }
+        hr = vboxDispKmtCloseAdapter(&Adapter);
+        Assert(hr == S_OK);
+    }
+}
 
 ///* to be used by injection thread and by ogl ICD driver for hgsmi initialization*/

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

@@ -1699 +1699 @@
         pSwapchain->pRenderTargetFbCopy->Release();
         pSwapchain->pRenderTargetFbCopy = NULL;
+        pSwapchain->bRTFbCopyUpToDate = FALSE;
 #endif
         pSwapchain->pSwapChainIf->Release();
@@ -2358 +2359 @@
         pSwapchain->pSwapChainIf = pNewIf;
 #ifndef VBOXWDDM_WITH_VISIBLE_FB
+        pSwapchain->bRTFbCopyUpToDate = FALSE;
         if (!pSwapchain->pRenderTargetFbCopy)
         {
@@ -2462 +2464 @@
     if (hr == S_OK)
     {
+        pSwapchain->bRTFbCopyUpToDate = FALSE;
         vboxWddmSwapchainFlip(pSwapchain);
         Assert(pSwapchain->fFlags.Value == 0);
@@ -6355 +6358 @@
                     pSrcSurfIf = pSrcSwapchain->pRenderTargetFbCopy;
                     Assert(pSrcSurfIf);
-                    hr = pSrcSwapchain->pSwapChainIf->GetFrontBufferData(pSrcSurfIf);
-                    Assert(hr == S_OK);
-                    if (hr == S_OK)
+                    if (!pSrcSwapchain->bRTFbCopyUpToDate)
                     {
-                        /* do pSrcSurfIf->AddRef since we do a Release in the following if (hr == S_OK) branch */
+                        hr = pSrcSwapchain->pSwapChainIf->GetFrontBufferData(pSrcSurfIf);
+                        Assert(hr == S_OK);
+                        if (hr == S_OK)
+                        {
+                            /* do pSrcSurfIf->AddRef since we do a Release in the following if (hr == S_OK) branch */
+                            pSrcSwapchain->bRTFbCopyUpToDate = TRUE;
+                            pSrcSurfIf->AddRef();
+                        }
+                    }
+                    else
+                    {
                         pSrcSurfIf->AddRef();
                     }

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h

@@ -139 +139 @@
 #ifndef VBOXWDDM_WITH_VISIBLE_FB
     IDirect3DSurface9 *pRenderTargetFbCopy;
+    BOOL bRTFbCopyUpToDate;
 #endif
     IDirect3DSwapChain9 *pSwapChainIf;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

@@ -983 +983 @@
     Assert(Status == STATUS_SUCCESS);
 
+    if (context.data.bNotifyDpc)
+        pDevExt->u.primary.DxgkInterface.DxgkCbNotifyDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
+
     if (!vboxSHGSMIListIsEmpty(&context.data.CtlList))
     {
@@ -1003 +1006 @@
 
     vboxVdmaDdiCmdHandleCompletedList(pDevExt, &pDevExt->DdiCmdQueue, &context.data.CompletedDdiCmdQueue);
-
-    if (context.data.bNotifyDpc)
-        pDevExt->u.primary.DxgkInterface.DxgkCbNotifyDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
 
 //    dfprintf(("<== "__FUNCTION__ ", context(0x%p)\n", MiniportDeviceContext));
@@ -4245 +4245 @@
     DXGKARG_RENDER  *pRender)
 {
-    drprintf(("==> "__FUNCTION__ ", hContext(0x%x)\n", hContext));
+//    drprintf(("==> "__FUNCTION__ ", hContext(0x%x)\n", hContext));
 
     Assert(pRender->DmaBufferPrivateDataSize >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR));
@@ -4347 +4347 @@
     }
 
-    drprintf(("<== "__FUNCTION__ ", hContext(0x%x)\n", hContext));
+//    drprintf(("<== "__FUNCTION__ ", hContext(0x%x)\n", hContext));
 
     return Status;

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

@@ -854 +854 @@
 }
 
+#ifdef VBOX_WITH_WDDM
+static void surface_upload_data_rect(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
+        const struct wined3d_format_desc *format_desc, BOOL srgb, const GLvoid *data, RECT *pRect)
+{
+    GLsizei width = pRect->right - pRect->left;
+    GLsizei height = pRect->bottom - pRect->top;
+    GLenum internal;
+
+    if (srgb)
+    {
+        internal = format_desc->glGammaInternal;
+    }
+    else if (This->resource.usage & WINED3DUSAGE_RENDERTARGET
+            && surface_is_offscreen((IWineD3DSurface *)This))
+    {
+        internal = format_desc->rtInternal;
+    }
+    else
+    {
+        internal = format_desc->glInternal;
+    }
+
+    TRACE("This %p, internal %#x, width %d, height %d, format %#x, type %#x, data %p.\n",
+            This, internal, width, height, format_desc->glFormat, format_desc->glType, data);
+    TRACE("target %#x, level %u, resource size %u.\n",
+            This->texture_target, This->texture_level, This->resource.size);
+
+    if (format_desc->heightscale != 1.0f && format_desc->heightscale != 0.0f) height *= format_desc->heightscale;
+
+    ENTER_GL();
+
+    if (This->Flags & SFLAG_PBO)
+    {
+        GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
+        checkGLcall("glBindBufferARB");
+
+        TRACE("(%p) pbo: %#x, data: %p.\n", This, This->pbo, data);
+        data = NULL;
+    }
+
+    if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
+    {
+        TRACE("Calling glCompressedTexSubImage2DARB.\n");
+
+        GL_EXTCALL(glCompressedTexSubImage2DARB(This->texture_target, This->texture_level,
+                pRect->left, pRect->top, width, height, internal, This->resource.size, data));
+        checkGLcall("glCompressedTexSubImage2DARB");
+    }
+    else
+    {
+        TRACE("Calling glTexSubImage2D.\n");
+
+        glTexSubImage2D(This->texture_target, This->texture_level,
+                pRect->left, pRect->top, width, height, format_desc->glFormat, format_desc->glType, data);
+        checkGLcall("glTexSubImage2D");
+    }
+
+    if (This->Flags & SFLAG_PBO)
+    {
+        GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
+        checkGLcall("glBindBufferARB");
+    }
+
+    LEAVE_GL();
+
+    if (gl_info->quirks & WINED3D_QUIRK_FBO_TEX_UPDATE)
+    {
+        IWineD3DDeviceImpl *device = This->resource.device;
+        unsigned int i;
+
+        for (i = 0; i < device->numContexts; ++i)
+        {
+            context_surface_update(device->contexts[i], This);
+        }
+    }
+}
+#endif
+
 /* This call just allocates the texture, the caller is responsible for binding
  * the correct texture. */
@@ -3899 +3977 @@
 }
 
+#ifdef VBOX_WITH_WDDM
+/* Not called from the VTable */
+static HRESULT IWineD3DSurfaceImpl_BltSys2Vram(IWineD3DSurfaceImpl *This, const RECT *DestRect,
+        IWineD3DSurface *SrcSurface, const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx,
+        WINED3DTEXTUREFILTERTYPE Filter)
+{
+    IWineD3DDeviceImpl *myDevice = This->resource.device;
+    const struct wined3d_gl_info *gl_info = &myDevice->adapter->gl_info;
+    IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
+    RECT dst_rect, src_rect;
+    struct wined3d_format_desc desc;
+    CONVERT_TYPES convert;
+    struct wined3d_context *context = NULL;
+    BYTE *mem;
+    BYTE *updateMem;
+    BOOL srgb;
+    int srcWidth, srcPitch;
+
+    TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
+
+    if(This->Flags & SFLAG_INSYSMEM) {
+        WARN("Destination has a SYSMEM location valid, rejecting gl blt\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    if(!(This->Flags & SFLAG_INTEXTURE)
+            && !(This->Flags & SFLAG_INSRGBTEX)) {
+        WARN("Destination does NOT have a TEXTURE location valid, rejecting gl blt\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    srgb = !(This->Flags & SFLAG_INTEXTURE);
+
+    if(!(Src->Flags & SFLAG_INSYSMEM)) {
+        WARN("Source does NOT have a SYSMEM location valid, rejecting gl blt\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    if(This->resource.format_desc != Src->resource.format_desc) {
+        WARN("Src and Dest Formats NOT equal, rejecting gl blt\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    /* No destination color keying supported */
+    if(Flags & (WINEDDBLT_KEYDEST | WINEDDBLT_KEYDESTOVERRIDE)) {
+        /* Can we support that with glBlendFunc if blitting to the frame buffer? */
+        TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    surface_get_rect(This, DestRect, &dst_rect);
+    surface_get_rect(Src, SrcRect, &src_rect);
+
+    if (src_rect.right - src_rect.left != dst_rect.right - dst_rect.left
+            || src_rect.bottom - src_rect.top != dst_rect.bottom - dst_rect.top)
+    {
+        WARN("Stretching requested, rejecting gl blt\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    d3dfmt_get_conv(Src, TRUE /* We need color keying */, TRUE /* We will use textures */,
+            &desc, &convert);
+
+    if  (desc.convert || convert != NO_CONVERSION)
+    {
+        WARN("TODO: test if conversion works, rejecting gl blt\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    if (!myDevice->isInDraw) context = context_acquire(myDevice, NULL, CTXUSAGE_RESOURCELOAD);
+
+    surface_bind_and_dirtify(This, srgb);
+
+    if(This->CKeyFlags & WINEDDSD_CKSRCBLT) {
+        This->Flags |= SFLAG_GLCKEY;
+        This->glCKey = This->SrcBltCKey;
+    }
+    else This->Flags &= ~SFLAG_GLCKEY;
+
+//    /* The width is in 'length' not in bytes */
+    srcWidth = Src->currentDesc.Width;
+    srcPitch = IWineD3DSurface_GetPitch(SrcSurface);
+
+    /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
+     * but it isn't set (yet) in all cases it is getting called. */
+    if((convert != NO_CONVERSION) && (This->Flags & SFLAG_PBO)) {
+        TRACE("Removing the pbo attached to surface %p\n", This);
+        surface_remove_pbo(This, gl_info);
+    }
+
+    if(desc.convert) {
+        /* This code is entered for texture formats which need a fixup. */
+        int srcHeight = Src->currentDesc.Height;
+//        int width = Src->currentDesc.Width;
+//        int pitch = IWineD3DSurface_GetPitch(SrcSurface);
+
+        /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
+        int outpitch = srcWidth * desc.conv_byte_count;
+        outpitch = (outpitch + myDevice->surface_alignment - 1) & ~(myDevice->surface_alignment - 1);
+
+        mem = HeapAlloc(GetProcessHeap(), 0, outpitch * srcHeight);
+        if(!mem) {
+            ERR("Out of memory %d, %d!\n", outpitch, srcHeight);
+            if (context) context_release(context);
+            return WINED3DERR_OUTOFVIDEOMEMORY;
+        }
+        desc.convert(Src->resource.allocatedMemory, mem, srcPitch, srcWidth, srcHeight);
+    } else if((convert != NO_CONVERSION) && Src->resource.allocatedMemory) {
+        /* This code is only entered for color keying fixups */
+        int srcHeight = Src->currentDesc.Height;
+        int outpitch;
+//        int width = Src->currentDesc.Width;
+//        int pitch = IWineD3DSurface_GetPitch(SrcSurface);
+
+        /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
+        outpitch = srcWidth * desc.conv_byte_count;
+        outpitch = (outpitch + myDevice->surface_alignment - 1) & ~(myDevice->surface_alignment - 1);
+
+        mem = HeapAlloc(GetProcessHeap(), 0, outpitch * srcHeight);
+        if(!mem) {
+            ERR("Out of memory %d, %d!\n", outpitch, srcHeight);
+            if (context) context_release(context);
+            return WINED3DERR_OUTOFVIDEOMEMORY;
+        }
+        d3dfmt_convert_surface(Src->resource.allocatedMemory, mem, srcPitch, srcWidth, srcHeight, outpitch, convert, Src);
+    } else {
+        mem = Src->resource.allocatedMemory;
+    }
+
+    updateMem = mem + srcPitch * src_rect.top;
+
+    /* Make sure the correct pitch is used */
+    ENTER_GL();
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, Src->currentDesc.Width);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, src_rect.left);
+    LEAVE_GL();
+
+    if (mem || (This->Flags & SFLAG_PBO))
+        surface_upload_data_rect(This, gl_info, &desc, srgb, updateMem, &dst_rect);
+
+    /* Restore the default pitch */
+    ENTER_GL();
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    LEAVE_GL();
+
+    if (context) context_release(context);
+
+    /* Don't delete PBO memory */
+    if((mem != Src->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
+        HeapFree(GetProcessHeap(), 0, mem);
+    ////
+
+    IWineD3DSurface_ModifyLocation((IWineD3DSurface *)This, srgb ? SFLAG_INSRGBTEX : SFLAG_INTEXTURE, TRUE);
+
+    return WINED3D_OK;
+}
+#endif
+
 static HRESULT WINAPI IWineD3DSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *DestRect, IWineD3DSurface *SrcSurface,
         const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter) {
@@ -3932 +4169 @@
         if(IWineD3DSurfaceImpl_BltOverride(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter) == WINED3D_OK) return WINED3D_OK;
     }
+
+#ifdef VBOX_WITH_WDDM
+    if (IWineD3DSurfaceImpl_BltSys2Vram(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter) == WINED3D_OK) return WINED3D_OK;
+#endif
 
     /* For the rest call the X11 surface implementation.

trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp

@@ -524 +524 @@
     void * pvDst;
     int rc = VINF_SUCCESS;
+    uint32_t cbTransfer = pTransfer->cbTransferSize;
+    uint32_t cbTransfered = 0;
     bool bSrcLocked = false;
     bool bDstLocked = false;
-    if (pTransfer->fFlags & VBOXVDMACMD_DMA_BPB_TRANSFER_F_SRC_VRAMOFFSET)
-    {
-        pvSrc = pvRam + pTransfer->Src.offVramBuf;
-    }
-    else
-    {
-        RTGCPHYS phPage = pTransfer->Src.phBuf;
-        rc = PDMDevHlpPhysGCPhys2CCPtrReadOnly(pDevIns, phPage, 0, &pvSrc, &SrcLock);
-        AssertRC(rc);
+    do
+    {
+        uint32_t cbSubTransfer = cbTransfer;
+        if (pTransfer->fFlags & VBOXVDMACMD_DMA_BPB_TRANSFER_F_SRC_VRAMOFFSET)
+        {
+            pvSrc  = pvRam + pTransfer->Src.offVramBuf + cbTransfered;
+        }
+        else
+        {
+            RTGCPHYS phPage = pTransfer->Src.phBuf;
+            phPage += cbTransfered;
+            rc = PDMDevHlpPhysGCPhys2CCPtrReadOnly(pDevIns, phPage, 0, &pvSrc, &SrcLock);
+            AssertRC(rc);
+            if (RT_SUCCESS(rc))
+            {
+                bSrcLocked = true;
+                cbSubTransfer = RT_MIN(cbSubTransfer, 0x1000);
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        if (pTransfer->fFlags & VBOXVDMACMD_DMA_BPB_TRANSFER_F_DST_VRAMOFFSET)
+        {
+            pvDst  = pvRam + pTransfer->Dst.offVramBuf + cbTransfered;
+        }
+        else
+        {
+            RTGCPHYS phPage = pTransfer->Dst.phBuf;
+            phPage += cbTransfered;
+            rc = PDMDevHlpPhysGCPhys2CCPtr(pDevIns, phPage, 0, &pvDst, &DstLock);
+            AssertRC(rc);
+            if (RT_SUCCESS(rc))
+            {
+                bDstLocked = true;
+                cbSubTransfer = RT_MIN(cbSubTransfer, 0x1000);
+            }
+            else
+            {
+                break;
+            }
+        }
+
         if (RT_SUCCESS(rc))
         {
-            bSrcLocked = true;
-        }
-    }
-
-    if (pTransfer->fFlags & VBOXVDMACMD_DMA_BPB_TRANSFER_F_DST_VRAMOFFSET)
-    {
-        pvDst = pvRam + pTransfer->Dst.offVramBuf;
-    }
-    else
-    {
-        RTGCPHYS phPage = pTransfer->Dst.phBuf;
-        rc = PDMDevHlpPhysGCPhys2CCPtr(pDevIns, phPage, 0, &pvDst, &DstLock);
-        AssertRC(rc);
-        if (RT_SUCCESS(rc))
-        {
-            bDstLocked = true;
-        }
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        memcpy(pvDst, pvSrc, pTransfer->cbTransferSize);
-    }
-
-    if (bSrcLocked)
-        PDMDevHlpPhysReleasePageMappingLock(pDevIns, &SrcLock);
-    if (bDstLocked)
-        PDMDevHlpPhysReleasePageMappingLock(pDevIns, &DstLock);
+            memcpy(pvDst, pvSrc, cbSubTransfer);
+            cbTransfer -= cbSubTransfer;
+            cbTransfered += cbSubTransfer;
+        }
+        else
+        {
+            cbTransfer = 0; /* to break */
+        }
+
+        if (bSrcLocked)
+            PDMDevHlpPhysReleasePageMappingLock(pDevIns, &SrcLock);
+        if (bDstLocked)
+            PDMDevHlpPhysReleasePageMappingLock(pDevIns, &DstLock);
+    } while (cbTransfer);
 
     if (RT_SUCCESS(rc))

trunk/src/VBox/GuestHost/OpenGL/util/vboxhgsmi.c

@@ -60 +60 @@
 #endif
 
+#define VBOX_WITH_CRHGSMIPROFILE
+#ifdef VBOX_WITH_CRHGSMIPROFILE
+#include <iprt/time.h>
+#include <stdio.h>
+
+typedef struct VBOXCRHGSMIPROFILE
+{
+    uint64_t cStartTime;
+    uint64_t cStepsTime;
+    uint64_t cSteps;
+} VBOXCRHGSMIPROFILE, *PVBOXCRHGSMIPROFILE;
+
+#define VBOXCRHGSMIPROFILE_GET_TIME_NANO() RTTimeNanoTS()
+#define VBOXCRHGSMIPROFILE_GET_TIME_MILLI() RTTimeMilliTS()
+
+/* 10 sec */
+#define VBOXCRHGSMIPROFILE_LOG_STEP_TIME (10000000000.)
+
+DECLINLINE(void) vboxCrHgsmiProfileStart(PVBOXCRHGSMIPROFILE pProfile)
+{
+    pProfile->cStepsTime = 0;
+    pProfile->cSteps = 0;
+    pProfile->cStartTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
+}
+
+DECLINLINE(void) vboxCrHgsmiProfileStep(PVBOXCRHGSMIPROFILE pProfile, uint64_t cStepTime)
+{
+    pProfile->cStepsTime += cStepTime;
+    ++pProfile->cSteps;
+}
+
+typedef struct VBOXCRHGSMIPROFILE_SCOPE
+{
+    uint64_t cStartTime;
+//    bool bDisable;
+} VBOXCRHGSMIPROFILE_SCOPE, *PVBOXCRHGSMIPROFILE_SCOPE;
+
+static VBOXCRHGSMIPROFILE g_VBoxProfile;
+
+static void vboxCrHgsmiLog(char * szString, ...)
+{
+    char szBuffer[4096] = {0};
+     va_list pArgList;
+     va_start(pArgList, szString);
+     _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
+     va_end(pArgList);
+
+     VBoxCrHgsmiLog(szBuffer);
+}
+
+DECLINLINE(void) vboxCrHgsmiProfileLog(PVBOXCRHGSMIPROFILE pProfile, uint64_t cTime)
+{
+    uint64_t profileTime = cTime - pProfile->cStartTime;
+    double percent = ((double)100.0) * pProfile->cStepsTime / profileTime;
+    double cps = ((double)1000000000.) * pProfile->cSteps / profileTime;
+    vboxCrHgsmiLog("hgsmi: cps: %.1f, host %.1f%%\n", cps, percent);
+}
+
+DECLINLINE(void) vboxCrHgsmiProfileScopeEnter(PVBOXCRHGSMIPROFILE_SCOPE pScope)
+{
+//    pScope->bDisable = false;
+    pScope->cStartTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
+}
+
+DECLINLINE(void) vboxCrHgsmiProfileScopeExit(PVBOXCRHGSMIPROFILE_SCOPE pScope)
+{
+//    if (!pScope->bDisable)
+    {
+        uint64_t cTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
+        vboxCrHgsmiProfileStep(&g_VBoxProfile, cTime - pScope->cStartTime);
+        if (VBOXCRHGSMIPROFILE_LOG_STEP_TIME < cTime - g_VBoxProfile.cStartTime)
+        {
+            vboxCrHgsmiProfileLog(&g_VBoxProfile, cTime);
+            vboxCrHgsmiProfileStart(&g_VBoxProfile);
+        }
+    }
+}
+
+
+#define VBOXCRHGSMIPROFILE_INIT() vboxCrHgsmiProfileStart(&g_VBoxProfile)
+#define VBOXCRHGSMIPROFILE_TERM() do {} while (0)
+
+#define VBOXCRHGSMIPROFILE_FUNC_PROLOGUE() \
+        VBOXCRHGSMIPROFILE_SCOPE __vboxCrHgsmiProfileScope; \
+        vboxCrHgsmiProfileScopeEnter(&__vboxCrHgsmiProfileScope);
+
+#define VBOXCRHGSMIPROFILE_FUNC_EPILOGUE() \
+        vboxCrHgsmiProfileScopeExit(&__vboxCrHgsmiProfileScope); \
+
+
+#else
+#define VBOXCRHGSMIPROFILE_INIT() do {} while (0)
+#define VBOXCRHGSMIPROFILE_TERM() do {} while (0)
+#define VBOXCRHGSMIPROFILE_FUNC_PROLOGUE() do {} while (0)
+#define VBOXCRHGSMIPROFILE_FUNC_EPILOGUE() do {} while (0)
+#endif
+
+
 typedef struct {
     int                  initialized;
@@ -443 +541 @@
 static void *crVBoxHGSMIAlloc(CRConnection *conn)
 {
-    PCRVBOXHGSMI_CLIENT pClient = _crVBoxHGSMIClientGet();
-    void *pvBuf = _crVBoxHGSMIDoAlloc(pClient, conn->buffer_size);
+    PCRVBOXHGSMI_CLIENT pClient;
+    void *pvBuf;
+
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
+
+    pClient = _crVBoxHGSMIClientGet();
+    pvBuf = _crVBoxHGSMIDoAlloc(pClient, conn->buffer_size);
     Assert(pvBuf);
+
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
+
     return pvBuf;
 }
@@ -456 +562 @@
     pSubm->fFlags.Value = 0;
     pSubm->fFlags.bDoNotRetire = 1;
-    pSubm->fFlags.bDoNotSignalCompletion = 1; /* <- we do not need that actually since
-                                                       * in case we want completion,
-                                                       * we will block in _crVBoxHGSMICmdBufferGetRc (when locking the buffer)
-                                                       * which is needed for getting the result */
+//    pSubm->fFlags.bDoNotSignalCompletion = 1; /* <- we do not need that actually since
+//                                                       * in case we want completion,
+//                                                       * we will block in _crVBoxHGSMICmdBufferGetRc (when locking the buffer)
+//                                                       * which is needed for getting the result */
 }
 
@@ -467 +573 @@
 # error "Port Me!!"
 #endif
+
+DECLINLINE(void) _crVBoxHGSMIWaitCmd(PCRVBOXHGSMI_CLIENT pClient)
+{
+    int rc = CRVBOXHGSMI_BUF_WAIT(pClient->pCmdBuffer);
+    Assert(rc == 0);
+}
 
 static void _crVBoxHGSMIWriteExact(CRConnection *conn, PCRVBOXHGSMI_CLIENT pClient, PVBOXUHGSMI_BUFFER pBuf, uint32_t offStart, unsigned int len)
@@ -506 +618 @@
         if (RT_SUCCESS(rc))
         {
+            _crVBoxHGSMIWaitCmd(pClient);
                 /* @todo: do we need to wait for completion actually?
                  * NOTE: in case we do not need completion,
@@ -539 +652 @@
         if (RT_SUCCESS(rc))
         {
+            _crVBoxHGSMIWaitCmd(pClient);
                 /* @todo: do we need to wait for completion actually?
                  * NOTE: in case we do not need completion,
@@ -556 +670 @@
 static void crVBoxHGSMIWriteExact(CRConnection *conn, const void *buf, unsigned int len)
 {
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     Assert(0);
 
@@ -566 +681 @@
 //    _crVBoxHGSMIWriteExact(conn, pClient, pBuf, 0, len);
 //    _crVBoxHGSMIBufFree(pClient, pBuf);
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 }
 
@@ -609 +725 @@
         return;
     }
+
+    _crVBoxHGSMIWaitCmd(pClient);
 
     parms = (CRVBOXHGSMIREAD *)_crVBoxHGSMICmdBufferLockRo(pClient, sizeof (*parms));
@@ -733 +851 @@
             break;
         }
+
+        _crVBoxHGSMIWaitCmd(pClient);
 
         parms = (CRVBOXHGSMIWRITEREAD *)_crVBoxHGSMICmdBufferLockRo(pClient, sizeof (*parms));
@@ -799 +919 @@
     PVBOXUHGSMI_BUFFER pBuf;
 
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
+
     if (!bufp) /* We're sending a user-allocated buffer. */
     {
@@ -811 +933 @@
         _crVBoxHGSMIWriteReadExact(conn, pClient, (void*)start, 0, len, false);
 #endif
+        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
         return;
     }
@@ -822 +945 @@
     Assert(pBuf);
     if (!pBuf)
+    {
+        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
         return;
+    }
 
     pClient = (PCRVBOXHGSMI_CLIENT)pBuf->pvUserData;
@@ -847 +973 @@
      */
     *bufp = NULL;
+
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 }
 
@@ -852 +980 @@
 {
     PCRVBOXHGSMI_CLIENT pClient;
-    PVBOXUHGSMI_BUFFER pBuf = _crVBoxHGSMIBufFromMemPtr(buf);
+    PVBOXUHGSMI_BUFFER pBuf;
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
+    pBuf = _crVBoxHGSMIBufFromMemPtr(buf);
     Assert(pBuf);
     Assert(0);
     CRASSERT(0);
     if (!pBuf)
+    {
+        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
         return;
+    }
     pClient = (PCRVBOXHGSMI_CLIENT)pBuf->pvUserData;
     _crVBoxHGSMIReadExact(conn, pClient);
-}
-
-static void crVBoxHGSMIFree(CRConnection *conn, void *buf)
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
+}
+
+static void _crVBoxHGSMIFree(CRConnection *conn, void *buf)
 {
     CRVBOXHGSMIBUFFER *hgsmi_buffer = (CRVBOXHGSMIBUFFER *) buf - 1;
@@ -888 +1022 @@
 #endif
     }
+}
+static void crVBoxHGSMIFree(CRConnection *conn, void *buf)
+{
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
+    _crVBoxHGSMIFree(conn, buf);
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 }
 
@@ -967 +1107 @@
         && cached_type != CR_MESSAGE_GATHER)
     {
-        crVBoxHGSMIFree(conn, msg);
+        _crVBoxHGSMIFree(conn, msg);
     }
 }
@@ -973 +1113 @@
 static void crVBoxHGSMIReceiveMessage(CRConnection *conn)
 {
-    PCRVBOXHGSMI_CLIENT pClient = _crVBoxHGSMIClientGet();
+    PCRVBOXHGSMI_CLIENT pClient;
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
+
+    pClient = _crVBoxHGSMIClientGet();
 
     Assert(pClient);
@@ -979 +1122 @@
 
     _crVBoxHGSMIReceiveMessage(conn, pClient);
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 }
 /*
@@ -985 +1129 @@
 static void crVBoxHGSMIAccept( CRConnection *conn, const char *hostname, unsigned short port )
 {
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     Assert(0);
 
@@ -991 +1136 @@
     CRASSERT(FALSE);
 #endif
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 }
 
@@ -1038 +1184 @@
 #ifdef RT_OS_WINDOWS
     DWORD cbReturned;
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
 
     if (g_crvboxhgsmi.hGuestDrv == INVALID_HANDLE_VALUE)
@@ -1055 +1202 @@
             Assert(0);
             crDebug("could not open VBox Guest Additions driver! rc = %d\n", GetLastError());
+            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
             return FALSE;
         }
     }
 #else
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
+
     if (g_crvboxhgsmi.iGuestDrv == INVALID_HANDLE_VALUE)
     {
@@ -1065 +1215 @@
         {
             crDebug("could not open Guest Additions kernel module! rc = %d\n", errno);
+            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
             return FALSE;
         }
@@ -1097 +1248 @@
         if (info.result == VINF_SUCCESS)
         {
+            int rc;
             conn->u32ClientID = info.u32ClientID;
             crDebug("HGCM connect was successful: client id =0x%x\n", conn->u32ClientID);
 
-            return crVBoxHGSMISetVersion(conn, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR);
+            rc = crVBoxHGSMISetVersion(conn, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR);
+            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
+            return rc;
         }
         else
@@ -1116 +1270 @@
 #endif
     }
+
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 
     return FALSE;
@@ -1135 +1291 @@
     int i;
 #endif
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
 
     if (conn->pHostBuffer)
@@ -1214 +1371 @@
 # endif
     }
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 #endif /* IN_GUEST */
 }
@@ -1219 +1377 @@
 static void crVBoxHGSMIInstantReclaim(CRConnection *conn, CRMessage *mess)
 {
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     Assert(0);
 
-    crVBoxHGSMIFree(conn, mess);
+    _crVBoxHGSMIFree(conn, mess);
     CRASSERT(FALSE);
+
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 }
 
 static void crVBoxHGSMIHandleNewMessage( CRConnection *conn, CRMessage *msg, unsigned int len )
 {
+    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     Assert(0);
 
     CRASSERT(FALSE);
+    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
 }
 
@@ -1241 +1404 @@
         pClient->pHgsmi = pHgsmi;
         rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(1),
-                                VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE, NULL,
+                                VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
+                                NULL,
                                 &pClient->pCmdBuffer);
         AssertRC(rc);
@@ -1247 +1411 @@
         {
             rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(0x800000),
-                                            VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE, NULL,
+                                            VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
+                                            NULL,
                                             &pClient->pHGBuffer);
             AssertRC(rc);