[VP] Enable Bindless Surface State Dump

add bindless surface dump

Author: peiyigu-intel

media_common/agnostic/common/os/mos_os.h

@@ -559,6 +559,8 @@ struct MosStreamState
     bool  dumpCommandBufferAsMessages           = false;    //!< Indicates that the command buffer should be dumped via MOS normal messages
     char  sDirName[MOS_MAX_HLT_FILENAME_LEN]    = {0};      //!< Dump Directory name - maximum 260 bytes length
     std::vector<INDIRECT_STATE_INFO> indirectStateInfo                     = {};
+    std::vector<uint8_t *>           bindlessSurfaceStateInfo              = {};
+    uint32_t                         bindlessSurfaceStateSize              = 0;
 #endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
 
 #if _DEBUG || _RELEASE_INTERNAL
@@ -969,6 +971,11 @@ typedef struct _MOS_INTERFACE
         uint32_t            *gfxAddressTop,
         const char          *stateName);
 
+    void (*pfnAddBindlessSurfaceStateInfo)(
+        PMOS_INTERFACE          pOsInterface,
+        std::vector<uint8_t *> &bindlessSurfaceState,
+        uint32_t                surfaceStateSize);
+
     #define pfnFreeResource(pOsInterface, pResource) \
        pfnFreeResource(pOsInterface, __FUNCTION__, __FILE__, __LINE__, pResource)
 

media_common/agnostic/common/renderhal/surface_state_heap_mgr.h

@@ -83,9 +83,9 @@ class SurfaceStateHeapManager
 
     MOS_STATUS DestroyHeap();
 
-    MOS_STATUS AssignSurfaceState();
+    MOS_STATUS AssignSurfaceState(uint32_t surfaceStateEntryIndex, uint32_t &offset, uint8_t *&curSurfaceStatePtr, PMOS_RESOURCE &stateHeap, int32_t &surfaceStateIndex);
 
-    MOS_STATUS AssignUsedSurfaceState(int32_t surfaceStateEntryIndex);
+    MOS_STATUS GetSurfaceStateDump(std::vector<uint8_t *> &dump);
 
     ~SurfaceStateHeapManager();
 

media_softlet/agnostic/common/os/mos_interface.h

@@ -525,6 +525,24 @@ class MosInterface
         MOS_GPU_NODE          gpuNode,
         const char            *filePathPrefix);
 
+    //!
+    //! \brief    Dump Bindless Surface State
+    //!
+    //! \param    [in] streamState
+    //!           Handle of Os Stream State
+    //! \param    [in] gpuNode
+    //!           Gpu node.
+    //! \param    [in] filePathPrefix
+    //!           The prefix for indirect state dump file.
+    //!
+    //! \return   MOS_STATUS
+    //!           Return MOS_STATUS_SUCCESS if successful, otherwise failed
+    //!
+    static MOS_STATUS DumpBindlessSurfaceState(
+        MOS_STREAM_HANDLE streamState,
+        MOS_GPU_NODE      gpuNode,
+        const char       *filePathPrefix);
+
     //!
     //! \brief    Dump Command Buffer
     //! \details  [Cmd Buffer Interface] Dump an existing cmd buffer

media_softlet/agnostic/common/os/mos_os.cpp

@@ -461,6 +461,21 @@ MOS_STATUS Mos_GetPlatformName(
     return MOS_STATUS_SUCCESS;
 }
 
