Changeset 46204 in vbox for trunk/src/VBox/Runtime/common/dbg

Timestamp:

May 22, 2013 12:28:12 AM (12 years ago)

Author:

vboxsync

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

85923

Message:

Speed up line number allocation and dwarf DIE allocations by using RTMemCacheXZY. Helps a lot with the EF heap, mainly by avoid it...

Location:

trunk/src/VBox/Runtime/common/dbg

Files:

• dbgmodcontainer.cpp (modified) (7 diffs)
• dbgmoddwarf.cpp (modified) (10 diffs)

trunk/src/VBox/Runtime/common/dbg/dbgmodcontainer.cpp

@@ -35 +35 @@
 #include <iprt/err.h>
 #include <iprt/mem.h>
+#define RTDBGMODCNT_WITH_MEM_CACHE
+#ifdef RTDBGMODCNT_WITH_MEM_CACHE
+# include <iprt/memcache.h>
+#endif
 #include <iprt/string.h>
 #include <iprt/strcache.h>
@@ -135 +139 @@
     /** The next line number ordinal. */
     uint32_t                    iNextLineOrdinal;
+#ifdef RTDBGMODCNT_WITH_MEM_CACHE
+    /** Line number allocator.
+     * Using a cache is a bit overkill since we normally won't free them, but
+     * it's a construct that exists and does the job relatively efficiently. */
+    RTMEMCACHE                  hLineNumAllocator;
+#endif
 } RTDBGMODCTN;
 /** Pointer to instance data for the debug info container. */
@@ -251 +261 @@
      * Create a new entry.
      */
+#ifdef RTDBGMODCNT_WITH_MEM_CACHE
+    PRTDBGMODCTNLINE pLine = (PRTDBGMODCTNLINE)RTMemCacheAlloc(pThis->hLineNumAllocator);
+#else
     PRTDBGMODCTNLINE pLine = (PRTDBGMODCTNLINE)RTMemAllocZ(sizeof(*pLine));
+#endif
     if (!pLine)
         return VERR_NO_MEMORY;
@@ -625 +639 @@
 static DECLCALLBACK(int)  rtDbgModContainer_DestroyTreeLineNode(PAVLU32NODECORE pNode, void *pvUser)
 {
+    PRTDBGMODCTN     pThis = (PRTDBGMODCTN)pvUser;
     PRTDBGMODCTNLINE pLine = RT_FROM_MEMBER(pNode, RTDBGMODCTNLINE, OrdinalCore);
     RTStrCacheRelease(g_hDbgModStrCache, pLine->pszFile);
     pLine->pszFile = NULL;
-    RTMemFree(pLine);
-    NOREF(pvUser);
+#ifdef RTDBGMODCNT_WITH_MEM_CACHE
+    RTMemCacheFree(pThis->hLineNumAllocator, pLine);
+#else
+    RTMemFree(pLine); NOREF(pThis);
+#endif    
     return 0;
 }
@@ -664 +682 @@
     pThis->Names = NULL;
 
-    RTAvlU32Destroy(&pThis->LineOrdinalTree, rtDbgModContainer_DestroyTreeLineNode, NULL);
+#ifdef RTDBGMODCNT_WITH_MEM_CACHE
+    RTMemCacheDestroy(pThis->hLineNumAllocator);
+    pThis->hLineNumAllocator = NIL_RTMEMCACHE;
+#else
+    RTAvlU32Destroy(&pThis->LineOrdinalTree, rtDbgModContainer_DestroyTreeLineNode, pThis);
+#endif
 
     RTMemFree(pThis->paSegs);
@@ -755 +778 @@
         pThis->paSegs[iSeg].LineAddrTree = NULL;
 
-    RTAvlU32Destroy(&pThis->LineOrdinalTree, rtDbgModContainer_DestroyTreeLineNode, NULL);
+    RTAvlU32Destroy(&pThis->LineOrdinalTree, rtDbgModContainer_DestroyTreeLineNode, pThis);
     Assert(pThis->LineOrdinalTree == NULL);
 
@@ -817 +840 @@
     pMod->pvDbgPriv = pThis;
 
-    /*
-     * Add the initial segment.
-     */
-    if (cbSeg)
-    {
-        int rc = rtDbgModContainer_SegmentAdd(pMod, 0, cbSeg, "default", sizeof("default") - 1, 0, NULL);
-        if (RT_FAILURE(rc))
-        {
-            RTMemFree(pThis);
-            pMod->pDbgVt = NULL;
-            pMod->pvDbgPriv = NULL;
+#ifdef RTDBGMODCNT_WITH_MEM_CACHE
+    int rc = RTMemCacheCreate(&pThis->hLineNumAllocator, sizeof(RTDBGMODCTNLINE), sizeof(void *), UINT32_MAX,
+                              NULL /*pfnCtor*/, NULL /*pfnDtor*/, NULL /*pvUser*/, 0 /*fFlags*/);
+#else
+    int rc = VINF_SUCCESS;
+#endif
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Add the initial segment.
+         */
+        if (cbSeg)
+            rc = rtDbgModContainer_SegmentAdd(pMod, 0, cbSeg, "default", sizeof("default") - 1, 0, NULL);
+        if (RT_SUCCESS(rc))
             return rc;
-        }
-    }
-
-    return VINF_SUCCESS;
-}
-
+
+#ifdef RTDBGMODCNT_WITH_MEM_CACHE
+        RTMemCacheDestroy(pThis->hLineNumAllocator);
+#endif
+    }
+
+    RTMemFree(pThis);
+    pMod->pDbgVt = NULL;
+    pMod->pvDbgPriv = NULL;
+    return rc;
+}
+

