Changeset 94449 in vbox

Timestamp:

Apr 2, 2022 2:09:02 PM (3 years ago)

Author:

vboxsync

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

150779

Message:

Devices/Graphics: implemented queries; fixed generation of GS attributes: bugref:9830

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA-cmd.cpp (modified) (1 diff)
• DevVGA-SVGA.h (modified) (1 diff)
• DevVGA-SVGA3d-dx-shader.cpp (modified) (3 diffs)
• DevVGA-SVGA3d-dx-shader.h (modified) (1 diff)
• DevVGA-SVGA3d-dx.cpp (modified) (10 diffs)
• DevVGA-SVGA3d-win-dx.cpp (modified) (7 diffs)
• DevVGA-SVGA3d.h (modified) (1 diff)

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

@@ -903 +903 @@
 
 
+int vmsvgaR3MobWrite(PVMSVGAR3STATE pSvgaR3State, PVMSVGAMOB pMob,
+                     uint32_t off, void const *pvData, uint32_t cbData)
+{
+    return vmsvgaR3GboWrite(pSvgaR3State, &pMob->Gbo, off, pvData, cbData);
+}
+
+
+int vmsvgaR3MobRead(PVMSVGAR3STATE pSvgaR3State, PVMSVGAMOB pMob,
+                    uint32_t off, void *pvData, uint32_t cbData)
+{
+    return vmsvgaR3GboWrite(pSvgaR3State, &pMob->Gbo, off, pvData, cbData);
+}
+
+
 /** Create a host ring-3 pointer to the MOB data.
  * Current approach is to allocate a host memory buffer and copy the guest MOB data if necessary.

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

@@ -629 +629 @@
 
 PVMSVGAMOB vmsvgaR3MobGet(PVMSVGAR3STATE pSvgaR3State, SVGAMobId RT_UNTRUSTED_GUEST mobid);
+int vmsvgaR3MobWrite(PVMSVGAR3STATE pSvgaR3State, PVMSVGAMOB pMob, uint32_t off, void const *pvData, uint32_t cbData);
+int vmsvgaR3MobRead(PVMSVGAR3STATE pSvgaR3State, PVMSVGAMOB pMob, uint32_t off, void *pvData, uint32_t cbData);
 int vmsvgaR3MobBackingStoreCreate(PVMSVGAR3STATE pSvgaR3State, PVMSVGAMOB pMob, uint32_t cbValid);
 void vmsvgaR3MobBackingStoreDelete(PVMSVGAR3STATE pSvgaR3State, PVMSVGAMOB pMob);

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

@@ -2349 +2349 @@
 
 static char const *dxbcGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister, uint32_t u32BlobType,
-                                             uint32_t cSignature, SVGA3dDXSignatureEntry const *paSignature)
+                                             uint32_t cSignature, SVGA3dDXSignatureEntry const *paSignature,
+                                             SVGA3dDXSignatureSemanticName *pSemanticName)
 {
     for (uint32_t i = 0; i < cSignature; ++i)
@@ -2358 +2359 @@
             AssertReturn(p->semanticName < SVGADX_SIGNATURE_SEMANTIC_NAME_MAX, NULL);
             VGPUSemanticInfo const *pSemanticInfo = dxbcSemanticInfo(pInfo, p->semanticName, u32BlobType);
+            *pSemanticName = p->semanticName;
             return pSemanticInfo->pszName;
         }
@@ -2364 +2366 @@
 }
 
-char const *DXShaderGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister)
-{
-    return dxbcGetOutputSemanticName(pInfo, idxRegister, DXBC_BLOB_TYPE_OSGN, pInfo->cOutputSignature, &pInfo->aOutputSignature[0]);
+char const *DXShaderGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister, SVGA3dDXSignatureSemanticName *pSemanticName)
+{
+    return dxbcGetOutputSemanticName(pInfo, idxRegister, DXBC_BLOB_TYPE_OSGN, pInfo->cOutputSignature, &pInfo->aOutputSignature[0], pSemanticName);
 }
 

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

@@ -54 +54 @@
 int DXShaderUpdateResourceTypes(DXShaderInfo const *pInfo, VGPU10_RESOURCE_DIMENSION *paResourceType, uint32_t cResourceType);
 int DXShaderCreateDXBC(DXShaderInfo const *pInfo, void **ppvDXBC, uint32_t *pcbDXBC);
-char const *DXShaderGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister);
+char const *DXShaderGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister, SVGA3dDXSignatureSemanticName *pSemanticName);
 
 #endif /* !VBOX_INCLUDED_SRC_Graphics_DevVGA_SVGA3d_dx_shader_h */

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