+void Mos_AddBindlessSurfaceStateInfo(
+    PMOS_INTERFACE          pOsInterface,
+    std::vector<uint8_t *> &bindlessSurfaceState,
+    uint32_t                surfaceStateSize)
+{
+    MOS_OS_CHK_NULL_NO_STATUS_RETURN(pOsInterface);
+    if (pOsInterface->apoMosEnabled)
+    {
+        MOS_OS_CHK_NULL_NO_STATUS_RETURN(pOsInterface->osStreamState);
+        pOsInterface->osStreamState->bindlessSurfaceStateInfo = std::move(bindlessSurfaceState);
+        pOsInterface->osStreamState->bindlessSurfaceStateSize = surfaceStateSize;
+    }
+    return;
+}
+
 void Mos_AddIndirectState(
     PMOS_INTERFACE      pOsInterface,
     uint32_t            stateSize,
@@ -672,6 +687,7 @@ MOS_STATUS Mos_DumpCommandBufferInit(
     // Setup member function and variable.
     pOsInterface->pfnDumpCommandBuffer  = Mos_DumpCommandBuffer;
     pOsInterface->pfnAddIndirectState   = Mos_AddIndirectState;
+    pOsInterface->pfnAddBindlessSurfaceStateInfo = Mos_AddBindlessSurfaceStateInfo;
 
     // Check if command buffer dump was enabled in user feature.
     ReadUserSetting(

media_softlet/agnostic/common/renderhal/renderhal.cpp

@@ -3068,16 +3068,7 @@ MOS_STATUS RenderHal_AssignSurfaceState(
             return eStatus;
         }
         MHW_RENDERHAL_CHK_NULL_RETURN(pStateHeap->surfaceStateMgr);
-        MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->AssignSurfaceState());
-        SURFACE_STATES_HEAP_OBJ *sufStateHeap = pStateHeap->surfaceStateMgr->m_surfStateHeap;
-        MHW_RENDERHAL_CHK_NULL_RETURN(sufStateHeap);
-        MHW_RENDERHAL_CHK_NULL_RETURN(sufStateHeap->pLockedOsResourceMem);
-        MHW_RENDERHAL_CHK_VALUE_RETURN(Mos_ResourceIsNull(&sufStateHeap->osResource), false);
-        dwOffset          = sufStateHeap->uiCurState * sufStateHeap->uiInstanceSize;
-        pCurSurfaceState  = sufStateHeap->pLockedOsResourceMem + dwOffset;
-        stateHeap         = &sufStateHeap->osResource;
-        surfaceStateIndex = sufStateHeap->uiCurState;
-        MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->AssignUsedSurfaceState(pStateHeap->iCurrentSurfaceState));
+        MHW_RENDERHAL_CHK_STATUS_RETURN(pStateHeap->surfaceStateMgr->AssignSurfaceState(pStateHeap->iCurrentSurfaceState, dwOffset, pCurSurfaceState, stateHeap, surfaceStateIndex));
         // Obtain new surface entry and initialize
         iSurfaceEntry = pStateHeap->iCurrentSurfaceState;
         ++pStateHeap->iCurrentSurfaceState;
@@ -5766,7 +5757,7 @@ MOS_STATUS RenderHal_SendBindlessSurfaces(
 
     MHW_RENDERHAL_CHK_VALUE_RETURN(pStateHeap->surfaceStateMgr->m_heapStatus, SURFACE_STATE_USED_HEAP_INITIALIZED);
 
-     for (const auto &pair : pStateHeap->surfaceStateMgr->m_usedStates)
+    for (const auto &pair : pStateHeap->surfaceStateMgr->m_usedStates)
     {
         uint32_t surfaceStateIndex      = pair.first;
         uint32_t surfaceStateEntryIndex = pair.second;
@@ -5784,6 +5775,21 @@ MOS_STATUS RenderHal_SendBindlessSurfaces(
 
     pStateHeap->surfaceStateMgr->m_heapStatus = SURFACE_STATE_USED_HEAP_SENT;
 
+#if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
+    if (pOsInterface->pfnAddBindlessSurfaceStateInfo)
+    {
+        std::vector<uint8_t *> dumpInfo;
+        if (pStateHeap->surfaceStateMgr->GetSurfaceStateDump(dumpInfo) == MOS_STATUS_SUCCESS)
+        {
+            pOsInterface->pfnAddBindlessSurfaceStateInfo(pOsInterface, dumpInfo, pStateHeap->surfaceStateMgr->m_surfStateHeap->uiInstanceSize);
+        }
+        else
+        {
+            MHW_RENDERHAL_ASSERTMESSAGE("Dump Bindless Surface State Fail");
+        }
+    }
+#endif
+
     return eStatus;
 }
 

media_softlet/agnostic/common/renderhal/surface_state_heap_mgr.cpp

@@ -113,6 +113,7 @@ MOS_STATUS SurfaceStateHeapManager::DestroyHeap()
                 m_osInterface->pfnUnlockResource(
                     m_osInterface,
                     &m_surfStateHeap->osResource);
+                m_surfStateHeap->pLockedOsResourceMem = nullptr;
             }
 
             m_osInterface->pfnFreeResource(
@@ -184,7 +185,7 @@ void SurfaceStateHeapManager::RefreshSync()
     m_surfHeapInUse = iInstanceInUse;
 }
 
-MOS_STATUS SurfaceStateHeapManager::AssignSurfaceState()
+MOS_STATUS SurfaceStateHeapManager::AssignSurfaceState(uint32_t surfaceStateEntryIndex, uint32_t &offset, uint8_t *&curSurfaceStatePtr, PMOS_RESOURCE &stateHeap, int32_t &surfaceStateIndex)
 {
     VP_FUNC_CALL();
 
@@ -193,7 +194,6 @@ MOS_STATUS SurfaceStateHeapManager::AssignSurfaceState()
 
     SURFACE_STATES_OBJ      *pSurfStateCurObj;
     SURFACE_STATES_HEAP_OBJ *pSurfStateHeap;
-    uint32_t                 uiOffset;
 
     MHW_FUNCTION_ENTER;
     MHW_CHK_NULL_RETURN(m_surfStateHeap);
@@ -264,15 +264,29 @@ MOS_STATUS SurfaceStateHeapManager::AssignSurfaceState()
     pSurfStateHeap->uiNextState = (pSurfStateHeap->uiNextState + 1) % MAX_SURFACE_STATES;
 
     //Clean the memory of current veboxheap to avoid the history states
-    uiOffset = pSurfStateHeap->uiCurState * pSurfStateHeap->uiInstanceSize;
-    MOS_ZeroMemory(pSurfStateHeap->pLockedOsResourceMem + uiOffset, pSurfStateHeap->uiInstanceSize);
+    offset = pSurfStateHeap->uiCurState * pSurfStateHeap->uiInstanceSize;
+    MOS_ZeroMemory(pSurfStateHeap->pLockedOsResourceMem + offset, pSurfStateHeap->uiInstanceSize);
+
+    curSurfaceStatePtr = pSurfStateHeap->pLockedOsResourceMem + offset;
+    stateHeap          = &pSurfStateHeap->osResource;
+    surfaceStateIndex  = pSurfStateHeap->uiCurState;
+
+    m_usedStates.insert(std::make_pair(surfaceStateIndex, surfaceStateEntryIndex));
 
     return eStatus;
 }
 
-MOS_STATUS SurfaceStateHeapManager::AssignUsedSurfaceState(int32_t surfaceStateEntryIndex)
+MOS_STATUS SurfaceStateHeapManager::GetSurfaceStateDump(std::vector<uint8_t *> &dump)
 {
+    std::stringstream ss;
+    dump.clear();
     MHW_CHK_NULL_RETURN(m_surfStateHeap);
-    m_usedStates.insert(std::make_pair(m_surfStateHeap->uiCurState, surfaceStateEntryIndex));
+    MHW_CHK_NULL_RETURN(m_surfStateHeap->pLockedOsResourceMem);
+    for (const auto &pair : m_usedStates)
+    {
+        uint32_t surfaceIndex = pair.first;
+        uint8_t *data         = m_surfStateHeap->pLockedOsResourceMem + m_surfStateHeap->uiInstanceSize * surfaceIndex;
+        dump.push_back(data);
+    }
     return MOS_STATUS_SUCCESS;
 }

media_softlet/linux/common/os/mos_interface.cpp

@@ -773,6 +773,48 @@ MOS_STATUS MosInterface::DumpIndirectStates(MOS_STREAM_HANDLE streamState, const
     return eStatus;
 }
 
+MOS_STATUS MosInterface::DumpBindlessSurfaceState(
+    MOS_STREAM_HANDLE streamState,
+    MOS_GPU_NODE      gpuNode,
+    const char       *filePathPrefix)
+{
+    MOS_OS_CHK_NULL_RETURN(filePathPrefix);
+
+    if (streamState &&
+        !streamState->bindlessSurfaceStateInfo.empty() &&
+        (MOS_GPU_NODE_COMPUTE == gpuNode || MOS_GPU_NODE_3D == gpuNode))
+    {
+        std::stringstream fileName;
+        fileName << filePathPrefix << "_bindless_surface_state.txt";
+        std::fstream fs;
+        fs.open(fileName.str(), std::ios_base::out | std::ios_base::app);
+        uint32_t dwordCount = streamState->bindlessSurfaceStateSize / 4;
+        for (uint8_t *&ptr : streamState->bindlessSurfaceStateInfo)
+        {
+            uint32_t *data = (uint32_t *)ptr;
+            for (uint32_t i = 0; i < dwordCount; ++i)
+            {
+                if (0 == i % 4)
+                {
+                    if (0 != i)
+                    {
+                        fs << std::endl;
+                    }
+                    fs << "#0    #0";
+                }
+                fs << "    " << std::hex << std::setw(8) << std::setfill('0') << data[i];
+            }
+            fs << std::endl
+               << std::endl;
+        }
+        fs.close();
+        streamState->bindlessSurfaceStateInfo.clear();
+        streamState->bindlessSurfaceStateSize = 0;
+    }
+
+    return MOS_STATUS_SUCCESS;
+}
+
 MOS_STATUS MosInterface::DumpBindingTable(
     MOS_STREAM_HANDLE     streamState,
     COMMAND_BUFFER_HANDLE cmdBuffer,
@@ -963,6 +1005,11 @@ MOS_STATUS MosInterface::DumpCommandBuffer(
             MOS_FreeMemory(pOutputBuffer);
             return eStatus;
         }
+        if ((eStatus = DumpBindlessSurfaceState(streamState, gpuNode, sFileName)) != MOS_STATUS_SUCCESS)
+        {
+            MOS_FreeMemory(pOutputBuffer);
+            return eStatus;
+        }
         if ((eStatus = DumpIndirectStates(streamState, sFileName, currentTime)) != MOS_STATUS_SUCCESS)
         {
             MOS_FreeMemory(pOutputBuffer);