Changeset 94101 in vbox for trunk/src/VBox/Devices

Timestamp:

Mar 6, 2022 5:43:23 PM (3 years ago)

Author:

vboxsync

Message:

Devices/Graphics: initial code for single device mode, enabled for non Windows hosts: bugref:9830

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA-internal.h (modified) (1 diff)
• DevVGA-SVGA.cpp (modified) (2 diffs)
• DevVGA-SVGA3d-dx.cpp (modified) (5 diffs)
• DevVGA-SVGA3d-win-dx.cpp (modified) (18 diffs)
• DevVGA-SVGA3d.h (modified) (2 diffs)

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA-internal.h

@@ -143 +143 @@
 
 # ifdef VBOX_WITH_VMSVGA3D
+#  ifdef VMSVGA3D_DX
+    /** DX context of the currently processed command buffer */
+    uint32_t                 idDXContextCurrent;
+    uint32_t                 u32Reserved;
+#  endif
     VMSVGA3DBACKENDFUNCS3D  *pFuncs3D;
     VMSVGA3DBACKENDFUNCSVGPU9 *pFuncsVGPU9;

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.cpp

@@ -3442 +3442 @@
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
 
+# ifdef VBOX_WITH_VMSVGA3D
+#  ifdef VMSVGA3D_DX
+    /* Commands submitted for the SVGA3D_INVALID_ID context do not affect pipeline. So ignore them. */
+    if (idDXContext != SVGA3D_INVALID_ID)
+    {
+        if (pSvgaR3State->idDXContextCurrent != idDXContext)
+        {
+            LogFlow(("DXCTX: buffer %d->%d\n", pSvgaR3State->idDXContextCurrent, idDXContext));
+            vmsvga3dDXSwitchContext(pThisCC, idDXContext);
+            pSvgaR3State->idDXContextCurrent = idDXContext;
+        }
+    }
+#  endif
+# endif
+
     uint32_t RT_UNTRUSTED_VOLATILE_GUEST * const pFIFO = pThisCC->svga.pau32FIFO;
 
@@ -5812 +5827 @@
 
     RTListInit(&pSVGAState->MOBLRUList);
+# ifdef VBOX_WITH_VMSVGA3D
+#  ifdef VMSVGA3D_DX
+    pSVGAState->idDXContextCurrent = SVGA3D_INVALID_ID;
+#  endif
+# endif
     return rc;
 }

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-dx.cpp

@@ -54 +54 @@
     /* Copy the host structure back to the guest memory. */
     memcpy(pSvgaDXContext, &pDXContext->svgaDXContext, sizeof(*pSvgaDXContext));
