Changeset 15411 in vbox

Timestamp:

Dec 13, 2008 3:30:58 AM (16 years ago)

Author:

vboxsync

Message:

VMM: Working around set overflows caused by the page pool.

Location:

trunk

Files:

• include/VBox/pgm.h (modified) (1 diff)
• src/VBox/VMM/PGM.cpp (modified) (2 diffs)
• src/VBox/VMM/PGMInternal.h (modified) (8 diffs)
• src/VBox/VMM/VMMAll/PGMAllPool.cpp (modified) (4 diffs)
• src/VBox/VMM/VMMR0/PGMR0DynMap.cpp (modified) (9 diffs)

trunk/include/VBox/pgm.h

@@ -455 +455 @@
 VMMDECL(void)       PGMDynMapFlushAutoSet(PVMCPU pVCpu);
 VMMDECL(void)       PGMDynMapMigrateAutoSet(PVMCPU pVCpu);
+VMMDECL(uint32_t)   PGMDynMapPushAutoSubset(PVMCPU pVCpu);
+VMMDECL(void)       PGMDynMapPopAutoSubset(PVMCPU pVCpu, uint32_t iPrevSubset);
 
 /**

trunk/src/VBox/VMM/PGM.cpp

@@ -1609 +1609 @@
     STAM_REG(pVM, &pPGM->StatR0DynMapPage,                  STAMTYPE_COUNTER, "/PGM/R0/DynMapPage",                 STAMUNIT_OCCURENCES,     "Calls to pgmR0DynMapPage");
     STAM_REG(pVM, &pPGM->StatR0DynMapSetOptimize,           STAMTYPE_COUNTER, "/PGM/R0/DynMapPage/SetOptimize",     STAMUNIT_OCCURENCES,     "Calls to pgmDynMapOptimizeAutoSet.");
+    STAM_REG(pVM, &pPGM->StatR0DynMapSetSearchFlushes,      STAMTYPE_COUNTER, "/PGM/R0/DynMapPage/SetSearchFlushes",STAMUNIT_OCCURENCES,     "Set search restorting to subset flushes.");
     STAM_REG(pVM, &pPGM->StatR0DynMapSetSearchHits,         STAMTYPE_COUNTER, "/PGM/R0/DynMapPage/SetSearchHits",   STAMUNIT_OCCURENCES,     "Set search hits.");
     STAM_REG(pVM, &pPGM->StatR0DynMapSetSearchMisses,       STAMTYPE_COUNTER, "/PGM/R0/DynMapPage/SetSearchMisses", STAMUNIT_OCCURENCES,     "Set search misses.");
@@ -1620 +1621 @@
     STAM_REG(pVM, &pPGM->StatR0DynMapPageSlowLoopMisses,    STAMTYPE_COUNTER, "/PGM/R0/DynMapPage/SlowLoopMisses",  STAMUNIT_OCCURENCES,     "Misses in the loop path. NonLoopMisses = Slow - SlowLoopHit - SlowLoopMisses");
     //STAM_REG(pVM, &pPGM->StatR0DynMapPageSlowLostHits,      STAMTYPE_COUNTER, "/PGM/R0/DynMapPage/SlowLostHits",    STAMUNIT_OCCURENCES,     "Lost hits.");
+    STAM_REG(pVM, &pPGM->StatR0DynMapSubsets,               STAMTYPE_COUNTER, "/PGM/R0/Subsets",                    STAMUNIT_OCCURENCES,     "Times PGMDynMapPushAutoSubset was called.");
+    STAM_REG(pVM, &pPGM->StatR0DynMapPopFlushes,            STAMTYPE_COUNTER, "/PGM/R0/SubsetPopFlushes",           STAMUNIT_OCCURENCES,     "Times PGMDynMapPopAutoSubset flushes the subset.");
 
     /* GC only: */

trunk/src/VBox/VMM/PGMInternal.h