@@ -40 +40 @@
 
 
-static int dxReadbackQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId, SVGACOTableDXQueryEntry *pEntry);
+/*
+ * Helpers.
+ */
+
+static int dxMobWrite(PVMSVGAR3STATE pSvgaR3State, SVGAMobId mobid, uint32_t off, void const *pvData, uint32_t cbData)
+{
+    PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, mobid);
+    ASSERT_GUEST_RETURN(pMob, VERR_INVALID_STATE);
+
+    return vmsvgaR3MobWrite(pSvgaR3State, pMob, off, pvData, cbData);
+}
 
 
@@ -1024 +1034 @@
     int rc;
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXBindQuery, VERR_INVALID_STATE);
+    AssertReturn(pSvgaR3State->pFuncsDX, VERR_INVALID_STATE);
     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
     AssertReturn(p3dState, VERR_INVALID_STATE);
@@ -1041 +1051 @@
     pEntry->mobid = vmsvgaR3MobId(pMob);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXBindQuery(pThisCC, pDXContext, queryId);
     return rc;
 }
@@ -1095 +1104 @@
         rc = pSvgaR3State->pFuncsDX->pfnDXBeginQuery(pThisCC, pDXContext, queryId);
         if (RT_SUCCESS(rc))
+        {
             pEntry->state = SVGADX_QDSTATE_ACTIVE;
+
+            /* Update the guest status of the query. */
+            uint32_t const u32 = SVGA3D_QUERYSTATE_PENDING;
+            dxMobWrite(pSvgaR3State, pEntry->mobid, pEntry->offset, &u32, sizeof(u32));
+        }
+        else
+        {
+            uint32_t const u32 = SVGA3D_QUERYSTATE_FAILED;
+            dxMobWrite(pSvgaR3State, pEntry->mobid, pEntry->offset, &u32, sizeof(u32));
+        }
     }
     return rc;
@@ -1101 +1121 @@
 
 
-int vmsvga3dDXEndQuery(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXEndQuery const *pCmd)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXEndQuery, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
-    AssertRCReturn(rc, rc);
-
-    SVGA3dQueryId const queryId = pCmd->queryId;
-
-    ASSERT_GUEST_RETURN(pDXContext->cot.paQuery, VERR_INVALID_STATE);
-    ASSERT_GUEST_RETURN(queryId < pDXContext->cot.cQuery, VERR_INVALID_PARAMETER);
-    RT_UNTRUSTED_VALIDATED_FENCE();
-
-    SVGACOTableDXQueryEntry *pEntry = &pDXContext->cot.paQuery[queryId];
+static int dxEndQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId, SVGACOTableDXQueryEntry *pEntry)
+{
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+
+    int rc;
     Assert(pEntry->state == SVGADX_QDSTATE_ACTIVE);
     if (pEntry->state == SVGADX_QDSTATE_ACTIVE)
     {
-        rc = pSvgaR3State->pFuncsDX->pfnDXEndQuery(pThisCC, pDXContext, queryId);
+        pEntry->state = SVGADX_QDSTATE_PENDING;
+
+        uint32_t u32QueryState;
+        SVGADXQueryResultUnion queryResult;
+        uint32_t cbQuery = 0; /* Actual size of query data returned by backend. */
+        rc = pSvgaR3State->pFuncsDX->pfnDXEndQuery(pThisCC, pDXContext, queryId, &queryResult, &cbQuery);
         if (RT_SUCCESS(rc))
-            pEntry->state = SVGADX_QDSTATE_PENDING;
+        {
+            /* Write the result after SVGA3dQueryState. */
+            dxMobWrite(pSvgaR3State, pEntry->mobid, pEntry->offset + sizeof(uint32_t), &queryResult, cbQuery);
+
+            u32QueryState = SVGA3D_QUERYSTATE_SUCCEEDED;
+        }
+        else
+            u32QueryState = SVGA3D_QUERYSTATE_FAILED;
+
+        dxMobWrite(pSvgaR3State, pEntry->mobid, pEntry->offset, &u32QueryState, sizeof(u32QueryState));
+
+        if (RT_SUCCESS(rc))
+            pEntry->state = SVGADX_QDSTATE_FINISHED;
     }
-
-    return rc;
-}
-
-
-int vmsvga3dDXReadbackQuery(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXReadbackQuery const *pCmd)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXReadbackQuery, VERR_INVALID_STATE);
+    else
+        rc = VERR_INVALID_STATE;
+
+    return rc;
+}
+
+
+int vmsvga3dDXEndQuery(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXEndQuery const *pCmd)
+{
+    int rc;
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXEndQuery, VERR_INVALID_STATE);
     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
     AssertReturn(p3dState, VERR_INVALID_STATE);
