Changeset 106212 in vbox for trunk/src/VBox/VMM/VMMAll/IEMAllThrdRecompiler.cpp

Timestamp:

Oct 3, 2024 2:42:55 AM (2 months ago)

Author:

vboxsync

Message:

VMM/IEM: Some machinery for saving threaded TBs and a program for loading them and running them thru the native recompiler. The program be used for profiling or to check the effect of code changes. bugref:10720

File:

• trunk/src/VBox/VMM/VMMAll/IEMAllThrdRecompiler.cpp (modified) (3 diffs)

trunk/src/VBox/VMM/VMMAll/IEMAllThrdRecompiler.cpp

@@ -440 +440 @@
 
 
+
 /*********************************************************************************************************************************
 *   Translation Block Cache.                                                                                                     *
@@ -661 +662 @@
                     }
                     Log10(("TB lookup: fFlags=%#x GCPhysPc=%RGp: %p (@ %p) - recompiling\n", fFlags, GCPhysPc, pTb, ppTbLookup));
+# ifdef VBOX_WITH_SAVE_THREADED_TBS_FOR_PROFILING
+                    iemThreadedSaveTbForProfiling(pVCpu, pTb);
+# endif
                     return iemNativeRecompile(pVCpu, pTb);
 #else
@@ -2937 +2941 @@
 
 /*********************************************************************************************************************************
+*   Threaded Translation Block Saving and Restoring for Profiling the Native Recompiler                                          *
+*********************************************************************************************************************************/
+#if defined(VBOX_WITH_IEM_NATIVE_RECOMPILER) && defined(VBOX_WITH_SAVE_THREADED_TBS_FOR_PROFILING)
+# include <iprt/message.h>
+
+static const SSMFIELD g_aIemThreadedTbFields[] =
+{
+    SSMFIELD_ENTRY(       IEMTB, cUsed),
+    SSMFIELD_ENTRY(       IEMTB, msLastUsed),
+    SSMFIELD_ENTRY_GCPHYS(IEMTB, GCPhysPc),
+    SSMFIELD_ENTRY(       IEMTB, fFlags),
+    SSMFIELD_ENTRY(       IEMTB, x86.fAttr),
+    SSMFIELD_ENTRY(       IEMTB, cRanges),
+    SSMFIELD_ENTRY(       IEMTB, cInstructions),
+    SSMFIELD_ENTRY(       IEMTB, Thrd.cCalls),
+    SSMFIELD_ENTRY(       IEMTB, cTbLookupEntries),
+    SSMFIELD_ENTRY(       IEMTB, cbOpcodes),
+    SSMFIELD_ENTRY(       IEMTB, FlatPc),
+    SSMFIELD_ENTRY_GCPHYS(IEMTB, aGCPhysPages[0]),
+    SSMFIELD_ENTRY_GCPHYS(IEMTB, aGCPhysPages[1]),
+    SSMFIELD_ENTRY_TERM()
+};
+
+/**
+ * Saves a threaded TB to a dedicated saved state file.
+ */
+static void iemThreadedSaveTbForProfiling(PVMCPU pVCpu, PCIEMTB pTb)
+{
+    /* Only VCPU #0 for now. */
+    if (pVCpu->idCpu != 0)
+        return;
+
+    /*
+     * Get the SSM handle, lazily opening the output file.
+     */
+    PSSMHANDLE const pNil = (PSSMHANDLE)~(uintptr_t)0; Assert(!RT_VALID_PTR(pNil));
+    PSSMHANDLE       pSSM = pVCpu->iem.s.pSsmThreadedTbsForProfiling;
+    if (pSSM && pSSM != pNil)
+    { /* likely */ }
+    else if (pSSM)
+        return;
+    else
+    {
+        pVCpu->iem.s.pSsmThreadedTbsForProfiling = pNil;
+        int rc = SSMR3Open("ThreadedTBsForRecompilerProfiling.sav", NULL, NULL, SSM_OPEN_F_FOR_WRITING, &pSSM);
+        AssertLogRelRCReturnVoid(rc);
+
+        rc = SSMR3WriteFileHeader(pSSM, 1);
+        AssertLogRelRCReturnVoid(rc); /* leaks SSM handle, but whatever. */
+
+        rc = SSMR3WriteUnitBegin(pSSM, "threaded-tbs", 1, 0);
+        AssertLogRelRCReturnVoid(rc); /* leaks SSM handle, but whatever. */
+        pVCpu->iem.s.pSsmThreadedTbsForProfiling = pSSM;
+    }
+
+    /*
+     * Do the actual saving.
+     */
+    SSMR3PutU32(pSSM, 0); /* Indicates that another TB follows. */
+
+    /* The basic structure. */
+    SSMR3PutStructEx(pSSM, pTb, sizeof(*pTb), 0 /*fFlags*/, g_aIemThreadedTbFields, NULL);
+
+    /* The ranges. */
+    for (uint32_t iRange = 0; iRange < pTb->cRanges; iRange++)
+    {
+        SSMR3PutU16(pSSM, pTb->aRanges[iRange].offOpcodes);
+        SSMR3PutU16(pSSM, pTb->aRanges[iRange].cbOpcodes);
+        SSMR3PutU16(pSSM, pTb->aRanges[iRange].offPhysPage | (pTb->aRanges[iRange].idxPhysPage << 14));
+    }
+
+    /* The opcodes. */
+    SSMR3PutMem(pSSM, pTb->pabOpcodes, pTb->cbOpcodes);
+
+    /* The threaded call table. */
+    int rc = SSMR3PutMem(pSSM, pTb->Thrd.paCalls, sizeof(*pTb->Thrd.paCalls) * pTb->Thrd.cCalls);
+    AssertLogRelMsgStmt(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), pVCpu->iem.s.pSsmThreadedTbsForProfiling = pNil);
+}
+
+
+/**
+ * Called by IEMR3Term to finish any open profile files.
+ *
+ * @note This is not called on the EMT for @a pVCpu, but rather on the thread
+ *       driving the VM termination.
+ */
+DECLHIDDEN(void) iemThreadedSaveTbForProfilingCleanup(PVMCPU pVCpu)
+{
+    PSSMHANDLE const pSSM = pVCpu->iem.s.pSsmThreadedTbsForProfiling;
+    pVCpu->iem.s.pSsmThreadedTbsForProfiling = NULL;
+    if (RT_VALID_PTR(pSSM))
+    {
+        /* Indicate that this is the end.   */
+        SSMR3PutU32(pSSM, UINT32_MAX);
+
+        int rc = SSMR3WriteUnitComplete(pSSM);
+        AssertLogRelRC(rc);
+        rc = SSMR3WriteFileFooter(pSSM);
+        AssertLogRelRC(rc);
+        rc = SSMR3Close(pSSM);
+        AssertLogRelRC(rc);
+    }
+}
+
+#endif /* VBOX_WITH_IEM_NATIVE_RECOMPILER && VBOX_WITH_SAVE_THREADED_TBS_FOR_PROFILING */
+
+#ifdef IN_RING3
+/**
+ * API use to process what iemThreadedSaveTbForProfiling() saved.
+ *
+ * @note Do not mix build types or revisions. Local changes between saving the
+ *       TBs and calling this API may cause unexpected trouble.
+ */
+VMMR3DECL(int) IEMR3ThreadedProfileRecompilingSavedTbs(PVM pVM, const char *pszFilename, uint32_t cMinTbs)
+{
+# if defined(VBOX_WITH_IEM_NATIVE_RECOMPILER) && defined(VBOX_WITH_SAVE_THREADED_TBS_FOR_PROFILING)
+    PVMCPU const pVCpu = pVM->apCpusR3[0];
+
+    /* We need to keep an eye on the TB allocator. */
+    PIEMTBALLOCATOR const pTbAllocator = pVCpu->iem.s.pTbAllocatorR3;
+
+    /*
+     * Load the TBs from the file.
+     */
+    PSSMHANDLE pSSM = NULL;
+    int rc = SSMR3Open(pszFilename, NULL, NULL, 0, &pSSM);
+    if (RT_SUCCESS(rc))
+    {
+        uint32_t cTbs     = 0;
+        PIEMTB   pTbHead  = NULL;
+        PIEMTB  *ppTbTail = &pTbHead;
+        uint32_t uVersion;
+        rc = SSMR3Seek(pSSM, "threaded-tbs", 0, &uVersion);
+        if (RT_SUCCESS(rc))
+        {
+            for (;; cTbs++)
+            {
+                /* Check for the end tag. */
+                uint32_t uTag = 0;
+                rc = SSMR3GetU32(pSSM, &uTag);
+                AssertRCBreak(rc);
+                if (uTag == UINT32_MAX)
+                    break;
+                AssertBreakStmt(uTag == 0, rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+
+                /* Do we have room for another TB? */
+                if (pTbAllocator->cInUseTbs + 2 >= pTbAllocator->cMaxTbs)
+                {
+                    RTMsgInfo("Too many TBs to load, stopping loading early.\n");
+                    break;
+                }
+
+                /* Allocate a new TB. */
+                PIEMTB pTb = iemTbAllocatorAlloc(pVCpu, true /*fThreaded*/);
+                AssertBreakStmt(uTag == 0, rc = VERR_OUT_OF_RESOURCES);
+
+                uint8_t const idxAllocChunk = pTb->idxAllocChunk;
+                RT_ZERO(*pTb);
+                pTb->idxAllocChunk = idxAllocChunk;
+
+                rc = SSMR3GetStructEx(pSSM, pTb, sizeof(*pTb), 0, g_aIemThreadedTbFields, NULL);
+                if (RT_SUCCESS(rc))
+                {
+                    AssertStmt(pTb->Thrd.cCalls      > 0 && pTb->Thrd.cCalls      <= _8K, rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+                    AssertStmt(pTb->cbOpcodes        > 0 && pTb->cbOpcodes        <= _8K, rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+                    AssertStmt(pTb->cRanges          > 0 && pTb->cRanges <= RT_ELEMENTS(pTb->aRanges), rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+                    AssertStmt(pTb->cTbLookupEntries > 0 && pTb->cTbLookupEntries <= _1K, rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+
+                    if (RT_SUCCESS(rc))
+                        for (uint32_t iRange = 0; iRange < pTb->cRanges; iRange++)
+                        {
+                            SSMR3GetU16(pSSM, &pTb->aRanges[iRange].offOpcodes);
+                            SSMR3GetU16(pSSM, &pTb->aRanges[iRange].cbOpcodes);
+                            uint16_t uTmp = 0;
+                            rc = SSMR3GetU16(pSSM, &uTmp);
+                            AssertRCBreak(rc);
+                            pTb->aRanges[iRange].offPhysPage = uTmp & GUEST_PAGE_OFFSET_MASK;
+                            pTb->aRanges[iRange].idxPhysPage = uTmp >> 14;
+
+                            AssertBreakStmt(pTb->aRanges[iRange].idxPhysPage <= RT_ELEMENTS(pTb->aGCPhysPages),
+                                            rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+                            AssertBreakStmt(pTb->aRanges[iRange].offOpcodes  < pTb->cbOpcodes,
+                                            rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+                            AssertBreakStmt(pTb->aRanges[iRange].offOpcodes + pTb->aRanges[iRange].cbOpcodes <= pTb->cbOpcodes,
+                                            rc = VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+                        }
+
+                    if (RT_SUCCESS(rc))
+                    {
+                        pTb->Thrd.paCalls = (PIEMTHRDEDCALLENTRY)RTMemAllocZ(sizeof(IEMTHRDEDCALLENTRY) * pTb->Thrd.cCalls);
+                        if (pTb->Thrd.paCalls)
+                        {
+                            size_t const cbTbLookup = pTb->cTbLookupEntries * sizeof(PIEMTB);
+                            Assert(cbTbLookup > 0);
+                            size_t const cbOpcodes  = pTb->cbOpcodes;
+                            Assert(cbOpcodes > 0);
+                            size_t const cbBoth     = cbTbLookup + RT_ALIGN_Z(cbOpcodes, sizeof(PIEMTB));
+                            uint8_t * const pbBoth  = (uint8_t *)RTMemAllocZ(cbBoth);
+                            if (pbBoth)
+                            {
+                                pTb->pabOpcodes = &pbBoth[cbTbLookup];
+                                SSMR3GetMem(pSSM, pTb->pabOpcodes, pTb->cbOpcodes);
+                                rc = SSMR3GetMem(pSSM, pTb->Thrd.paCalls, sizeof(IEMTHRDEDCALLENTRY) * pTb->Thrd.cCalls);
+                                if (RT_SUCCESS(rc))
+                                {
+                                    *ppTbTail = pTb;
+                                    ppTbTail  = &pTb->pNext;
+                                    continue;
+                                }
+                            }
+                            else
+                                rc = VERR_NO_MEMORY;
+                            RTMemFree(pTb->Thrd.paCalls);
+                        }
+                        else
+                            rc = VERR_NO_MEMORY;
+                    }
+                }
+                iemTbAllocatorFree(pVCpu, pTb);
+                break;
+            }
+            if (RT_FAILURE(rc))
+                RTMsgError("Load error: %Rrc (cTbs=%u)", rc, cTbs);
+        }
+        else
+            RTMsgError("SSMR3Seek failed on '%s': %Rrc", pszFilename, rc);
+        SSMR3Close(pSSM);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Recompile the TBs.
+             */
+            if (pTbHead)
+            {
+                RTMsgInfo("Loaded %u TBs\n", cTbs);
+                if (cTbs < cMinTbs)
+                {
+                    RTMsgInfo("Duplicating TBs to reach %u TB target\n", cMinTbs);
+                    for (PIEMTB pTb = pTbHead;
+                         cTbs < cMinTbs && pTbAllocator->cInUseTbs + 2 <= pTbAllocator->cMaxTbs;
+                         pTb = pTb->pNext)
+                    {
+                        PIEMTB pTbCopy = iemThreadedTbDuplicate(pVM, pVCpu, pTbHead);
+                        if (!pTbCopy)
+                            break;
+                        *ppTbTail = pTbCopy;
+                        ppTbTail  = &pTbCopy->pNext;
+                        cTbs++;
+                    }
+                }
+
+                PIEMTB pTbWarmup = iemThreadedTbDuplicate(pVM, pVCpu, pTbHead);
+                if (pTbWarmup)
+                {
+                    iemNativeRecompile(pVCpu, pTbWarmup);
+                    RTThreadSleep(512); /* to make the start visible in the profiler. */
+                    RTMsgInfo("Ready, set, go!\n");
+
+                    if ((pTbWarmup->fFlags & IEMTB_F_TYPE_MASK) == IEMTB_F_TYPE_NATIVE)
+                    {
+                        uint32_t       cFailed = 0;
+                        uint64_t const nsStart = RTTimeNanoTS();
+                        for (PIEMTB pTb = pTbHead; pTb; pTb = pTb->pNext)
+                        {
+                            iemNativeRecompile(pVCpu, pTb);
+                            if ((pTb->fFlags & IEMTB_F_TYPE_MASK) != IEMTB_F_TYPE_NATIVE)
+                                cFailed++;
+                        }
+                        uint64_t const cNsElapsed = RTTimeNanoTS() - nsStart;
+                        RTMsgInfo("Recompiled %u TBs in %'RU64 ns - averaging %'RU64 ns/TB\n",
+                                  cTbs, cNsElapsed, (cNsElapsed + cTbs - 1) / cTbs);
+                        if (cFailed)
+                        {
+                            RTMsgError("Unforuntately %u TB failed!", cFailed);
+                            rc = VERR_GENERAL_FAILURE;
+                        }
+                        RTThreadSleep(128); /* Another gap in the profiler timeline.  */
+                    }
+                    else
+                    {
+                        RTMsgError("Failed to recompile the first TB!");
+                        rc = VERR_GENERAL_FAILURE;
+                    }
+                }
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+            else
+            {
+                RTMsgError("'%s' contains no TBs!", pszFilename);
+                rc = VERR_NO_DATA;
+            }
+        }
+    }
+    else
+        RTMsgError("SSMR3Open failed on '%s': %Rrc", pszFilename, rc);
+    return rc;
+
+# else
+    RT_NOREF(pVM, pszFilename, cMinTbs);
+    return VERR_NOT_IMPLEMENTED;
+# endif
+}
+#endif /* IN_RING3 */
+
+
+/*********************************************************************************************************************************
 *   Recompiled Execution Core                                                                                                    *
 *********************************************************************************************************************************/