@@ -1315 +1315 @@
 typedef struct PGMMAPSET
 {
-    /** The index of the current CPU, only valid if the set is open. */
-    int32_t                     iCpu;
-    /** The number of occupied.
+    /** The number of occupied entries.
      * This is PGMMAPSET_CLOSED if the set is closed and we're not supposed to do
      * dynamic mappings. */
     uint32_t                    cEntries;
+    /** The start of the current subset.
+     * This is UINT32_MAX if no subset is currently open. */
+    uint32_t                    iSubset;
+    /** The index of the current CPU, only valid if the set is open. */
+    int32_t                     iCpu;
     /** The entries. */
     PGMMAPSETENTRY              aEntries[32];
@@ -1818 +1821 @@
 
 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
-DECLINLINE(void *) pgmPoolMapPageInlined(PVM pVM, PPGMPOOLPAGE pPage);
+DECLINLINE(void *) pgmPoolMapPageInlined(PVM pVM, PPGMPOOLPAGE pPage, int iLine, const char *pszFile);
 #endif
 
@@ -1832 +1835 @@
  * @remark  There is no need to assert on the result.
  */
-#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
-# define PGMPOOL_PAGE_2_PTR(pVM, pPage)  pgmPoolMapPageInlined(&(pVM)->pgm.s, (pPage))
+#if defined(IN_RC)
+# define PGMPOOL_PAGE_2_PTR(pVM, pPage)  pgmPoolMapPageInlined(&(pVM)->pgm.s, (pPage), __LINE__, 0)
+#elif defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
+# define PGMPOOL_PAGE_2_PTR(pVM, pPage)  pgmPoolMapPageInlined(&(pVM)->pgm.s, (pPage), __LINE__, __PRETTY_FUNCTION__)
 #elif defined(VBOX_STRICT)
 # define PGMPOOL_PAGE_2_PTR(pVM, pPage)  pgmPoolMapPageStrict(pPage)
@@ -1856 +1861 @@
  * @remark  There is no need to assert on the result.
  */
-#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
-# define PGMPOOL_PAGE_2_PTR_BY_PGM(pPGM, pPage)  pgmPoolMapPageInlined((pPGM), (pPage))
+#if defined(IN_RC)
+# define PGMPOOL_PAGE_2_PTR_BY_PGM(pPGM, pPage)  pgmPoolMapPageInlined((pPGM), (pPage), __LINE__, 0)
+#elif defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
+# define PGMPOOL_PAGE_2_PTR_BY_PGM(pPGM, pPage)  pgmPoolMapPageInlined((pPGM), (pPage), __LINE__, __PRETTY_FUNCTION__)
 #else
 # define PGMPOOL_PAGE_2_PTR_BY_PGM(pPGM, pPage)  PGMPOOL_PAGE_2_PTR(PGM2VM(pPGM), pPage)
@@ -2660 +2667 @@
     STAMPROFILE StatR0DynMapHCPage;                 /**< R0: Calls to PGMDynMapHCPage. */
     STAMCOUNTER StatR0DynMapSetOptimize;            /**< R0: Calls to pgmDynMapOptimizeAutoSet. */
+    STAMCOUNTER StatR0DynMapSetSearchFlushes;       /**< R0: Set search restorting to subset flushes. */
     STAMCOUNTER StatR0DynMapSetSearchHits;          /**< R0: Set search hits. */
     STAMCOUNTER StatR0DynMapSetSearchMisses;        /**< R0: Set search misses. */
@@ -2671 +2679 @@
     STAMCOUNTER StatR0DynMapPageSlowLoopMisses;     /**< R0: Misses in the pgmR0DynMapPageSlow search loop. */
     //STAMCOUNTER StatR0DynMapPageSlowLostHits;       /**< R0: Lost hits. */
+    STAMCOUNTER StatR0DynMapSubsets;                /**< R0: Times PGMDynMapPushAutoSubset was called. */
+    STAMCOUNTER StatR0DynMapPopFlushes;             /**< R0: Times PGMDynMapPopAutoSubset flushes the subset. */
 
     /* RC only: */
@@ -4621 +4631 @@
  * @param   pPage       The page.
  */
-DECLINLINE(void *) pgmPoolMapPageInlined(PPGM pPGM, PPGMPOOLPAGE pPage)
+DECLINLINE(void *) pgmPoolMapPageInlined(PPGM pPGM, PPGMPOOLPAGE pPage, int iLine, const char *pszFile)
 {
     if (pPage->idx >= PGMPOOL_IDX_FIRST)
@@ -4634 +4644 @@
         if (RT_SUCCESS(rc))
             return pv;
+        AssertMsgFailed(("%Rrc: %s(%d)\n", rc, pszFile, iLine));
     }
     return pgmPoolMapPageFallback(pPGM, pPage);

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

@@ -3674 +3674 @@
     }
 
