Changeset 97930 in vbox

Timestamp:

Dec 31, 2022 3:33:06 AM (2 years ago)

Author:

vboxsync

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

155020

Message:

Add/VBoxGuestR0LibPhysHeap.cpp: Simplify link handling by adding an array access to the free and alloc block lists. Also, set the mutex handle to NIL after destruction.

Location:

trunk/src/VBox/Additions/common/VBoxGuest/lib

Files:

• VBoxGuestR0LibInternal.h (modified) (1 diff)
• VBoxGuestR0LibPhysHeap.cpp (modified) (10 diffs)

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibInternal.h

@@ -133 +133 @@
      */
     RTSEMFASTMUTEX     mutexHeap;
-    VBGLPHYSHEAPBLOCK *pFreeBlocksHead;
-    VBGLPHYSHEAPBLOCK *pAllocBlocksHead;
+    /** Block list heads. */
+    union
+    {
+        struct
+        {
+            VBGLPHYSHEAPBLOCK *pFreeBlocksHead;
+            VBGLPHYSHEAPBLOCK *pAllocBlocksHead;
+        } s;
+        /** Indexed by VBGLPHYSHEAPBLOCK::fAllocated, so zero is the free ones
+         * and one the allocated ones. */
+        VBGLPHYSHEAPBLOCK *apHeads[2];
+    } u;
     /** Indexed by VBGLPHYSHEAPBLOCK::fAllocated, so zero is the free ones and
-     *  one the allocated ones. */
+     * one the allocated ones. */
     int32_t            acBlocks[2];
+    /** Chunk    */
     VBGLPHYSHEAPCHUNK *pChunkHead;
     /** @} */

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibPhysHeap.cpp

@@ -44 +44 @@
  * The physical memory heap consists of a doubly linked list of large chunks
  * (VBGLDATA::pChunkHead), memory blocks are allocated within these chunks and
- * are members of allocated (VBGLDATA::pAllocBlocksHead) and free
- * (VBGLDATA::pFreeBlocksHead) doubly linked lists.
+ * are members of allocated (VBGLDATA::u.s.pAllocBlocksHead) and free
+ * (VBGLDATA::u.s.pFreeBlocksHead) doubly linked lists.
  *
  * When allocating a block, we search the free list for a suitable free block.
@@ -221 +221 @@
    VBGL_PH_dprintf(("Allocated blocks:\n"));
 
-   VBGLPHYSHEAPBLOCK *pBlock = g_vbgldata.pAllocBlocksHead;
+   VBGLPHYSHEAPBLOCK *pBlock = g_vbgldata.u.s.pAllocBlocksHead;
 
    while (pBlock)
@@ -234 +234 @@
    VBGL_PH_dprintf(("Free blocks:\n"));
 
-   pBlock = g_vbgldata.pFreeBlocksHead;
+   pBlock = g_vbgldata.u.s.pFreeBlocksHead;
 
    while (pBlock)
@@ -290 +290 @@
     {
         /* inserting to head of list */
+        VBGLPHYSHEAPBLOCK *pOldHead = g_vbgldata.u.apHeads[fAllocated];
+
+        pBlock->pNext = pOldHead;
         pBlock->pPrev = NULL;
 
-        if (fAllocated)
-        {
-            pBlock->pNext = g_vbgldata.pAllocBlocksHead;
-
-            if (g_vbgldata.pAllocBlocksHead)
-                g_vbgldata.pAllocBlocksHead->pPrev = pBlock;
-
-            g_vbgldata.pAllocBlocksHead = pBlock;
-        }
-        else
-        {
-            pBlock->pNext = g_vbgldata.pFreeBlocksHead;
-
-            if (g_vbgldata.pFreeBlocksHead)
-                g_vbgldata.pFreeBlocksHead->pPrev = pBlock;
-
-            g_vbgldata.pFreeBlocksHead = pBlock;
-        }
+        if (pOldHead)
+            pOldHead->pPrev = pBlock;
+        g_vbgldata.u.apHeads[fAllocated] = pBlock;
     }
 
@@ -331 +319 @@
     bool const fAllocated = pBlock->fAllocated;
 