+
+    return rc;
+}
+
+
+int vmsvga3dDXSwitchContext(PVGASTATECC pThisCC, uint32_t cidNew)
+{
+    int rc;
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSwitchContext, VERR_INVALID_STATE);
+    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
+    AssertReturn(p3dState, VERR_INVALID_STATE);
+
+    PVMSVGA3DDXCONTEXT pDXContextNew;
+    rc = vmsvga3dDXContextFromCid(p3dState, cidNew, &pDXContextNew);
+    AssertRCReturn(rc, rc);
+
+    /* Notify the host backend that context is about to be switched. */
+    rc = pSvgaR3State->pFuncsDX->pfnDXSwitchContext(pThisCC, pDXContextNew);
+    if (rc == VINF_NOT_IMPLEMENTED || RT_FAILURE(rc))
+        return rc;
+
+    /** @todo Keep track of changes in the pipeline and apply only modified state. */
+    #define DX_STATE_VS                0x00000001
+    #define DX_STATE_PS                0x00000002
+    #define DX_STATE_SAMPLERS          0x00000004
+    #define DX_STATE_INPUTLAYOUT       0x00000008
+    uint32_t u32TrackedState = 0
+        | DX_STATE_VS
+        | DX_STATE_PS
+        | DX_STATE_SAMPLERS
+        | DX_STATE_INPUTLAYOUT
+        ;
+
+    if (u32TrackedState & DX_STATE_VS)
+    {
+        u32TrackedState &= ~DX_STATE_VS;
+
+        SVGA3dShaderType const shaderType = SVGA3D_SHADERTYPE_VS;
+
+        uint32_t const idxShaderState = shaderType - SVGA3D_SHADERTYPE_MIN;
+        SVGA3dShaderId shaderId = pDXContextNew->svgaDXContext.shaderState[idxShaderState].shaderId;
+
+        /** @todo Same code as in DXSetShader, move to a static function with type and id as parms. */
+        PVMSVGA3DSHADER pShader;
+        if (shaderId != SVGA_ID_INVALID)
+        {
+            SVGACOTableDXShaderEntry *pEntry = &pDXContextNew->cot.paShader[shaderId];
+            ASSERT_GUEST_RETURN(pEntry->type == shaderType, VERR_INVALID_PARAMETER);
+            RT_UNTRUSTED_VALIDATED_FENCE();
+
+            pShader = &pDXContextNew->paShader[shaderId];
+        }
+        else
+            pShader = NULL;
+
+        rc = pSvgaR3State->pFuncsDX->pfnDXSetShader(pThisCC, pDXContextNew, shaderType, pShader);
+        AssertRC(rc);
+    }
+
+    if (u32TrackedState & DX_STATE_PS)
+    {
+        u32TrackedState &= ~DX_STATE_PS;
+
+        SVGA3dShaderType const shaderType = SVGA3D_SHADERTYPE_PS;
+
+        uint32_t const idxShaderState = shaderType - SVGA3D_SHADERTYPE_MIN;
+        SVGA3dShaderId shaderId = pDXContextNew->svgaDXContext.shaderState[idxShaderState].shaderId;
+
+        /** @todo Same code as in DXSetShader, move to a static function with type and id as parms. */
+        PVMSVGA3DSHADER pShader;
+        if (shaderId != SVGA_ID_INVALID)
+        {
+            SVGACOTableDXShaderEntry *pEntry = &pDXContextNew->cot.paShader[shaderId];
+            ASSERT_GUEST_RETURN(pEntry->type == shaderType, VERR_INVALID_PARAMETER);
+            RT_UNTRUSTED_VALIDATED_FENCE();
+
+            pShader = &pDXContextNew->paShader[shaderId];
+        }
+        else
+            pShader = NULL;
+
+        rc = pSvgaR3State->pFuncsDX->pfnDXSetShader(pThisCC, pDXContextNew, shaderType, pShader);
+        AssertRC(rc);
+    }
+
+    if (u32TrackedState & DX_STATE_SAMPLERS)
+    {
+        u32TrackedState &= ~DX_STATE_SAMPLERS;
+
+        for (int i = SVGA3D_SHADERTYPE_MIN; i < SVGA3D_SHADERTYPE_DX10_MAX; ++i) /** SVGA3D_SHADERTYPE_MAX */
+        {
+            SVGA3dShaderType const shaderType = (SVGA3dShaderType)i;
+            uint32_t const idxShaderState = shaderType - SVGA3D_SHADERTYPE_MIN;
+
+            uint32_t startSampler = 0;
+            uint32_t cSamplerId = SVGA3D_DX_MAX_SAMPLERS;
+            SVGA3dSamplerId *paSamplerId = &pDXContextNew->svgaDXContext.shaderState[idxShaderState].samplers[0];
+
+            rc = pSvgaR3State->pFuncsDX->pfnDXSetSamplers(pThisCC, pDXContextNew, startSampler, shaderType, cSamplerId, paSamplerId);
+            AssertRC(rc);
+        }
+    }
+
+
+    if (u32TrackedState & DX_STATE_INPUTLAYOUT)
+    {
+        u32TrackedState &= ~DX_STATE_INPUTLAYOUT;
+
+        SVGA3dElementLayoutId const elementLayoutId = pDXContextNew->svgaDXContext.inputAssembly.layoutId;
+
+        rc = pSvgaR3State->pFuncsDX->pfnDXSetInputLayout(pThisCC, pDXContextNew, elementLayoutId);
+        AssertRC(rc);
+    }
+
+    Assert(u32TrackedState == 0);
 
     return rc;
@@ -263 +379 @@
     ASSERT_GUEST_RETURN(   pCmd->shaderId < pDXContext->cot.cShader
                         || pCmd->shaderId == SVGA_ID_INVALID, VERR_INVALID_PARAMETER);