+#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
+    /* Start a subset so we won't run out of mapping space. */
+    PVMCPU pVCpu = VMMGetCpu(pPool->CTX_SUFF(pVM));
+    uint32_t iPrevSubset = PGMDynMapPushAutoSubset(pVCpu);
+#endif
+
     /*
      * Nuke the free list and reinsert all pages into it.
@@ -3815 +3821 @@
     }
 
+#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
+    /* Pop the subset. */
+    PGMDynMapPopAutoSubset(pVCpu, iPrevSubset);
+#endif
+
     /*
      * Finally, assert the FF.
@@ -3863 +3874 @@
     }
 
+#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
+    /* Start a subset so we won't run out of mapping space. */
+    PVMCPU pVCpu = VMMGetCpu(pPool->CTX_SUFF(pVM));
+    uint32_t iPrevSubset = PGMDynMapPushAutoSubset(pVCpu);
+#endif
+
     /*
      * Mark the page as being in need of a ASMMemZeroPage().
@@ -3884 +3901 @@
     pgmPoolCacheFlushPage(pPool, pPage);
 #endif /* PGMPOOL_WITH_CACHE */
+
+#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
+    /* Heavy stuff done. */
+    PGMDynMapPopAutoSubset(pVCpu, iPrevSubset);
+#endif
 
 #ifdef PGMPOOL_WITH_MONITORING

trunk/src/VBox/VMM/VMMR0/PGMR0DynMap.cpp

@@ -367 +367 @@
         }
         pSet->cEntries = PGMMAPSET_CLOSED;
+        pSet->iSubset = UINT32_MAX;
         pSet->iCpu = -1;
         memset(&pSet->aiHashTable[0], 0xff, sizeof(pSet->aiHashTable));
@@ -466 +467 @@
                 }
                 pSet->cEntries = PGMMAPSET_CLOSED;
+                pSet->iSubset = UINT32_MAX;
                 pSet->iCpu = -1;
             }
@@ -1498 +1500 @@
 {
     Assert(pVCpu->pgm.s.AutoSet.cEntries == PGMMAPSET_CLOSED);
+    Assert(pVCpu->pgm.s.AutoSet.iSubset == UINT32_MAX);
     pVCpu->pgm.s.AutoSet.cEntries = 0;
     pVCpu->pgm.s.AutoSet.iCpu = RTMpCpuIdToSetIndex(RTMpCpuId());
@@ -1557 +1560 @@
     AssertMsg(cEntries <= RT_ELEMENTS(pSet->aEntries), ("%#x (%u)\n", cEntries, cEntries));
     pSet->cEntries = PGMMAPSET_CLOSED;
+    pSet->iSubset = UINT32_MAX;
     pSet->iCpu = -1;
 
@@ -1587 +1591 @@
     }
 }
-
 
 
@@ -1616 +1619 @@
             {
                 PPGMR0DYNMAP    pThis = g_pPGMR0DynMap;
+                RTSPINLOCKTMP   Tmp = RTSPINLOCKTMP_INITIALIZER;
+                RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
+
                 while (i-- > 0)
                 {
@@ -1624 +1630 @@
                     {
                         RTCpuSetDelByIndex(&pThis->paPages[iPage].PendingSet, iRealCpu);
+                        RTSpinlockRelease(pThis->hSpinlock, &Tmp);
+
                         ASMInvalidatePage(pThis->paPages[iPage].pvPage);
                         STAM_COUNTER_INC(&pVCpu->pVMR0->pgm.s.StatR0DynMapMigrateInvlPg);
+
+                        RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
                     }
                 }
 
+                RTSpinlockRelease(pThis->hSpinlock, &Tmp);
             }
         }
         pSet->iCpu = iRealCpu;
     }