@@ -1151 +1176 @@
 
     SVGACOTableDXQueryEntry *pEntry = &pDXContext->cot.paQuery[queryId];
-    Assert(pEntry->state == SVGADX_QDSTATE_PENDING);
-
-    rc = dxReadbackQuery(pThisCC, pDXContext, queryId, pEntry);
+    rc = dxEndQuery(pThisCC, pDXContext, queryId, pEntry);
+    return rc;
+}
+
+
+int vmsvga3dDXReadbackQuery(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXReadbackQuery const *pCmd)
+{
+    int rc;
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    AssertReturn(pSvgaR3State->pFuncsDX, VERR_INVALID_STATE);
+    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
+    AssertReturn(p3dState, VERR_INVALID_STATE);
+
+    PVMSVGA3DDXCONTEXT pDXContext;
+    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
+    AssertRCReturn(rc, rc);
+
+    SVGA3dQueryId const queryId = pCmd->queryId;
+
+    ASSERT_GUEST_RETURN(pDXContext->cot.paQuery, VERR_INVALID_STATE);
+    ASSERT_GUEST_RETURN(queryId < pDXContext->cot.cQuery, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    /* The device does not cache queries. So this is a NOP. */
+
     return rc;
 }
@@ -2356 +2403 @@
     int rc;
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXBindQuery, VERR_INVALID_STATE);
+    AssertReturn(pSvgaR3State->pFuncsDX, VERR_INVALID_STATE);
     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
     AssertReturn(p3dState, VERR_INVALID_STATE);
@@ -2370 +2417 @@
         SVGACOTableDXQueryEntry *pEntry = &pDXContext->cot.paQuery[i];
         if (pEntry->type != SVGA3D_QUERYTYPE_INVALID)
-        {
             pEntry->mobid = pCmd->mobid;
-            pSvgaR3State->pFuncsDX->pfnDXBindQuery(pThisCC, pDXContext, i);
-        }
     }
 
@@ -2380 +2424 @@
 
 
-static int dxReadbackQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId, SVGACOTableDXQueryEntry *pEntry)
-{
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-
-    PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, pEntry->mobid);
-    ASSERT_GUEST_RETURN(pMob, VERR_INVALID_STATE); /* No MOB bound. */
-
-    uint32_t const cbMob = vmsvgaR3MobSize(pMob);
-    ASSERT_GUEST_RETURN(cbMob > pEntry->offset, VERR_INVALID_PARAMETER);
-    uint32_t const cbAvail = cbMob - pEntry->offset;
-
-    /* Create a memory pointer, which is accessible by host. */
-    int rc = vmsvgaR3MobBackingStoreCreate(pSvgaR3State, pMob, cbMob);
-    AssertRCReturn(rc, rc);
-
-    void *pvQuery = vmsvgaR3MobBackingStorePtr(pMob, pEntry->offset);
-    /** @todo Write the query data only. */
-    uint32_t cbQuery = 0; /* Actual size of query data returned by backend. */
-    rc = pSvgaR3State->pFuncsDX->pfnDXReadbackQuery(pThisCC, pDXContext, queryId, pvQuery, cbAvail, &cbQuery);
-    if (RT_SUCCESS(rc))
-        rc = vmsvgaR3MobBackingStoreWriteToGuest(pSvgaR3State, pMob);
-
-    vmsvgaR3MobBackingStoreDelete(pSvgaR3State, pMob);
-
-    pEntry->state = SVGADX_QDSTATE_FINISHED;
-    return rc;
-}
-
-
 int vmsvga3dDXReadbackAllQuery(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXReadbackAllQuery const *pCmd)
 {
     int rc;
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXReadbackQuery, VERR_INVALID_STATE);
+    AssertReturn(pSvgaR3State->pFuncsDX, VERR_INVALID_STATE);
     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
     AssertReturn(p3dState, VERR_INVALID_STATE);
