[gvg] 15497: Implement sub-allocation of small requests

Implement sub-allocation of small requests
Modified: trunk/reactos/boot/freeldr/freeldr/freeldr.c
Modified: trunk/reactos/boot/freeldr/freeldr/mm/mm.c
  _____

Modified: trunk/reactos/boot/freeldr/freeldr/freeldr.c
--- trunk/reactos/boot/freeldr/freeldr/freeldr.c	2005-05-25
20:59:13 UTC (rev 15496)
+++ trunk/reactos/boot/freeldr/freeldr/freeldr.c	2005-05-25
22:36:35 UTC (rev 15497)
@@ -35,7 +35,7 @@

DebugInit();

-	DbgPrint((DPRINT_WARNING, "BootMain() called. BootDrive = 0x%x
BootPartition = %d\n", BootDrive, BootPartition));
+	DbgPrint((DPRINT_WARNING, "BootMain() called.\n"));

if (!MmInitializeMemoryManager())
    {
  _____

Modified: trunk/reactos/boot/freeldr/freeldr/mm/mm.c
--- trunk/reactos/boot/freeldr/freeldr/mm/mm.c	2005-05-25 20:59:13 UTC
(rev 15496)
+++ trunk/reactos/boot/freeldr/freeldr/mm/mm.c	2005-05-25 22:36:35 UTC
(rev 15497)
@@ -36,10 +36,30 @@

VOID		MemAllocTest(VOID);
 #endif // DEBUG

+/*
+ * Hack alert
+ * Normally, we allocate whole pages. This is ofcourse wastefull for
small
+ * allocations (a few bytes). So, for small allocations (smaller than a
page)
+ * we sub-allocate. When the first small allocation is done, a page is
+ * requested. We keep a pointer to that page in SubAllocationPage. The
alloc
+ * is satisfied by returning a pointer to the beginning of the page. We
also
+ * keep track of how many bytes are still available in the page in
SubAllocationRest.
+ * When the next small request comes in, we try to allocate it just
after the
+ * memory previously allocated. If it won't fit, we allocate a new page
and
+ * the whole process starts again.
+ * Note that suballocations are done back-to-back, there's no
bookkeeping at all.
+ * That also means that we cannot really free suballocations. So, when
a free is
+ * done and it is determined that this might be a free of a
sub-allocation, we
+ * just no-op the free.
+ * Perhaps we should use the heap routines from ntdll here.
+ */
+static PVOID    SubAllocationPage = NULL;
+static unsigned SubAllocationRest = 0;
+
 PVOID MmAllocateMemory(ULONG MemorySize)
 {
-	ULONG		PagesNeeded;
-	ULONG		FirstFreePageFromEnd;
+	ULONG	PagesNeeded;
+	ULONG	FirstFreePageFromEnd;
    PVOID	MemPointer;

if (MemorySize == 0)
@@ -49,6 +69,14 @@
    	return NULL;
    }

+	MemorySize = ROUND_UP(MemorySize, 4);
+	if (MemorySize <= SubAllocationRest)
+	{
+		MemPointer = SubAllocationPage + MM_PAGE_SIZE -
SubAllocationRest;
+		SubAllocationRest -= MemorySize;
+		return MemPointer;
+	}
+
    // Find out how many blocks it will take to
    // satisfy this allocation
    PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
@@ -76,6 +104,13 @@
    FreePagesInLookupTable -= PagesNeeded;
    MemPointer = (PVOID)(FirstFreePageFromEnd * MM_PAGE_SIZE);

+	if (MemorySize < MM_PAGE_SIZE)
+	{
+		SubAllocationPage = MemPointer;
+		SubAllocationRest = MM_PAGE_SIZE - MemorySize;
+	}
+		
+
 #ifdef DEBUG
    IncrementAllocationCount();
    DbgPrint((DPRINT_MEMORY, "Allocated %d bytes (%d pages) of
memory starting at page %d. AllocCount: %d\n", MemorySize, PagesNeeded,
FirstFreePageFromEnd, AllocationCount));
@@ -235,6 +270,13 @@

#endif

+	/* If this allocation is only a single page, it could be a
sub-allocated page.
+	 * Just don't free it */
+	if (1 == PageCount)
+	{
+		return;
+	}
+
    // Loop through our array and mark all the
    // blocks as free
    for (Idx=PageNumber; Idx<(PageNumber + PageCount); Idx++)