Changeset 37206 in vbox for trunk

Timestamp:

May 24, 2011 6:43:32 PM (14 years ago)

Author:

vboxsync

Message:

GMMR0: Simplified the cleanup, let the VMs work in parallel since. (fixed redo-from-start bug)

File:

• trunk/src/VBox/VMM/VMMR0/GMMR0.cpp (modified) (20 diffs)

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

@@ -514 +514 @@
     PAVLGCPTRNODECORE   pGlobalSharedModuleTree;
 
-    /** The fast mutex protecting the GMM cleanup.
-     * This is serializes VMs cleaning up their memory, so that we can
-     * safely leave the primary mutex (hMtx). */
-    RTSEMFASTMUTEX      hMtxCleanup;
     /** The chunk list.  For simplifying the cleanup process. */
     RTLISTNODE          ChunkList;
@@ -697 +693 @@
 DECLINLINE(void)             gmmR0UnlinkChunk(PGMMCHUNK pChunk);
 static uint32_t              gmmR0SanityCheck(PGMM pGMM, const char *pszFunction, unsigned uLineNo);
-static void                  gmmR0FreeChunk(PGMM pGMM, PGVM pGVM, PGMMCHUNK pChunk);
+static bool                  gmmR0FreeChunk(PGMM pGMM, PGVM pGVM, PGMMCHUNK pChunk, bool fRelaxedSem);
 static void                  gmmR0FreeSharedPage(PGMM pGMM, uint32_t idPage, PGMMPAGE pPage);
 static int                   gmmR0UnmapChunkLocked(PGMM pGMM, PGVM pGVM, PGMMCHUNK pChunk);
@@ -732 +728 @@
     if (RT_SUCCESS(rc))
     {
-        rc = RTSemFastMutexCreate(&pGMM->hMtxCleanup);
+        unsigned iMtx;
+        for (iMtx = 0; iMtx < RT_ELEMENTS(pGMM->aChunkMtx); iMtx++)
+        {
+            rc = RTSemFastMutexCreate(&pGMM->aChunkMtx[iMtx].hMtx);
+            if (RT_FAILURE(rc))
+                break;
+        }
         if (RT_SUCCESS(rc))
         {
-            unsigned iMtx;
-            for (iMtx = 0; iMtx < RT_ELEMENTS(pGMM->aChunkMtx); iMtx++)
-            {
-                rc = RTSemFastMutexCreate(&pGMM->aChunkMtx[iMtx].hMtx);
-                if (RT_FAILURE(rc))
-                    break;
-            }
+            /*
+             * Check and see if RTR0MemObjAllocPhysNC works.
+             */
+#if 0 /* later, see #3170. */
+            RTR0MEMOBJ MemObj;
+            rc = RTR0MemObjAllocPhysNC(&MemObj, _64K, NIL_RTHCPHYS);
             if (RT_SUCCESS(rc))
             {
-                /*
-                 * Check and see if RTR0MemObjAllocPhysNC works.
-                 */
-#if 0 /* later, see #3170. */
-                RTR0MEMOBJ MemObj;
-                rc = RTR0MemObjAllocPhysNC(&MemObj, _64K, NIL_RTHCPHYS);
-                if (RT_SUCCESS(rc))
-                {
-                    rc = RTR0MemObjFree(MemObj, true);
-                    AssertRC(rc);
-                }
-                else if (rc == VERR_NOT_SUPPORTED)
-                    pGMM->fLegacyAllocationMode = pGMM->fBoundMemoryMode = true;
-                else
-                    SUPR0Printf("GMMR0Init: RTR0MemObjAllocPhysNC(,64K,Any) -> %d!\n", rc);
+                rc = RTR0MemObjFree(MemObj, true);
+                AssertRC(rc);
+            }
+            else if (rc == VERR_NOT_SUPPORTED)
+                pGMM->fLegacyAllocationMode = pGMM->fBoundMemoryMode = true;
+            else
+                SUPR0Printf("GMMR0Init: RTR0MemObjAllocPhysNC(,64K,Any) -> %d!\n", rc);
 #else
 # if defined(RT_OS_WINDOWS) || (defined(RT_OS_SOLARIS) && ARCH_BITS == 64) || defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
-                pGMM->fLegacyAllocationMode = false;
+            pGMM->fLegacyAllocationMode = false;
 #  if ARCH_BITS == 32
-                /* Don't reuse possibly partial chunks because of the virtual
-                   address space limitation. */
-                pGMM->fBoundMemoryMode      = true;
+            /* Don't reuse possibly partial chunks because of the virtual
+               address space limitation. */
+            pGMM->fBoundMemoryMode      = true;
 #  else
-                pGMM->fBoundMemoryMode      = false;
+            pGMM->fBoundMemoryMode      = false;
 #  endif
 # else
-                pGMM->fLegacyAllocationMode = true;
-                pGMM->fBoundMemoryMode      = true;
+            pGMM->fLegacyAllocationMode = true;
+            pGMM->fBoundMemoryMode      = true;
 # endif
 #endif
 
-                /*
-                 * Query system page count and guess a reasonable cMaxPages value.
-                 */
-                pGMM->cMaxPages = UINT32_MAX; /** @todo IPRT function for query ram size and such. */
-
-                g_pGMM = pGMM;
-                LogFlow(("GMMInit: pGMM=%p fLegacyAllocationMode=%RTbool fBoundMemoryMode=%RTbool\n", pGMM, pGMM->fLegacyAllocationMode, pGMM->fBoundMemoryMode));
-                return VINF_SUCCESS;
-            }
-
             /*
-             * Bail out.
+             * Query system page count and guess a reasonable cMaxPages value.
              */
-            while (iMtx-- > 0)
-                RTSemFastMutexDestroy(pGMM->aChunkMtx[iMtx].hMtx);
-        }
+            pGMM->cMaxPages = UINT32_MAX; /** @todo IPRT function for query ram size and such. */
+
+            g_pGMM = pGMM;
+            LogFlow(("GMMInit: pGMM=%p fLegacyAllocationMode=%RTbool fBoundMemoryMode=%RTbool\n", pGMM, pGMM->fLegacyAllocationMode, pGMM->fBoundMemoryMode));
+            return VINF_SUCCESS;
+        }
+
+        /*
+         * Bail out.
+         */
+        while (iMtx-- > 0)
+            RTSemFastMutexDestroy(pGMM->aChunkMtx[iMtx].hMtx);
         RTSemFastMutexDestroy(pGMM->hMtx);
     }