-    if (pBlock->pNext)
-        pBlock->pNext->pPrev = pBlock->pPrev;
+    VBGLPHYSHEAPBLOCK *pOtherBlock = pBlock->pNext;
+    if (pOtherBlock)
+        pOtherBlock->pPrev = pBlock->pPrev;
     /* else: this is tail of list but we do not maintain tails of block lists. so nothing to do. */
 
-    if (pBlock->pPrev)
-        pBlock->pPrev->pNext = pBlock->pNext;
-    else if (fAllocated)
-    {
-        Assert(g_vbgldata.pAllocBlocksHead == pBlock);
-        g_vbgldata.pAllocBlocksHead = pBlock->pNext;
-    }
+    pOtherBlock = pBlock->pPrev;
+    if (pOtherBlock)
+        pOtherBlock->pNext = pBlock->pNext;
     else
     {
-        Assert(g_vbgldata.pFreeBlocksHead == pBlock);
-        g_vbgldata.pFreeBlocksHead = pBlock->pNext;
+        Assert(g_vbgldata.u.apHeads[fAllocated] == pBlock);
+        g_vbgldata.u.apHeads[fAllocated] = pBlock->pNext;
     }
 
@@ -536 +521 @@
            so HGCM processing in VMMDev can use page locks instead of several reads and writes. */
         VBGLPHYSHEAPBLOCK *pFallback = NULL;
-        for (pIter = g_vbgldata.pFreeBlocksHead; pIter != NULL; pIter = pIter->pNext, cLeft--)
+        for (pIter = g_vbgldata.u.s.pFreeBlocksHead; pIter != NULL; pIter = pIter->pNext, cLeft--)
         {
             AssertBreak(pIter->u32Signature == VBGL_PH_BLOCKSIGNATURE);
@@ -581 +566 @@
     {
         /* Large than 3/4 page:  Find closest free list match. */
-        for (pIter = g_vbgldata.pFreeBlocksHead; pIter != NULL; pIter = pIter->pNext, cLeft--)
+        for (pIter = g_vbgldata.u.s.pFreeBlocksHead; pIter != NULL; pIter = pIter->pNext, cLeft--)
         {
             AssertBreak(pIter->u32Signature == VBGL_PH_BLOCKSIGNATURE);
@@ -834 +819 @@
 
     size_t cbTotal = 0;
-    for (VBGLPHYSHEAPBLOCK *pCurBlock = g_vbgldata.pFreeBlocksHead; pCurBlock; pCurBlock = pCurBlock->pNext)
+    for (VBGLPHYSHEAPBLOCK *pCurBlock = g_vbgldata.u.s.pFreeBlocksHead; pCurBlock; pCurBlock = pCurBlock->pNext)
     {
         Assert(pCurBlock->u32Signature == VBGL_PH_BLOCKSIGNATURE);
@@ -915 +900 @@
      * Count each list and check that they contain the same number of nodes.
      */
-    VBGLPHYSHEAPBLOCK *apHeads[2] = { g_vbgldata.pFreeBlocksHead, g_vbgldata.pAllocBlocksHead };
-    for (unsigned iType = 0; iType < RT_ELEMENTS(apHeads); iType++)
+    for (unsigned iType = 0; iType < RT_ELEMENTS(g_vbgldata.u.apHeads); iType++)
     {
         unsigned           cBlocks    = 0;
         VBGLPHYSHEAPBLOCK *pPrevBlock = NULL;
-        for (VBGLPHYSHEAPBLOCK *pCurBlock = apHeads[iType]; pCurBlock; pCurBlock = pCurBlock->pNext)
+        for (VBGLPHYSHEAPBLOCK *pCurBlock = g_vbgldata.u.apHeads[iType]; pCurBlock; pCurBlock = pCurBlock->pNext)
         {
             AssertReturn(pCurBlock->u32Signature == VBGL_PH_BLOCKSIGNATURE,
@@ -980 +964 @@
 
     RTSemFastMutexDestroy(g_vbgldata.mutexHeap);
-}
-
+    g_vbgldata.mutexHeap = NIL_RTSEMFASTMUTEX;
+}
+