@@ -2423 +2438 @@
     AssertRCReturn(rc, rc);
 
-    for (uint32_t i = 0; i < pDXContext->cot.cQuery; ++i)
-    {
-        SVGACOTableDXQueryEntry *pEntry = &pDXContext->cot.paQuery[i];
-        if (pEntry->state == SVGADX_QDSTATE_PENDING)
-        {
-            dxReadbackQuery(pThisCC, pDXContext, i, pEntry);
-        }
-    }
+    /* "Read back cached states from the device if they exist."
+     * The device does not cache queries. So this is a NOP.
+     */
+    RT_NOREF(pDXContext);
 
     return rc;

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

@@ -1705 +1705 @@
                     D3D11_SO_DECLARATION_ENTRY *p = &pDXStreamOutput->aDeclarationEntry[i];
                     SVGA3dStreamOutputDeclarationEntry const *decl = &pEntry->decl[i];
-                    p->SemanticName = DXShaderGetOutputSemanticName(&pDXShader->shaderInfo, decl->registerIndex);
-                    p->SemanticIndex = decl->registerIndex;
+                    SVGA3dDXSignatureSemanticName enmSemanticName;
+                    p->SemanticName = DXShaderGetOutputSemanticName(&pDXShader->shaderInfo, decl->registerIndex, &enmSemanticName);
+                    if (enmSemanticName == SVGADX_SIGNATURE_SEMANTIC_NAME_UNDEFINED)
+                        p->SemanticIndex = decl->registerIndex;
+                    else
+                        p->SemanticIndex = 0;
                 }
 
@@ -6043 +6047 @@
 }
 