@@ -828 +820 @@
     RTSemFastMutexDestroy(pGMM->hMtx);
     pGMM->hMtx        = NIL_RTSEMFASTMUTEX;
-    RTSemFastMutexDestroy(pGMM->hMtxCleanup);
-    pGMM->hMtxCleanup = NIL_RTSEMFASTMUTEX;
 
     /* Free any chunks still hanging around. */
@@ -1114 +1104 @@
  *
  * This only works if gmmR0ChunkMutexAcquire was called with
- * GMMR0CHUNK_MTX_KEEP_GIANT.  Release will NOT retake the giant
- * when dropped this way, the behavior will be like if
- * GMMR0CHUNK_MTX_DROP_GIANT was used.
+ * GMMR0CHUNK_MTX_KEEP_GIANT.  gmmR0ChunkMutexRelease will retake the giant
+ * mutex, i.e. behave as if GMMR0CHUNK_MTX_RETAKE_GIANT was used.
  *
  * @returns VBox status code (assuming success is ok).
@@ -1125 +1114 @@
     AssertReturn(pMtxState->fFlags == GMMR0CHUNK_MTX_KEEP_GIANT, VERR_INTERNAL_ERROR_2);
     Assert(pMtxState->pGMM->hMtxOwner == RTThreadNativeSelf());
-    pMtxState->fFlags = GMMR0CHUNK_MTX_DROP_GIANT;
+    pMtxState->fFlags = GMMR0CHUNK_MTX_RETAKE_GIANT;
     /** @todo GMM life cycle cleanup (we may race someone
      *        destroying and cleaning up GMM)? */
@@ -1151 +1140 @@
 #endif
 
-    int rc = RTSemFastMutexRequest(pGMM->hMtxCleanup); AssertRC(rc);
     gmmR0MutexAcquire(pGMM);
     uint64_t uLockNanoTS = RTTimeSystemNanoTS();
@@ -1175 +1163 @@
         /*
          * Walk the entire pool looking for pages that belong to this VM
-         * and left over mappings.  (This'll only catch private pages,
+         * and leftover mappings.  (This'll only catch private pages,
          * shared pages will be 'left behind'.)
          */