+}
+
+
+/**
+ * Worker function that flushes the current subset.
+ *
+ * This is called when the set is popped or when the set
+ * hash a too high load. As also pointed out elsewhere, the
+ * whole subset thing is a hack for working around code that
+ * accesses too many pages. Like PGMPool.
+ *
+ * @param   pSet        The set which subset to flush.
+ */
+static void pgmDynMapFlushSubset(PPGMMAPSET pSet)
+{
+    uint32_t iSubset = pSet->iSubset;
+    uint32_t i       = pSet->cEntries;
+    Assert(i <= RT_ELEMENTS(pSet->aEntries));
+    if (    i > iSubset
+        &&  i <= RT_ELEMENTS(pSet->aEntries))
+    {
+        pSet->cEntries = iSubset;
+
+        PPGMR0DYNMAP    pThis = g_pPGMR0DynMap;
+        RTSPINLOCKTMP   Tmp   = RTSPINLOCKTMP_INITIALIZER;
+        RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
+
+        while (i-- > iSubset)
+        {
+            uint32_t iPage = pSet->aEntries[i].iPage;
+            Assert(iPage < pThis->cPages);
+            int32_t  cRefs = pSet->aEntries[i].cRefs;
+            Assert(cRefs > 0);
+            pgmR0DynMapReleasePageLocked(pThis, iPage, cRefs);
+
+            pSet->aEntries[i].iPage = UINT16_MAX;
+            pSet->aEntries[i].cRefs = 0;
+        }
+
+        RTSpinlockRelease(pThis->hSpinlock, &Tmp);
+    }
+}
+
+
+/**
+ * Creates a subset.
+ *
+ * A subset is a hack to avoid having to rewrite code that touches a lot of
+ * pages. It prevents the mapping set from being overflowed by automatically
+ * flushing previous mappings when a certain threshold is reached.
+ *
+ * Pages mapped after calling this function are only valid until the next page
+ * is mapped.
+ *
+ * @returns The index of the previous subset. Pass this to
+ *        PGMDynMapPopAutoSubset when poping it.
+ * @param   pVCpu           Pointer to the virtual cpu data.
+ */
+VMMDECL(uint32_t) PGMDynMapPushAutoSubset(PVMCPU pVCpu)
+{
+    PPGMMAPSET      pSet = &pVCpu->pgm.s.AutoSet;
+    AssertReturn(pSet->cEntries != PGMMAPSET_CLOSED, UINT32_MAX);
+    uint32_t        iPrevSubset = pSet->iSubset;
+Assert(iPrevSubset == UINT32_MAX);
+    pSet->iSubset = pSet->cEntries;
+    STAM_COUNTER_INC(&pVCpu->pVMR0->pgm.s.StatR0DynMapSubsets);
+    return iPrevSubset;
+}
+
+
+/**
+ * Pops a subset created by a previous call to PGMDynMapPushAutoSubset.
+ *
+ * @param   pVCpu           Pointer to the virtual cpu data.
+ * @param   iPrevSubset     What PGMDynMapPushAutoSubset returned.
+ */
+VMMDECL(void) PGMDynMapPopAutoSubset(PVMCPU pVCpu, uint32_t iPrevSubset)
+{
+    PPGMMAPSET      pSet = &pVCpu->pgm.s.AutoSet;
+    AssertReturnVoid(pSet->cEntries != PGMMAPSET_CLOSED);
+    AssertReturnVoid(pSet->iSubset <= iPrevSubset || iPrevSubset == UINT32_MAX);
+Assert(iPrevSubset == UINT32_MAX);
+    if (    pSet->cEntries >= RT_ELEMENTS(pSet->aEntries) / 2
+        &&  pSet->cEntries != pSet->iSubset)
+    {
+        STAM_COUNTER_INC(&pVCpu->pVMR0->pgm.s.StatR0DynMapPopFlushes);
+        pgmDynMapFlushSubset(pSet);
+    }
+    pSet->iSubset = iPrevSubset;
 }
 
@@ -1774 +1874 @@
         {
             STAM_COUNTER_INC(&pVM->pgm.s.StatR0DynMapSetSearchMisses);
+            if (pSet->iSubset < pSet->cEntries)
+            {
+                STAM_COUNTER_INC(&pVM->pgm.s.StatR0DynMapSetSearchFlushes);
+                pgmDynMapFlushSubset(pSet);
+            }
+
             if (RT_UNLIKELY(pSet->cEntries >= RT_ELEMENTS(pSet->aEntries)))
             {
@@ -1779 +1885 @@
                 pgmDynMapOptimizeAutoSet(pSet);
             }
+
             if (RT_LIKELY(pSet->cEntries < RT_ELEMENTS(pSet->aEntries)))
             {