-static D3D11_QUERY dxQueryType(SVGA3dQueryType type)
-{
-    switch (type)
-    {
-        case SVGA3D_QUERYTYPE_OCCLUSION:               return D3D11_QUERY_OCCLUSION;
-        case SVGA3D_QUERYTYPE_TIMESTAMP:               return D3D11_QUERY_TIMESTAMP;
-        case SVGA3D_QUERYTYPE_TIMESTAMPDISJOINT:       return D3D11_QUERY_TIMESTAMP_DISJOINT;
-        case SVGA3D_QUERYTYPE_PIPELINESTATS:           return D3D11_QUERY_PIPELINE_STATISTICS;
-        case SVGA3D_QUERYTYPE_OCCLUSIONPREDICATE:      return D3D11_QUERY_OCCLUSION_PREDICATE;
-        case SVGA3D_QUERYTYPE_STREAMOUTPUTSTATS:       return D3D11_QUERY_SO_STATISTICS;
-        case SVGA3D_QUERYTYPE_STREAMOVERFLOWPREDICATE: return D3D11_QUERY_SO_OVERFLOW_PREDICATE;
-        case SVGA3D_QUERYTYPE_OCCLUSION64:             return D3D11_QUERY_OCCLUSION;
-        case SVGA3D_QUERYTYPE_SOSTATS_STREAM0:         return D3D11_QUERY_SO_STATISTICS_STREAM0;
-        case SVGA3D_QUERYTYPE_SOSTATS_STREAM1:         return D3D11_QUERY_SO_STATISTICS_STREAM1;
-        case SVGA3D_QUERYTYPE_SOSTATS_STREAM2:         return D3D11_QUERY_SO_STATISTICS_STREAM2;
-        case SVGA3D_QUERYTYPE_SOSTATS_STREAM3:         return D3D11_QUERY_SO_STATISTICS_STREAM3;
-        case SVGA3D_QUERYTYPE_SOP_STREAM0:             return D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0;
-        case SVGA3D_QUERYTYPE_SOP_STREAM1:             return D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1;
-        case SVGA3D_QUERYTYPE_SOP_STREAM2:             return D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2;
-        case SVGA3D_QUERYTYPE_SOP_STREAM3:             return D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3;
-        default:
-            break;
-    }
-    return D3D11_QUERY_EVENT;
+
+typedef struct VGPU10QUERYINFO
+{
+    SVGA3dQueryType svgaQueryType;
+    uint32_t        cbDataVMSVGA;
+    D3D11_QUERY     dxQueryType;
+    uint32_t        cbDataD3D11;
+} VGPU10QUERYINFO;
+
+static VGPU10QUERYINFO const *dxQueryInfo(SVGA3dQueryType type)
+{
+    static VGPU10QUERYINFO const aQueryInfo[SVGA3D_QUERYTYPE_MAX] =
+    {
+        { SVGA3D_QUERYTYPE_OCCLUSION,                sizeof(SVGADXOcclusionQueryResult),
+          D3D11_QUERY_OCCLUSION,                     sizeof(UINT64) },
+        { SVGA3D_QUERYTYPE_TIMESTAMP,                sizeof(SVGADXTimestampQueryResult),
+          D3D11_QUERY_TIMESTAMP,                     sizeof(UINT64) },
+        { SVGA3D_QUERYTYPE_TIMESTAMPDISJOINT,        sizeof(SVGADXTimestampDisjointQueryResult),
+          D3D11_QUERY_TIMESTAMP_DISJOINT,            sizeof(D3D11_QUERY_DATA_TIMESTAMP_DISJOINT) },
+        { SVGA3D_QUERYTYPE_PIPELINESTATS,            sizeof(SVGADXPipelineStatisticsQueryResult),
+          D3D11_QUERY_PIPELINE_STATISTICS,           sizeof(D3D11_QUERY_DATA_PIPELINE_STATISTICS) },
+        { SVGA3D_QUERYTYPE_OCCLUSIONPREDICATE,       sizeof(SVGADXOcclusionPredicateQueryResult),
+          D3D11_QUERY_OCCLUSION_PREDICATE,           sizeof(BOOL) },
+        { SVGA3D_QUERYTYPE_STREAMOUTPUTSTATS,        sizeof(SVGADXStreamOutStatisticsQueryResult),
+          D3D11_QUERY_SO_STATISTICS,                 sizeof(D3D11_QUERY_DATA_SO_STATISTICS) },
+        { SVGA3D_QUERYTYPE_STREAMOVERFLOWPREDICATE,  sizeof(SVGADXStreamOutPredicateQueryResult),
+          D3D11_QUERY_SO_OVERFLOW_PREDICATE,         sizeof(BOOL) },
+        { SVGA3D_QUERYTYPE_OCCLUSION64,              sizeof(SVGADXOcclusion64QueryResult),
+          D3D11_QUERY_OCCLUSION,                     sizeof(UINT64) },
+        { SVGA3D_QUERYTYPE_SOSTATS_STREAM0,          sizeof(SVGADXStreamOutStatisticsQueryResult),
+          D3D11_QUERY_SO_STATISTICS_STREAM0,         sizeof(D3D11_QUERY_DATA_SO_STATISTICS) },
+        { SVGA3D_QUERYTYPE_SOSTATS_STREAM1,          sizeof(SVGADXStreamOutStatisticsQueryResult),
+          D3D11_QUERY_SO_STATISTICS_STREAM1,         sizeof(D3D11_QUERY_DATA_SO_STATISTICS) },
+        { SVGA3D_QUERYTYPE_SOSTATS_STREAM2,          sizeof(SVGADXStreamOutStatisticsQueryResult),
+          D3D11_QUERY_SO_STATISTICS_STREAM2,         sizeof(D3D11_QUERY_DATA_SO_STATISTICS) },
+        { SVGA3D_QUERYTYPE_SOSTATS_STREAM3,          sizeof(SVGADXStreamOutStatisticsQueryResult),
+          D3D11_QUERY_SO_STATISTICS_STREAM3,         sizeof(D3D11_QUERY_DATA_SO_STATISTICS) },
+        { SVGA3D_QUERYTYPE_SOP_STREAM0,              sizeof(SVGADXStreamOutPredicateQueryResult),
+          D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0, sizeof(BOOL) },
+        { SVGA3D_QUERYTYPE_SOP_STREAM1,              sizeof(SVGADXStreamOutPredicateQueryResult),
+          D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1, sizeof(BOOL) },
+        { SVGA3D_QUERYTYPE_SOP_STREAM2,              sizeof(SVGADXStreamOutPredicateQueryResult),
+          D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2, sizeof(BOOL) },
+        { SVGA3D_QUERYTYPE_SOP_STREAM3,              sizeof(SVGADXStreamOutPredicateQueryResult),
+          D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3, sizeof(BOOL) },
+    };
+
+    ASSERT_GUEST_RETURN(type < RT_ELEMENTS(aQueryInfo), NULL);
+    return &aQueryInfo[type];
 }
 
@@ -6075 +6104 @@
 
     DXQUERY *pDXQuery = &pDXContext->pBackendDXContext->paQuery[queryId];
+    VGPU10QUERYINFO const *pQueryInfo = dxQueryInfo((SVGA3dQueryType)pEntry->type);
+    if (!pQueryInfo)
+        return VERR_INVALID_PARAMETER;
 
     D3D11_QUERY_DESC desc;
-    desc.Query     = dxQueryType((SVGA3dQueryType)pEntry->type);
+    desc.Query     = pQueryInfo->dxQueryType;
     desc.MiscFlags = 0;
     if (pEntry->flags & SVGA3D_DXQUERY_FLAG_PREDICATEHINT)
@@ -6117 +6149 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXBindQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    RT_NOREF(pBackend, pDXContext, queryId);
-
-    return VINF_SUCCESS;
-}
-
-
+/** @todo queryId makes pDXQuery redundant */
 static int dxBeginQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId, DXQUERY *pDXQuery)
 {
@@ -6135 +6159 @@
     if (pEntry->type == SVGA3D_QUERYTYPE_TIMESTAMP)
         return VINF_SUCCESS;
+
     pDXDevice->pImmediateContext->Begin(pDXQuery->pQuery);
     return VINF_SUCCESS;
@@ -6151 +6176 @@
 
 
-static int dxEndQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, DXQUERY *pDXQuery)
+static int dxGetQueryResult(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId,
+                            SVGADXQueryResultUnion *pQueryResult, uint32_t *pcbOut)
 {
     DXDEVICE *pDXDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
 
-    pDXDevice->pImmediateContext->End(pDXQuery->pQuery);
-    return VINF_SUCCESS;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXEndQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    RT_NOREF(pBackend);
+    typedef union _DXQUERYRESULT
+    {
+        UINT64                               occlusion;
+        UINT64                               timestamp;
+        D3D11_QUERY_DATA_TIMESTAMP_DISJOINT  timestampDisjoint;
+        D3D11_QUERY_DATA_PIPELINE_STATISTICS pipelineStatistics;
+        BOOL                                 occlusionPredicate;
+        D3D11_QUERY_DATA_SO_STATISTICS       soStatistics;
+        BOOL                                 soOverflowPredicate;
+    } DXQUERYRESULT;
 
     DXQUERY *pDXQuery = &pDXContext->pBackendDXContext->paQuery[queryId];
-    int rc = dxEndQuery(pThisCC, pDXContext, pDXQuery);
-    return rc;
-}
-
-
-static int dxReadbackQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId, DXQUERY *pDXQuery,
-                           void *pvData, uint32_t cbData, uint32_t *pcbOut)
+    SVGACOTableDXQueryEntry *pEntry = &pDXContext->cot.paQuery[queryId];
+    VGPU10QUERYINFO const *pQueryInfo = dxQueryInfo((SVGA3dQueryType)pEntry->type);
+    if (!pQueryInfo)
+        return VERR_INVALID_PARAMETER;
+
+    DXQUERYRESULT dxQueryResult;
+    while (pDXDevice->pImmediateContext->GetData(pDXQuery->pQuery, &dxQueryResult, pQueryInfo->cbDataD3D11, 0) != S_OK)
+    {
+        RTThreadYield();
+    }
+
+    /* Copy back the result. */
+    switch (pEntry->type)
+    {
+        case SVGA3D_QUERYTYPE_OCCLUSION:
+            pQueryResult->occ.samplesRendered = (uint32_t)dxQueryResult.occlusion;
+            break;
+        case SVGA3D_QUERYTYPE_TIMESTAMP:
+            pQueryResult->ts.timestamp = dxQueryResult.timestamp;
+            break;
+        case SVGA3D_QUERYTYPE_TIMESTAMPDISJOINT:
+            pQueryResult->tsDisjoint.realFrequency = dxQueryResult.timestampDisjoint.Frequency;
+            pQueryResult->tsDisjoint.disjoint = dxQueryResult.timestampDisjoint.Disjoint;
+            break;
+        case SVGA3D_QUERYTYPE_PIPELINESTATS:
+            pQueryResult->pipelineStats.inputAssemblyVertices     = dxQueryResult.pipelineStatistics.IAVertices;
+            pQueryResult->pipelineStats.inputAssemblyPrimitives   = dxQueryResult.pipelineStatistics.IAPrimitives;
+            pQueryResult->pipelineStats.vertexShaderInvocations   = dxQueryResult.pipelineStatistics.VSInvocations;
+            pQueryResult->pipelineStats.geometryShaderInvocations = dxQueryResult.pipelineStatistics.GSInvocations;
+            pQueryResult->pipelineStats.geometryShaderPrimitives  = dxQueryResult.pipelineStatistics.GSPrimitives;
+            pQueryResult->pipelineStats.clipperInvocations        = dxQueryResult.pipelineStatistics.CInvocations;
+            pQueryResult->pipelineStats.clipperPrimitives         = dxQueryResult.pipelineStatistics.CPrimitives;
+            pQueryResult->pipelineStats.pixelShaderInvocations    = dxQueryResult.pipelineStatistics.PSInvocations;
+            pQueryResult->pipelineStats.hullShaderInvocations     = dxQueryResult.pipelineStatistics.HSInvocations;
+            pQueryResult->pipelineStats.domainShaderInvocations   = dxQueryResult.pipelineStatistics.DSInvocations;
+            pQueryResult->pipelineStats.computeShaderInvocations  = dxQueryResult.pipelineStatistics.CSInvocations;
+            break;
+        case SVGA3D_QUERYTYPE_OCCLUSIONPREDICATE:
+            pQueryResult->occPred.anySamplesRendered = dxQueryResult.occlusionPredicate;
+            break;
+        case SVGA3D_QUERYTYPE_STREAMOUTPUTSTATS:
+        case SVGA3D_QUERYTYPE_SOSTATS_STREAM0:
+        case SVGA3D_QUERYTYPE_SOSTATS_STREAM1:
+        case SVGA3D_QUERYTYPE_SOSTATS_STREAM2:
+        case SVGA3D_QUERYTYPE_SOSTATS_STREAM3:
+            pQueryResult->soStats.numPrimitivesWritten  = dxQueryResult.soStatistics.NumPrimitivesWritten;
+            pQueryResult->soStats.numPrimitivesRequired = dxQueryResult.soStatistics.PrimitivesStorageNeeded;
+            break;
+        case SVGA3D_QUERYTYPE_STREAMOVERFLOWPREDICATE:
+        case SVGA3D_QUERYTYPE_SOP_STREAM0:
+        case SVGA3D_QUERYTYPE_SOP_STREAM1:
+        case SVGA3D_QUERYTYPE_SOP_STREAM2:
+        case SVGA3D_QUERYTYPE_SOP_STREAM3:
+            pQueryResult->soPred.overflowed = dxQueryResult.soOverflowPredicate;
+            break;
+        case SVGA3D_QUERYTYPE_OCCLUSION64:
+            pQueryResult->occ64.samplesRendered = dxQueryResult.occlusion;
+            break;
+    }
+
+    *pcbOut = pQueryInfo->cbDataVMSVGA;
+    return VINF_SUCCESS;
+}
+
+static int dxEndQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId,
+                      SVGADXQueryResultUnion *pQueryResult, uint32_t *pcbOut)
 {
     DXDEVICE *pDXDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
 
-    SVGACOTableDXQueryEntry *pEntry = &pDXContext->cot.paQuery[queryId];
-
-    uint32_t cbRequired;
-    switch (pEntry->type)
-    {
-        case SVGA3D_QUERYTYPE_OCCLUSION:               cbRequired = sizeof(UINT64); break;
-        case SVGA3D_QUERYTYPE_TIMESTAMP:               cbRequired = sizeof(UINT64); break;
-        case SVGA3D_QUERYTYPE_TIMESTAMPDISJOINT:       cbRequired = sizeof(D3D11_QUERY_DATA_TIMESTAMP_DISJOINT); break;
-        case SVGA3D_QUERYTYPE_PIPELINESTATS:           cbRequired = sizeof(D3D11_QUERY_DATA_PIPELINE_STATISTICS); break;
-        case SVGA3D_QUERYTYPE_OCCLUSIONPREDICATE:      cbRequired = sizeof(BOOL); break;
-        case SVGA3D_QUERYTYPE_STREAMOUTPUTSTATS:       cbRequired = sizeof(D3D11_QUERY_DATA_SO_STATISTICS); break;
-        case SVGA3D_QUERYTYPE_STREAMOVERFLOWPREDICATE: cbRequired = sizeof(BOOL); break;
-        case SVGA3D_QUERYTYPE_OCCLUSION64:             cbRequired = sizeof(UINT64); break;
-        case SVGA3D_QUERYTYPE_SOSTATS_STREAM0:         cbRequired = sizeof(D3D11_QUERY_DATA_SO_STATISTICS); break;
-        case SVGA3D_QUERYTYPE_SOSTATS_STREAM1:         cbRequired = sizeof(D3D11_QUERY_DATA_SO_STATISTICS); break;
-        case SVGA3D_QUERYTYPE_SOSTATS_STREAM2:         cbRequired = sizeof(D3D11_QUERY_DATA_SO_STATISTICS); break;
-        case SVGA3D_QUERYTYPE_SOSTATS_STREAM3:         cbRequired = sizeof(D3D11_QUERY_DATA_SO_STATISTICS); break;
-        case SVGA3D_QUERYTYPE_SOP_STREAM0:             cbRequired = sizeof(BOOL); break;
-        case SVGA3D_QUERYTYPE_SOP_STREAM1:             cbRequired = sizeof(BOOL); break;
-        case SVGA3D_QUERYTYPE_SOP_STREAM2:             cbRequired = sizeof(BOOL); break;
-        case SVGA3D_QUERYTYPE_SOP_STREAM3:             cbRequired = sizeof(BOOL); break;
-        default:
-            AssertFailedReturn(VERR_INVALID_STATE);
-    }
-
-    ASSERT_GUEST_RETURN(cbData > cbRequired, VERR_INVALID_PARAMETER);
-
-    while (pDXDevice->pImmediateContext->GetData(pDXQuery->pQuery, pvData, cbRequired, 0) != S_OK)
-    {
-    }
-
-    *pcbOut = cbRequired;
-    return VINF_SUCCESS;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXReadbackQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext,
-                                                     SVGA3dQueryId queryId, void *pvData, uint32_t cbData, uint32_t *pcbOut)
+    DXQUERY *pDXQuery = &pDXContext->pBackendDXContext->paQuery[queryId];
+    pDXDevice->pImmediateContext->End(pDXQuery->pQuery);
+
+    /** @todo Consider issuing QueryEnd and getting data later in FIFO thread loop. */
+    return dxGetQueryResult(pThisCC, pDXContext, queryId, pQueryResult, pcbOut);
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXEndQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext,
+                                                SVGA3dQueryId queryId, SVGADXQueryResultUnion *pQueryResult, uint32_t *pcbOut)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
     RT_NOREF(pBackend);
 