trunk/src/VBox/Runtime/common/dbg/dbgmoddwarf.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2011-2012 Oracle Corporation
+ * Copyright (C) 2011-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -39 +39 @@
 #include <iprt/log.h>
 #include <iprt/mem.h>
+#define RTDBGMODDWARF_WITH_MEM_CACHE
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+# include <iprt/memcache.h>
+#endif
 #include <iprt/path.h>
 #include <iprt/string.h>
@@ -473 +477 @@
     /** Pointer to segments if iWatcomPass isn't -1. */
     PRTDBGDWARFSEG          paSegs;
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+    /** DIE allocators.  */
+    struct
+    {
+        RTMEMCACHE          hMemCache;
+        uint32_t            cbMax;
+    } aDieAllocators[2];
+#endif
 } RTDBGMODDWARF;
 /** Pointer to instance data of the DWARF reader. */
@@ -646 +658 @@
     /** The number of unknown or otherwise unhandled attributes. */
     uint8_t             cUnhandledAttrs;
-    /** The date tag, indicating which union structure to use. */
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+    /** The allocator index. */
+    uint8_t             iAllocator;
+#endif
+    /** The die tag, indicating which union structure to use. */
     uint16_t            uTag;
     /** Offset of the abbreviation specification (within debug_abbrev). */
@@ -3804 +3820 @@
     NOREF(pThis);
     Assert(pDieDesc->cbDie >= sizeof(RTDWARFDIE));
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+    uint32_t iAllocator = pDieDesc->cbDie > pThis->aDieAllocators[0].cbMax;
+    Assert(pDieDesc->cbDie <= pThis->aDieAllocators[iAllocator].cbMax);
+    PRTDWARFDIE pDie = (PRTDWARFDIE)RTMemCacheAlloc(pThis->aDieAllocators[iAllocator].hMemCache);
+#else
     PRTDWARFDIE pDie = (PRTDWARFDIE)RTMemAllocZ(pDieDesc->cbDie);
+#endif
     if (pDie)
     {
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+        RT_BZERO(pDie, pDieDesc->cbDie);
+        pDie->iAllocator   = iAllocator;
+#endif
         rtDwarfInfo_InitDie(pDie, pDieDesc);
 
@@ -4105 +4131 @@
                 {
                     RTListNodeRemove(&pChild->SiblingNode);
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+                    RTMemCacheFree(pThis->aDieAllocators[pChild->iAllocator].hMemCache, pChild);
+#else
                     RTMemFree(pChild);
+#endif
                 }
             }
@@ -4337 +4367 @@
         pThis->pNestedMod = NULL;
     }
+
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+    uint32_t i = RT_ELEMENTS(pThis->aDieAllocators);
+    while (i-- > 0)
+    {
+        RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
+        pThis->aDieAllocators[i].hMemCache = NIL_RTMEMCACHE;
+    }
+#endif
+
     RTMemFree(pThis);
 
@@ -4476 +4516 @@
     RTListInit(&pThis->CompileUnitList);
 
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+    AssertCompile(RT_ELEMENTS(pThis->aDieAllocators) == 2);
+    pThis->aDieAllocators[0].cbMax = sizeof(RTDWARFDIE);
+    pThis->aDieAllocators[1].cbMax = sizeof(RTDWARFDIECOMPILEUNIT);
+    for (uint32_t i = 0; i < RT_ELEMENTS(g_aTagDescs); i++)
+        if (g_aTagDescs[i].pDesc && g_aTagDescs[i].pDesc->cbDie > pThis->aDieAllocators[1].cbMax)
+            pThis->aDieAllocators[1].cbMax = g_aTagDescs[i].pDesc->cbDie;
+    pThis->aDieAllocators[1].cbMax = RT_ALIGN_32(pThis->aDieAllocators[1].cbMax, sizeof(uint64_t));
+
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aDieAllocators); i++)
+    {
+        int rc = RTMemCacheCreate(&pThis->aDieAllocators[i].hMemCache, pThis->aDieAllocators[i].cbMax, sizeof(uint64_t),
+                                  UINT32_MAX, NULL /*pfnCtor*/, NULL /*pfnDtor*/, NULL /*pvUser*/, 0 /*fFlags*/);
+        if (RT_FAILURE(rc))
+        {
+            while (i-- > 0)
+                RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
+            RTMemFree(pThis);
+            return rc;
+        }
+    }
+#endif
 
     /*
@@ -4529 +4591 @@
                                                                      &pThis->aSections[iSect].pv);
 
-
+                    /** @todo Kill pThis->CompileUnitList and the alloc caches. */
                     return VINF_SUCCESS;
                 }
@@ -4541 +4603 @@
             rc = VERR_DBG_NO_MATCHING_INTERPRETER;
     }
+
     RTMemFree(pThis->paCachedAbbrevs);
+
+#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
+    uint32_t i = RT_ELEMENTS(pThis->aDieAllocators);
+    while (i-- > 0)
+    {
+        RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
+        pThis->aDieAllocators[i].hMemCache = NIL_RTMEMCACHE;
+    }
+#endif
+
     RTMemFree(pThis);