Introduce deactivated discontiguous memory allocator

This commit introduces the code for a discontiguous memory allocator
to implement malloc() and free(). The allocator is not active yet, and
all code still uses the contiguous allocator. (See below.)

A discontiguous allocator is useful because for most cases, Hostboot
allocates memory and doesn't expect the physical pages that back the
memory range to be contiguous. Allowing the physical pages to be
discontiguous helps us deal with memory fragmentation by allowing large
allocations to be split up wherever they can fit in the physical
address space.

There are certain places where contiguous physical memory is required,
such as by the kernel, or in communication with the SBE, which reads
physical memory directly without going through page translation. These
places call the contiguous-backed allocator explicitly.

This allocator allocates a block of virtual memory space, and uses a
"bump" allocator strategy (i.e. new allocations always come from the
front of the heap, and allocations are never reused).

The allocator is not activated yet because we are still experimenting
with the best heap sizes and allocation strategies.

JIRA: PFHB-521
Change-Id: I7e8de943e0dc348845a2fa3d9beb860bed92a99e
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/155995
Tested-by: Jenkins OP Build CI <[email protected]>
Tested-by: Jenkins Server <[email protected]>
Reviewed-by: Matthew Raybuck <[email protected]>
Tested-by: Jenkins Combined Simics CI <[email protected]>
Tested-by: FSP CI Jenkins <[email protected]>
Tested-by: Jenkins OP HW <[email protected]>
Tested-by: Hostboot CI <[email protected]>
Reviewed-by: Daniel M Crowell <[email protected]>

Author: skodali4

src/build/tools/hb

@@ -720,7 +720,7 @@ hb_startsimics()
         fi
 
         # For GCOV, tell simics to enable the larger backing cache.
-        if [ "$HOSTBOOT_PROFILE" ] ; then
+        if [[ "$HOSTBOOT_PROFILE" || "$SIMICS_MORECACHE" ]] ; then
             # enable more cores for 16MB backing cache
             export SIMICS_MORECACHE=1
             STARTSIMCMD+=(num_cores_per_chip=8)

src/include/stdlib.h

@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2010,2021                        */
+/* Contributors Listed Below - COPYRIGHT 2010,2023                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -32,9 +32,59 @@ extern "C"
 {
 #endif
 
-void* malloc(size_t) __attribute__((malloc));
-void free(void*);
+ /**
+  * @brief allocates memory contiguous in physical memory
+  * @param[in]  size  size of allocation.
+  * @return Pointer to beginning of allocation block
+  */
+void* contiguous_malloc(size_t)__attribute__((malloc));
+
+ /**
+  * @brief allocates memory discontiguous in physical memory
+  * @param[in]  size  size of allocation.
+  * @return Pointer to beginning of allocation block
+  */
+void* discontiguous_malloc(size_t);
+
+ /**
+  * @brief Uses the currently active allocator (contiguous or
+  * discontiguous). Always uses the contiguous allocator in kernel
+  * mode.
+  * @param[in]  size  size of allocation.
+  * @return pointer to beginning of allocation block
+  */
+void* malloc(size_t)__attribute__((malloc));
+
+ /**
+  * @brief Function to free allocated block. Can be used with the
+  *        results of either contiguous or discontiguous allocator.
+  * @param[in]  ptr  pointer to allocation block needed to be freed
+  */
+void  free(void*);
+
+ /**
+  * @brief called in istep 6.5 to switch the default allocator to
+  * discontiguous malloc. This is the earliest point when the VMM
+  * system is ready to handle a call mm_alloc_block.
+  */
+void activate_discontiguous_malloc_heap();
+
+/**
+ * @brief Called in exit_cache_contained to return to the
+ * physically contiguous allocator. We do this because we
+ * currently have limited virtual address space, and after exiting
+ * cache, we don't have tight memory constraints.
+ */
+void deactivate_discontiguous_malloc_heap();
+
+/**
+ *  @brief Can be used with a pointer from either allocator.
+ */
 void* realloc(void*, size_t);