-    DXQUERY *pDXQuery = &pDXContext->pBackendDXContext->paQuery[queryId];
-    int rc = dxReadbackQuery(pThisCC, pDXContext, queryId, pDXQuery, pvData, cbData, pcbOut);
+    int rc = dxEndQuery(pThisCC, pDXContext, queryId, pQueryResult, pcbOut);
     return rc;
 }
@@ -7951 +8008 @@
                 p->pfnDXDefineQuery               = vmsvga3dBackDXDefineQuery;
                 p->pfnDXDestroyQuery              = vmsvga3dBackDXDestroyQuery;
-                p->pfnDXBindQuery                 = vmsvga3dBackDXBindQuery;
                 p->pfnDXBeginQuery                = vmsvga3dBackDXBeginQuery;
                 p->pfnDXEndQuery                  = vmsvga3dBackDXEndQuery;
-                p->pfnDXReadbackQuery             = vmsvga3dBackDXReadbackQuery;
                 p->pfnDXSetPredication            = vmsvga3dBackDXSetPredication;
                 p->pfnDXSetSOTargets              = vmsvga3dBackDXSetSOTargets;

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

@@ -447 +447 @@
     DECLCALLBACKMEMBER(int, pfnDXDefineQuery,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId, SVGACOTableDXQueryEntry const *pEntry));
     DECLCALLBACKMEMBER(int, pfnDXDestroyQuery,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId));
-    DECLCALLBACKMEMBER(int, pfnDXBindQuery,                 (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId));
     DECLCALLBACKMEMBER(int, pfnDXBeginQuery,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId));
-    DECLCALLBACKMEMBER(int, pfnDXEndQuery,                  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId));
-    DECLCALLBACKMEMBER(int, pfnDXReadbackQuery,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId, void *pvData, uint32_t cbData, uint32_t *pcbOut));
+    DECLCALLBACKMEMBER(int, pfnDXEndQuery,                  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dQueryId queryId, SVGADXQueryResultUnion *pQueryResult, uint32_t *pcbOut));
     DECLCALLBACKMEMBER(int, pfnDXSetPredication,            (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXSetSOTargets,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t cSoTarget, SVGA3dSoTarget const *paSoTarget));