@@ -1191 +1179 @@
                 if (gmmR0CleanupVMScanChunk(pGMM, pGVM, pChunk))
                 {
-                    gmmR0MutexAcquire(pGMM);
+                    /* We left the giant mutex, so reset the yield counters. */
                     uLockNanoTS = RTTimeSystemNanoTS();
+                    iCountDown  = 64;
                 }
                 else
                 {
+                    /* Didn't leave it, so do normal yielding. */
                     if (!iCountDown)
                         gmmR0MutexYield(pGMM, &uLockNanoTS);
@@ -1216 +1206 @@
         do
         {
+            fRedoFromStart = false;
             iCountDown = 10240;
             pChunk = pGMM->Private.apLists[RT_ELEMENTS(pGMM->Private.apLists) - 1];
@@ -1225 +1216 @@
                          || pChunk->hGVM == pGVM->hSelf))
                 {
-                    gmmR0FreeChunk(pGMM, pGVM, pChunk);
-                    iCountDown = 1;
+                    uint64_t const idGenerationOld = pGMM->Private.idGeneration;
+                    if (gmmR0FreeChunk(pGMM, pGVM, pChunk, true /*fRelaxedSem*/))
+                    {
+                        /* We've left the giant mutex, restart? (+1 for our unlink) */
+                        fRedoFromStart = pGMM->Private.idGeneration != idGenerationOld + 1;
+                        if (fRedoFromStart)
+                            break;
+                        uLockNanoTS = RTTimeSystemNanoTS();
+                        iCountDown = 10240;
+                    }
                 }
+
+                /* Advance and maybe yield the lock. */
                 pChunk = pNext;
-
                 if (--iCountDown == 0)
                 {
@@ -1281 +1281 @@
     GMM_CHECK_SANITY_UPON_LEAVING(pGMM);
     gmmR0MutexRelease(pGMM);
-    RTSemFastMutexRelease(pGMM->hMtxCleanup);
 
     LogFlow(("GMMR0CleanupVM: returns\n"));
@@ -1290 +1289 @@
  * Scan one chunk for private pages belonging to the specified VM.
  *
- * @note    This function is ugly since may drop the ownership of the giant GMM
- *          mutex!
- *
- * @returns @c true if we've dropped the giant mutex, @c false if we didn't.
+ * @note    This function may drop the gian mutex!
+ *
+ * @returns @c true if we've temporarily dropped the giant mutex, @c false if
+ *          we didn't.
  * @param   pGMM        Pointer to the GMM instance.
  * @param   pGVM        The global VM handle.
@@ -1410 +1409 @@
                 AssertRC(rc);
             }
+
             gmmR0ChunkMutexRelease(&MtxState, pChunk);
             return true;
@@ -2819 +2819 @@
 
             /* Release the memory immediately. */
-            gmmR0FreeChunk(pGMM, NULL, pChunk);
+            gmmR0FreeChunk(pGMM, NULL, pChunk, false /*fRelaxedSem*/); /** @todo this can be relaxed too! */
 
             /* Update accounting. */
@@ -2868 +2868 @@
  *                      unmap and free the chunk in one go.
  * @param   pChunk      The chunk to free.