-    RT_UNTRUSTED_VALIDATED_FENCE();
+    ASSERT_GUEST_RETURN(pCmd->type >= SVGA3D_SHADERTYPE_MIN && pCmd->type < SVGA3D_SHADERTYPE_MAX, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    uint32_t const idxShaderState = pCmd->type - SVGA3D_SHADERTYPE_MIN;
+    pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId = pCmd->shaderId;
 
     PVMSVGA3DSHADER pShader;
@@ -298 +418 @@
     ASSERT_GUEST_RETURN(pCmd->type >= SVGA3D_SHADERTYPE_MIN && pCmd->type < SVGA3D_SHADERTYPE_MAX, VERR_INVALID_PARAMETER);
     ASSERT_GUEST_RETURN(pDXContext->cot.paSampler, VERR_INVALID_STATE);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    uint32_t const idxShaderState = pCmd->type - SVGA3D_SHADERTYPE_MIN;
     for (uint32_t i = 0; i < cSamplerId; ++i)
     {
@@ -303 +426 @@
         ASSERT_GUEST_RETURN(   samplerId < pDXContext->cot.cSampler
                             || samplerId == SVGA_ID_INVALID, VERR_INVALID_PARAMETER);
+        pDXContext->svgaDXContext.shaderState[idxShaderState].samplers[pCmd->startSampler + i] = samplerId;
     }
     RT_UNTRUSTED_VALIDATED_FENCE();
@@ -483 +607 @@
     ASSERT_GUEST_RETURN(elementLayoutId < pDXContext->cot.cElementLayout, VERR_INVALID_PARAMETER);
     RT_UNTRUSTED_VALIDATED_FENCE();
+
+    pDXContext->svgaDXContext.inputAssembly.layoutId = elementLayoutId;
 
     rc = pSvgaR3State->pFuncsDX->pfnDXSetInputLayout(pThisCC, pDXContext, elementLayoutId);

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win-dx.cpp

@@ -50 +50 @@
 # define VBOX_D3D11_LIBRARY_NAME "VBoxDxVk"
 #endif
+
+//#define DX_FORCE_SINGLE_DEVICE
 
 /* This is not available on non Windows hosts. */
@@ -263 +265 @@
     PFN_D3D_DISASSEMBLE        pfnD3DDisassemble;
 
-    /** @todo This device will be used for all rendering for "single DX device" mode. */
     DXDEVICE                   dxDevice;               /* Device for the VMSVGA3D context independent operation. */
+
+    bool                       fSingleDevice;          /* Whether to use one DX device for all guest contexts. */
+
+    /** @todo Here a set of functions which do different job in single and multiple device modes. */
 } VMSVGA3DBACKEND;
 
@@ -787 +792 @@
     int rc = VINF_SUCCESS;
 
+    if (pBackend->fSingleDevice && pBackend->dxDevice.pDevice)
+    {
+        pDevice->pDevice = pBackend->dxDevice.pDevice;
+        pDevice->pDevice->AddRef();
+
+        pDevice->pImmediateContext = pBackend->dxDevice.pImmediateContext;
+        pDevice->pImmediateContext->AddRef();
+
+        pDevice->pDxgiFactory = pBackend->dxDevice.pDxgiFactory;
+        pDevice->pDxgiFactory->AddRef();
+
+        pDevice->FeatureLevel = pBackend->dxDevice.FeatureLevel;
+
+        pDevice->pStagingBuffer = 0;
+        pDevice->cbStagingBuffer = 0;
+
+        return rc;
+    }
+
     IDXGIAdapter *pAdapter = NULL; /* Default adapter. */
     static D3D_FEATURE_LEVEL const s_aFeatureLevels[] =