+
+/**
+ * @brief Uses the current allocator.
+ */
 void* calloc(size_t, size_t) __attribute__((malloc));
 
 /**

src/include/usr/vmmconst.h

@@ -155,6 +155,16 @@ enum VmmRestriction : uint64_t
 #define VMM_VADDR_MALLOC (16 * GIGABYTE)
 #define VMM_MALLOC_SIZE  (1 * GIGABYTE)
 
+/** Userspace for malloc backed by virtual memory*/
+#define VMM_VADDR_MALLOC_VIRT (70 * GIGABYTE)
+
+// Increasing this number will make more page table entries need to be
+// allocated; divide this number by 1024 to get the number of bytes
+// needed for the page tables (e.g. 128 mb heap = 128 kb of page
+// tables).
+#define VMM_MALLOC_VIRT_SIZE (128 * MEGABYTE)
+#define VMM_MALLOC_EXTENDED_SIZE (2 * GIGABYTE)
+
 /**
  * Other Constants
  */

src/kernel/heapmgr.C

@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2010,2020                        */
+/* Contributors Listed Below - COPYRIGHT 2010,2023                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -33,6 +33,8 @@
 #include <usr/debugpointers.H>
 #include <arch/magic.H>
 #include <usr/vmmconst.h>
+#include <kernel/misc.H>
+#include <stdlib.h>
 
 #ifdef HOSTBOOT_DEBUG
 #define SMALL_HEAP_PAGES_TRACKED 64
@@ -264,16 +266,21 @@ void* _enforceBigFence(void* const i_pAddr)
 
 void * HeapManager::allocate(size_t i_sz)
 {
+
     HeapManager& hmgr = Singleton<HeapManager>::instance();
     size_t overhead = 0;
 
 #ifdef CONFIG_MALLOC_FENCING
     overhead = offsetof(fence_t,data) + sizeof(CHECK::END);
 #endif
-
+    // do not want huge allocations when in kernel mode (huge
+    // allocations use mm_alloc_block); kernel memory accesses don't
+    // go through page translation.
     if( (i_sz + overhead > MAX_BIG_ALLOC_SIZE)
-        && (i_sz + overhead <= HC_SLOT_SIZE) )
+        && (i_sz + overhead <= HC_SLOT_SIZE)
+        && !(KernelMisc::in_kernel_mode()))
     {
+
         printkd("allocateHuge=%ld [%d]\n", i_sz, task_gettid());
         void* ptr = hmgr._allocateHuge(i_sz);
         if( ptr )
@@ -859,7 +866,8 @@ void* HeapManager::_allocateBig(size_t i_sz)
     }
     if(!bc)
     {
-        bc = new big_chunk_t(v,pages);
+        bc = (big_chunk_t*) contiguous_malloc(sizeof(big_chunk_t));
+        bc = new (bc) big_chunk_t(v,pages);
         big_chunk_stack.push(bc);
     }
 
@@ -975,8 +983,8 @@ void* HeapManager::_allocateHuge(size_t i_sz)
              addr >= VMM_VADDR_MALLOC;
              addr -= HC_SLOT_SIZE )
         {
-            huge_chunk_t* hc =
-              new huge_chunk_t(reinterpret_cast<void*>(addr),0);
+            auto hc = static_cast<huge_chunk_t*>(contiguous_malloc(sizeof(huge_chunk_t)));
+            hc = new (hc) huge_chunk_t(reinterpret_cast<void*>(addr),0);
             huge_chunk_stack.push(hc);
         }
 
@@ -1019,6 +1027,7 @@ void* HeapManager::_allocateHuge(size_t i_sz)
     int rc = mm_set_permission(hc->addr,
                                pages*PAGESIZE,
                                WRITABLE | ALLOCATE_FROM_ZERO );
+
     if(rc != 0)
     {
         printk( "_allocateHuge> mm_set_permission failed for requested size=%ld!!\n", i_sz );
@@ -1137,4 +1146,3 @@ void* HeapManager::_reallocHuge(void* i_ptr, size_t i_sz)
 
     return i_ptr;
 }
-

src/kernel/ptmgr.C

@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2011,2022                        */
+/* Contributors Listed Below - COPYRIGHT 2011,2023                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -328,7 +328,7 @@ PageTableManager::PageTableManager( bool i_userSpace )
     uint64_t l_hrmor = 0;
     if( i_userSpace )
     {
-        ivTABLE = new char[getSize()];
+        ivTABLE = static_cast<char*>(contiguous_malloc(getSize()));
         printk( "** PageTableManager running in USER_SPACE : ivTABLE = %p**\n", ivTABLE );
         l_hrmor = cpu_spr_value(CPU_SPR_HRMOR);
     }
@@ -1287,4 +1287,3 @@ void PageTableManager::_flush( void )
         ++pte;
     }
 }
-