- */
-static void gmmR0FreeChunk(PGMM pGMM, PGVM pGVM, PGMMCHUNK pChunk)
+ * @param   fRelaxedSem Whether we can release the semaphore while doing the
+ *                      freeing (@c true) or not.
+ */
+static bool gmmR0FreeChunk(PGMM pGMM, PGVM pGVM, PGMMCHUNK pChunk, bool fRelaxedSem)
 {
     Assert(pChunk->Core.Key != NIL_GMM_CHUNKID);
@@ -2878 +2880 @@
     /*
      * Cleanup hack! Unmap the chunk from the callers address space.
+     * This shouldn't happen, so screw lock contention...
      */
     if (    pChunk->cMappingsX
@@ -2894 +2897 @@
         /* The chunk can be mapped by more than one VM if fBoundMemoryMode is false! */
         Log(("gmmR0FreeChunk: chunk still has %d/%d mappings; don't free!\n", pChunk->cMappingsX));
-    }
-    else
-    {
-        /*
-         * Try free the memory object.
-         */
-/** @todo drop the giant lock here! */
-        int rc = RTR0MemObjFree(pChunk->hMemObj, false /* fFreeMappings */);
-        if (RT_SUCCESS(rc))
-        {
-            pChunk->hMemObj = NIL_RTR0MEMOBJ;
-
-            /*
-             * Unlink it from everywhere.
-             */
-            gmmR0UnlinkChunk(pChunk);
-
-            RTListNodeRemove(&pChunk->ListNode);
-
-            PAVLU32NODECORE pCore = RTAvlU32Remove(&pGMM->pChunks, pChunk->Core.Key);
-            Assert(pCore == &pChunk->Core); NOREF(pCore);
-
-            PGMMCHUNKTLBE pTlbe = &pGMM->ChunkTLB.aEntries[GMM_CHUNKTLB_IDX(pChunk->Core.Key)];
-            if (pTlbe->pChunk == pChunk)
-            {
-                pTlbe->idChunk = NIL_GMM_CHUNKID;
-                pTlbe->pChunk = NULL;
-            }
-
-            Assert(pGMM->cChunks > 0);
-            pGMM->cChunks--;
-
-            /*
-             * Free the Chunk ID and struct.
-             */
-            gmmR0FreeChunkId(pGMM, pChunk->Core.Key);
-            pChunk->Core.Key = NIL_GMM_CHUNKID;
-
-            RTMemFree(pChunk->paMappingsX);
-            pChunk->paMappingsX = NULL;
-
-            RTMemFree(pChunk);
-            pChunk = NULL;              /* (for gmmR0ChunkMutexRelease) */
-
-            pGMM->cFreedChunks++;
-        }
-        else
-            AssertRC(rc);
-    }
-
-    gmmR0ChunkMutexRelease(&MtxState, pChunk);
+        gmmR0ChunkMutexRelease(&MtxState, pChunk);
+        return false;
+    }
+
+
+    /*
+     * Save and trash the handle.
+     */
+    RTR0MEMOBJ const hMemObj = pChunk->hMemObj;
+    pChunk->hMemObj = NIL_RTR0MEMOBJ;
+
+    /*
+     * Unlink it from everywhere.
+     */
+    gmmR0UnlinkChunk(pChunk);
+
+    RTListNodeRemove(&pChunk->ListNode);
+
+    PAVLU32NODECORE pCore = RTAvlU32Remove(&pGMM->pChunks, pChunk->Core.Key);
+    Assert(pCore == &pChunk->Core); NOREF(pCore);
+
+    PGMMCHUNKTLBE pTlbe = &pGMM->ChunkTLB.aEntries[GMM_CHUNKTLB_IDX(pChunk->Core.Key)];
+    if (pTlbe->pChunk == pChunk)
+    {
+        pTlbe->idChunk = NIL_GMM_CHUNKID;
+        pTlbe->pChunk = NULL;
+    }
+
+    Assert(pGMM->cChunks > 0);
+    pGMM->cChunks--;
+
+    /*
+     * Free the Chunk ID before dropping the locks and freeing the rest.
+     */
+    gmmR0FreeChunkId(pGMM, pChunk->Core.Key);
+    pChunk->Core.Key = NIL_GMM_CHUNKID;
+
+    pGMM->cFreedChunks++;
+
+    gmmR0ChunkMutexRelease(&MtxState, NULL);
+    if (fRelaxedSem)
+        gmmR0MutexRelease(pGMM);
+
+    RTMemFree(pChunk->paMappingsX);
+    pChunk->paMappingsX = NULL;
+
+    RTMemFree(pChunk);
+
+    int rc = RTR0MemObjFree(hMemObj, false /* fFreeMappings */);
+    AssertLogRelRC(rc);
+
+    if (fRelaxedSem)
+        gmmR0MutexAcquire(pGMM);
+    return fRelaxedSem;
 }
 
@@ -2997 +3003 @@
      * a bit...
      */
+    /** @todo Do this on the way out. */
     if (RT_UNLIKELY(   pChunk->cFree == GMM_CHUNK_NUM_PAGES
                     && pChunk->pFreeNext
                     && pChunk->pFreePrev /** @todo this is probably misfiring, see reset... */
                     && !pGMM->fLegacyAllocationMode))
-        gmmR0FreeChunk(pGMM, NULL, pChunk);
+        gmmR0FreeChunk(pGMM, NULL, pChunk, false);
 
 }
@@ -3732 +3739 @@
  * @param   pChunk      Pointer to the chunk to be mapped.
  * @param   fRelaxedSem Whether we can release the semaphore while doing the
- *                      locking (@c true) or not.
+ *                      mapping (@c true) or not.
  * @param   ppvR3       Where to store the ring-3 address of the mapping.
  *                      In the VERR_GMM_CHUNK_ALREADY_MAPPED case, this will be