@@ -988 +1012 @@
     if (cid != DX_CID_BACKEND)
     {
+        if (pState->pBackend->fSingleDevice)
+            return &pState->pBackend->dxDevice;
+
         VMSVGA3DDXCONTEXT *pDXContext;
         int rc = vmsvga3dDXContextFromCid(pState, cid, &pDXContext);
@@ -1003 +1030 @@
 static DXDEVICE *dxDeviceFromContext(PVMSVGA3DSTATE p3dState, VMSVGA3DDXCONTEXT *pDXContext)
 {
-    if (pDXContext)
+    if (pDXContext && !p3dState->pBackend->fSingleDevice)
         return &pDXContext->pBackendDXContext->dxDevice;
 
@@ -1036 +1063 @@
 static int dxContextWait(uint32_t cidDrawing, PVMSVGA3DSTATE pState)
 {
+    if (pState->pBackend->fSingleDevice)
+      return VINF_SUCCESS;
+
     /* Flush cidDrawing context and issue a query. */
     DXDEVICE *pDXDevice = dxDeviceFromCid(cidDrawing, pState);
@@ -1047 +1077 @@
 static int dxSurfaceWait(PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface, uint32_t cidRequesting)
 {
+    if (pState->pBackend->fSingleDevice)
+        return VINF_SUCCESS;
+
     VMSVGA3DBACKENDSURFACE *pBackendSurface = pSurface->pBackendSurface;
     if (!pBackendSurface)
@@ -1076 +1109 @@
 
     uint32_t const cidRequesting = pDXContext ? pDXContext->cid : DX_CID_BACKEND;
-    if (cidRequesting == pSurface->idAssociatedContext)
+    if (cidRequesting == pSurface->idAssociatedContext || pState->pBackend->fSingleDevice)
         pResource = pBackendSurface->u.pResource;
     else
@@ -1832 +1865 @@
 static DXDEVICE *dxSurfaceDevice(PVMSVGA3DSTATE p3dState, PVMSVGA3DSURFACE pSurface, PVMSVGA3DDXCONTEXT pDXContext, UINT *pMiscFlags)
 {
+    if (p3dState->pBackend->fSingleDevice)
+    {
+        *pMiscFlags = 0;
+        return &p3dState->pBackend->dxDevice;
+    }
+
     if (dxIsSurfaceShareable(pSurface))
     {
@@ -2220 +2259 @@
         pBackendSurface->enmDxgiFormat = dxgiFormat;
         pSurface->pBackendSurface = pBackendSurface;
-        if (RT_BOOL(MiscFlags & D3D11_RESOURCE_MISC_SHARED))
+        if (p3dState->pBackend->fSingleDevice || RT_BOOL(MiscFlags & D3D11_RESOURCE_MISC_SHARED))
             pSurface->idAssociatedContext = DX_CID_BACKEND;
         else
@@ -2806 +2845 @@
         Log6Func(("Load D3DDisassemble: %Rrc\n", rc2));
     }
+
+#if !defined(RT_OS_WINDOWS) || defined(DX_FORCE_SINGLE_DEVICE)
+    pBackend->fSingleDevice = true;
+#endif
+
+    LogRelMax(1, ("VMSVGA: Single DX device mode: %s\n", pBackend->fSingleDevice ? "enabled" : "disabled"));
+
 //DEBUG_BREAKPOINT_TEST();
     return rc;
@@ -4203 +4249 @@
         {
             /* Create the target if it can be used as a device context shared resource (render or screen target). */
-            if (dxIsSurfaceShareable(pDstSurface))
+            if (pBackend->fSingleDevice || dxIsSurfaceShareable(pDstSurface))
             {
                 rc = vmsvga3dBackSurfaceCreateTexture(pThisCC, NULL, pDstSurface);
@@ -5091 +5137 @@
 
 
+static DECLCALLBACK(int) vmsvga3dBackDXSwitchContext(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContextNew)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    if (!pBackend->fSingleDevice)
+        return VINF_NOT_IMPLEMENTED; /* Not required. */
+
+    /* The new context state will be applied by the generic DX code. */
+    RT_NOREF(pDXContextNew);
+    return VINF_SUCCESS;
+}
+
+
 static DECLCALLBACK(int) vmsvga3dBackDXReadbackContext(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
@@ -5228 +5286 @@
         Assert(pDXShader->pShader);
         Assert(pDXShader->enmShaderType >= SVGA3D_SHADERTYPE_MIN && pDXShader->enmShaderType < SVGA3D_SHADERTYPE_MAX);
-        uint32_t const idxShaderState = pDXShader->enmShaderType - SVGA3D_SHADERTYPE_MIN;
-        pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId = pShader->id;
     }
     else
@@ -5247 +5303 @@
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
-    uint32_t const idxShaderState = type - SVGA3D_SHADERTYPE_MIN;
     ID3D11SamplerState *papSamplerState[SVGA3D_DX_MAX_SAMPLERS];
     for (uint32_t i = 0; i < cSamplerId; ++i)
@@ -5259 +5314 @@
         else
             papSamplerState[i] = NULL;
-
-        pDXContext->svgaDXContext.shaderState[idxShaderState].samplers[startSampler + i] = samplerId;
     }
 
@@ -5722 +5775 @@
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
-    pDXContext->svgaDXContext.inputAssembly.layoutId = elementLayoutId;
-
-    DXELEMENTLAYOUT *pDXElementLayout = &pDXContext->pBackendDXContext->paElementLayout[elementLayoutId];
-    if (!pDXElementLayout->pElementLayout)
-    {
-        uint32_t const idxShaderState = SVGA3D_SHADERTYPE_VS - SVGA3D_SHADERTYPE_MIN;
-        uint32_t const shid = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId;
-        AssertReturnStmt(shid < pDXContext->pBackendDXContext->cShader,
-                         LogRelMax(16, ("VMSVGA: DX shader is not set in DXSetInputLayout: shid = 0x%x\n", shid)),
-                         VERR_INVALID_STATE);
-        DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shid];
-        AssertReturnStmt(pDXShader->pvDXBC,
-                         LogRelMax(16, ("VMSVGA: DX shader bytecode is not available in DXSetInputLayout: shid = %u\n", shid)),
-                         VERR_INVALID_STATE);
-        HRESULT hr = pDevice->pDevice->CreateInputLayout(pDXElementLayout->aElementDesc,
-                                                         pDXElementLayout->cElementDesc,
-                                                         pDXShader->pvDXBC,
-                                                         pDXShader->cbDXBC,
-                                                         &pDXElementLayout->pElementLayout);
-        AssertReturn(SUCCEEDED(hr), VERR_NO_MEMORY);
-    }
-
-    pDevice->pImmediateContext->IASetInputLayout(pDXElementLayout->pElementLayout);
+    ID3D11InputLayout *pInputLayout = NULL;
+    if (elementLayoutId != SVGA3D_INVALID_ID)
+    {
+        DXELEMENTLAYOUT *pDXElementLayout = &pDXContext->pBackendDXContext->paElementLayout[elementLayoutId];
+        if (!pDXElementLayout->pElementLayout)
+        {
+            uint32_t const idxShaderState = SVGA3D_SHADERTYPE_VS - SVGA3D_SHADERTYPE_MIN;
+            uint32_t const shid = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId;
+            AssertReturnStmt(shid < pDXContext->pBackendDXContext->cShader,
+                             LogRelMax(16, ("VMSVGA: DX shader is not set in DXSetInputLayout: shid = 0x%x\n", shid)),
+                             VERR_INVALID_STATE);
+            DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shid];
+            AssertReturnStmt(pDXShader->pvDXBC,
+                             LogRelMax(16, ("VMSVGA: DX shader bytecode is not available in DXSetInputLayout: shid = %u\n", shid)),
+                             VERR_INVALID_STATE);
+            HRESULT hr = pDevice->pDevice->CreateInputLayout(pDXElementLayout->aElementDesc,
+                                                             pDXElementLayout->cElementDesc,
+                                                             pDXShader->pvDXBC,
+                                                             pDXShader->cbDXBC,
+                                                             &pDXElementLayout->pElementLayout);
+            AssertReturn(SUCCEEDED(hr), VERR_NO_MEMORY);
+        }
+
+        pInputLayout = pDXElementLayout->pElementLayout;
+    }
+
+    pDevice->pImmediateContext->IASetInputLayout(pInputLayout);
     return VINF_SUCCESS;
 }
@@ -7748 +7805 @@
                 p->pfnDXDestroyContext            = vmsvga3dBackDXDestroyContext;
                 p->pfnDXBindContext               = vmsvga3dBackDXBindContext;
+                p->pfnDXSwitchContext             = vmsvga3dBackDXSwitchContext;
                 p->pfnDXReadbackContext           = vmsvga3dBackDXReadbackContext;
                 p->pfnDXInvalidateContext         = vmsvga3dBackDXInvalidateContext;

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.h

@@ -396 +396 @@
     DECLCALLBACKMEMBER(int, pfnDXDestroyContext,            (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXBindContext,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
+    DECLCALLBACKMEMBER(int, pfnDXSwitchContext,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContextNew));
     DECLCALLBACKMEMBER(int, pfnDXReadbackContext,           (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXInvalidateContext,         (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
@@ -520 +521 @@
 /* Helpers. */
 int vmsvga3dDXUnbindContext(PVGASTATECC pThisCC, uint32_t cid, SVGADXContextMobFormat *pSvgaDXContext);
+int vmsvga3dDXSwitchContext(PVGASTATECC pThisCC, uint32_t cidNew);
 
 /* Command handlers. */