Changeset 36960 in vbox for trunk/src/VBox/VMM

Timestamp:

May 4, 2011 4:08:29 PM (14 years ago)

Author:

vboxsync

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

71556

Message:

PGM,MM: Heap and shadow pool size adjustments for large memory configs.

Location:

trunk/src/VBox/VMM/VMMR3

Files:

• MMHyper.cpp (modified) (2 diffs)
• PGMPhys.cpp (modified) (1 diff)
• PGMPool.cpp (modified) (3 diffs)

trunk/src/VBox/VMM/VMMR3/MMHyper.cpp

@@ -45 +45 @@
 
 
-DECLINLINE(uint32_t) mmR3ComputeHyperHeapSize(PVM pVM, bool fCanUseLargerHeap)
-{
-    bool fHwVirtExtForced = VMMIsHwVirtExtForced(pVM);
-
-    /* Newer chipset allows for much more devices, putting additional pressure on hyperheap */
-    /* @todo: maybe base hyperheap size upon number of devices attached too */
+/**
+ * Determin the default heap size.
+ *
+ * @returns The heap size in bytes.
+ * @param   pVM     The VM handle.
+ */
+static uint32_t mmR3ComputeHyperHeapSize(PVM pVM)
+{
+    /*
+     * Gather parameters.
+     */
+    bool const  fHwVirtExtForced = VMMIsHwVirtExtForced(pVM)
+                                || pVM->cCpus > 1;
+
+    bool        fCanUseLargerHeap;
+    int rc = CFGMR3QueryBoolDef(CFGMR3GetChild(CFGMR3GetRoot(pVM), "MM"), "CanUseLargerHeap", &fCanUseLargerHeap, false);
+    AssertStmt(RT_SUCCESS(rc), fCanUseLargerHeap = false);
+
+    uint64_t    cbRam;
+    rc = CFGMR3QueryU64(CFGMR3GetRoot(pVM), "RamSize", &cbRam);
+    AssertStmt(RT_SUCCESS(rc), cbRam = _1G);
+
+    /*
+     * We need to keep saved state compatibility if raw-mode is an option,
+     * so lets filter out that case first.
+     */
+    if (   !fCanUseLargerHeap
+        && !fHwVirtExtForced
+        && cbRam < 16*_1G64)
+        return 1280 * _1K;
+
+    /*
+     * Calculate the heap size.
+     */
+    uint32_t cbHeap = _1M;
+
+    /* The newer chipset may have more devices attached, putting additional
+       pressure on the heap. */
     if (fCanUseLargerHeap)
-        return _2M + pVM->cCpus * 2 * _64K;
-
+        cbHeap += _1M;
+
+    /* More CPUs means some extra memory usage. */
     if (pVM->cCpus > 1)
-        return _1M + pVM->cCpus * 2 * _64K;
-
-    if (fHwVirtExtForced)
-    {
-        uint64_t cbRam = 0;
-        CFGMR3QueryU64(CFGMR3GetRoot(pVM), "RamSize", &cbRam);
-
-        /* Need a bit more space for large memory guests. (@todo: only for shadow paging!) */
-        if (cbRam >= _4G)
-            return _1M;
-        else
-            return 640 * _1K;
-    }
-    else
-        /* Size must be kept like this for saved state compatibility (only for raw mode though). */
-        return 1280*_1K;
+        cbHeap += pVM->cCpus * _64K;
+
+    /* Lots of memory means extra memory consumption as well (pool). */
+    if (cbRam > 16*_1G64)
+        cbHeap += _2M; /** @todo figure out extactly how much */
+
+    return RT_ALIGN(cbHeap, _256K);
 }
 
@@ -101 +125 @@
      */
     PCFGMNODE pMM = CFGMR3GetChild(CFGMR3GetRoot(pVM), "MM");
-    bool fCanUseLargerHeap = false;
-    int rc = CFGMR3QueryBoolDef(pMM, "CanUseLargerHeap", &fCanUseLargerHeap, false);
-    uint32_t cbHyperHeap = mmR3ComputeHyperHeapSize(pVM, fCanUseLargerHeap);
-    rc = CFGMR3QueryU32Def(pMM, "cbHyperHeap", &cbHyperHeap, cbHyperHeap);
+    uint32_t cbHyperHeap;
+    int rc = CFGMR3QueryU32Def(pMM, "cbHyperHeap", &cbHyperHeap, mmR3ComputeHyperHeapSize(pVM));
     AssertLogRelRCReturn(rc, rc);
 

trunk/src/VBox/VMM/VMMR3/PGMPhys.cpp

@@ -3996 +3996 @@
     else
     {
+        /** @todo this may fail because of /proc/sys/vm/max_map_count, so we
+         *        should probably restrict ourselves on linux. */
         AssertRC(rc);
 #ifdef VBOX_WITH_2X_4GB_ADDR_SPACE

trunk/src/VBox/VMM/VMMR3/PGMPool.cpp

@@ -135 +135 @@
 int pgmR3PoolInit(PVM pVM)
 {
+    int rc;
+
     AssertCompile(NIL_PGMPOOL_IDX == 0);
     /* pPage->cLocked is an unsigned byte. */
@@ -144 +146 @@
     PCFGMNODE pCfg = CFGMR3GetChild(CFGMR3GetRoot(pVM), "/PGM/Pool");
 
-    /* Default pgm pool size equals 1024 pages. */
-    uint16_t cMaxPages = 4*_1M >> PAGE_SHIFT;
-
-#if HC_ARCH_BITS == 64
-    uint64_t cbRam = 0;
-    CFGMR3QueryU64Def(CFGMR3GetRoot(pVM), "RamSize", &cbRam, 0);
-
-    /* We should increase the pgm pool size for guests with more than 2 GB of ram */
-    if (cbRam >= UINT64_C(2) * _1G)
-    {
-        /* In the nested paging case we require 2 + 513 * (cbRam/1GB) pages to
-         * store all page table descriptors.
-         */
-        uint64_t u64MaxPages = cbRam  / (_1G / UINT64_C(512));
-        if (u64MaxPages > PGMPOOL_IDX_LAST)
-            cMaxPages = PGMPOOL_IDX_LAST;
-        else
-            cMaxPages = (uint16_t)u64MaxPages;
-    }
-#endif
-
-    /** @cfgm{/PGM/Pool/MaxPages, uint16_t, #pages, 16, 0x3fff, 1024}
+    /* Default pgm pool size is 1024 pages (4MB). */
+    uint16_t cMaxPages = 1024;
+
+    /* Adjust it up relative to the RAM size, using the nested paging formula. */
+    uint64_t cbRam;
+    rc = CFGMR3QueryU64Def(CFGMR3GetRoot(pVM), "RamSize", &cbRam, 0); AssertRCReturn(rc, rc);
+    uint64_t u64MaxPages = (cbRam >> 9)
+                         + (cbRam >> 18)
+                         + (cbRam >> 27)
+                         + 32 * PAGE_SIZE;
+    u64MaxPages >>= PAGE_SHIFT;
+    if (u64MaxPages > PGMPOOL_IDX_LAST)
+        cMaxPages = PGMPOOL_IDX_LAST;
+    else
+        cMaxPages = (uint16_t)u64MaxPages;
+
+    /** @cfgm{/PGM/Pool/MaxPages, uint16_t, #pages, 16, 0x3fff, F(ram-size)}
      * The max size of the shadow page pool in pages. The pool will grow dynamically
      * up to this limit.
      */
-    int rc = CFGMR3QueryU16Def(pCfg, "MaxPages", &cMaxPages, cMaxPages);
+    rc = CFGMR3QueryU16Def(pCfg, "MaxPages", &cMaxPages, cMaxPages);
     AssertLogRelRCReturn(rc, rc);
     AssertLogRelMsgReturn(cMaxPages <= PGMPOOL_IDX_LAST && cMaxPages >= RT_ALIGN(PGMPOOL_IDX_FIRST, 16),
                           ("cMaxPages=%u (%#x)\n", cMaxPages, cMaxPages), VERR_INVALID_PARAMETER);
     cMaxPages = RT_ALIGN(cMaxPages, 16);
+    if (cMaxPages > PGMPOOL_IDX_LAST)
+        cMaxPages = PGMPOOL_IDX_LAST;
+    LogRel(("PGMPool: cMaxPages=%u (u64MaxPages=%llu)\n", cMaxPages, u64MaxPages));
 
     /** todo:
      * We need to be much more careful with our allocation strategy here.
-     * For nested paging we don't need pool user info nor extents at all, but we can't check for nested paging here (too early during init to get a confirmation it can be used)
-     * The default for large memory configs is a bit large for shadow paging, so I've restricted the extent maximum to 2k (2k * 16 = 32k of hyper heap)
+     * For nested paging we don't need pool user info nor extents at all, but
+     * we can't check for nested paging here (too early during init to get a
+     * confirmation it can be used).  The default for large memory configs is a
+     * bit large for shadow paging, so I've restricted the extent maximum to 8k
+     * (8k * 16 = 128k of hyper heap).
      *
      * Also when large page support is enabled, we typically don't need so much,
@@ -196 +199 @@
                           ("cMaxUsers=%u (%#x)\n", cMaxUsers, cMaxUsers), VERR_INVALID_PARAMETER);
 
-    /** @cfgm{/PGM/Pool/MaxPhysExts, uint16_t, #extents, 16, MaxPages * 2, MAX(MaxPages*2,0x3fff)}
+    /** @cfgm{/PGM/Pool/MaxPhysExts, uint16_t, #extents, 16, MaxPages * 2, MIN(MaxPages*2,8192)}
      * The max number of extents for tracking aliased guest pages.
      */
     uint16_t cMaxPhysExts;
-    rc = CFGMR3QueryU16Def(pCfg, "MaxPhysExts", &cMaxPhysExts, RT_MAX(cMaxPages * 2, 2048 /* 2k max as this eat too much hyper heap */));
+    rc = CFGMR3QueryU16Def(pCfg, "MaxPhysExts", &cMaxPhysExts,
+                           RT_MIN(cMaxPages * 2, 8192 /* 8Ki max as this eat too much hyper heap */));
     AssertLogRelRCReturn(rc, rc);
-    AssertLogRelMsgReturn(cMaxPhysExts >= 16 && cMaxPages <= PGMPOOL_IDX_LAST,
+    AssertLogRelMsgReturn(cMaxPhysExts >= 16 && cMaxPhysExts <= PGMPOOL_IDX_LAST,
                           ("cMaxPhysExts=%u (%#x)\n", cMaxPhysExts, cMaxPhysExts), VERR_INVALID_PARAMETER);