diff mbox

[edk2,5/6] MdeModulePkg: serve allocations from higher-up bins if current bin is empty

Message ID 1423414278-8455-6-git-send-email-ard.biesheuvel@linaro.org
State New
Headers show

Commit Message

Ard Biesheuvel Feb. 8, 2015, 4:51 p.m. UTC 
This patch changes the allocation logic for the pool allocator to only
allocate additional pages if the requested allocation cannot be fulfilled
from the current bin or any of the larger ones. If there are larger blocks
available, they will be used to serve the allocation, and the remainder will
be carved up into smaller blocks using the existing carving up logic.
Note that all pool sizes are a multiple of the smallest pool size, so it is
guaranteed that the remainder will be carved up without spilling. Due to the
exponential nature of the pool sizes, the amount of work is logarithmic in
the size of the available block.

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
---
 MdeModulePkg/Core/Dxe/Mem/Pool.c | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)
diff mbox

Patch

diff --git a/MdeModulePkg/Core/Dxe/Mem/Pool.c b/MdeModulePkg/Core/Dxe/Mem/Pool.c
index 23409d35c428..fd9f065dafa2 100644
--- a/MdeModulePkg/Core/Dxe/Mem/Pool.c
+++ b/MdeModulePkg/Core/Dxe/Mem/Pool.c
@@ -292,7 +292,7 @@  CoreAllocatePoolI (
   VOID        *Buffer;
   UINTN       Index;
   UINTN       FSize;
-  UINTN       Offset;
+  UINTN       Offset, MaxOffset;
   UINTN       NoPages;
   UINTN       Granularity;
 
@@ -343,6 +343,22 @@  CoreAllocatePoolI (
   //
   if (IsListEmpty (&Pool->FreeList[Index])) {
 
+    Offset = LIST_TO_SIZE (Index);
+    MaxOffset = Granularity;
+
+    //
+    // Check the bins holding larger blocks, and carve one up if needed
+    //
+    while (++Index < SIZE_TO_LIST (Granularity)) {
+      if (!IsListEmpty (&Pool->FreeList[Index])) {
+        Free = CR (Pool->FreeList[Index].ForwardLink, POOL_FREE, Link, POOL_FREE_SIGNATURE);
+        RemoveEntryList (&Free->Link);
+        NewPage = (VOID *) Free;
+        MaxOffset = LIST_TO_SIZE (Index);
+        goto Carve;
+      }
+    }
+
     //
     // Get another page
     //
@@ -354,29 +370,28 @@  CoreAllocatePoolI (
     //
     // Serve the allocation request from the head of the allocated block
     //
+Carve:
     Head = (POOL_HEAD *) NewPage;
-    Offset = LIST_TO_SIZE (Index);
 
     //
     // Carve up remaining space into free pool blocks
     //
-    Index = SIZE_TO_LIST (Granularity) - 1;
-    while (Offset < Granularity) {
+    Index--;
+    while (Offset < MaxOffset) {
       ASSERT (Index < MAX_POOL_LIST);
       FSize = LIST_TO_SIZE(Index);
 
-      while (Offset + FSize <= Granularity) {
+      while (Offset + FSize <= MaxOffset) {
         Free = (POOL_FREE *) &NewPage[Offset];
         Free->Signature = POOL_FREE_SIGNATURE;
         Free->Index     = (UINT32)Index;
         InsertHeadList (&Pool->FreeList[Index], &Free->Link);
         Offset += FSize;
       }
-
       Index -= 1;
     }
 
-    ASSERT (Offset == Granularity);
+    ASSERT (Offset == MaxOffset);
     goto Done;
   }