Fix memory performance issue related to aligned_alloc (#149)

I was profiling `wtf` and found a behavior that I wasn't aware of. Basically, every calls we make to `aligned_alloc` allocates 8kish instead of 4kish. For whatever reason, I made an assumption that it would use a special allocator; it isn't a special allocator it just wraps a call to `malloc` with that math: `v5 = malloc(Alignment - 1 + Size + 8);`. In our case, both `Alignment` & `Size` are `0x1000`.

I switched the calls to `aligned_alloc` to `VirtualAlloc` / `mmap` to match the behavior that I wanted in the first place. We also don't need page aligned chunks in the `Ram_t` object, so I turned this one into a `malloc` call.

Author: 0vercl0k

src/wtf/bochscpu_backend.cc

@@ -70,8 +70,45 @@ void StaticGpaMissingHandler(const uint64_t Gpa) {
   // (0000022ed2ae7000 + 00000738).
   //
 
-  uint8_t *Page = (uint8_t *)aligned_alloc(Page::Size, Page::Size);
+#if defined WINDOWS
+
+  //
+  // VirtualAlloc is able to give us back page-aligned allocation, but every
+  // time we allocate 1 page, the allocator actually reserve a 64KB region of VA
+  // and we'll use the first page of that. This basically fragment the
+  // address-space, so what we do is we actually reserve a 64KB region, and
+  // we'll commit pages as we need them.
+  //
+
+  static size_t Left = 0;
+  static uint8_t *Current = nullptr;
+  if (Left == 0) {
+
+    //
+    // It's time to reserve a 64KB region.
+    //
+
+    const uint64_t _64KB = 1024 * 64;
+    Left = _64KB;
+    Current =
+        (uint8_t *)VirtualAlloc(nullptr, Left, MEM_RESERVE, PAGE_READWRITE);
+  }
+
+  //
+  // Commit a page off the reserved region.
+  //
+
+  uint8_t *Page =
+      (uint8_t *)VirtualAlloc(Current, Page::Size, MEM_COMMIT, PAGE_READWRITE);
+
+  Left -= Page::Size;
+  Current += Page::Size;
   if (Page == nullptr) {
+#elif defined LINUX
+  uint8_t *Page = (uint8_t *)mmap(nullptr, Page::Size, PROT_READ | PROT_WRITE,
+                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  if (Page == (void *)-1) {
+#endif
     fmt::print("Failed to allocate memory in GpaMissingHandler.\n");
     __debugbreak();
   }

src/wtf/platform.h

@@ -18,8 +18,6 @@ using ssize_t = SSIZE_T;
 #define __builtin_bswap16 _byteswap_ushort
 #define __builtin_bswap32 _byteswap_ulong
 #define __builtin_bswap64 _byteswap_uint64
-#define aligned_alloc(a, b) _aligned_malloc(a, b)
-#define aligned_free(x) _aligned_free(x)
 #if defined ARCH_X86
 #define WINDOWS_X86
 #elif defined ARCH_X64

src/wtf/ram.h

@@ -74,7 +74,7 @@ class Ram_t {
 
   ~Ram_t() {
     for (const auto &[_, Page] : Cache_) {
-      aligned_free(Page);
+      free(Page);
     }
 
     if (Ram_ != nullptr) {
@@ -172,9 +172,9 @@ class Ram_t {
     //
 
     else {
-      Page = (uint8_t *)aligned_alloc(Page::Size, Page::Size);
+      Page = (uint8_t *)malloc(Page::Size);
       if (Page == nullptr) {
-        fmt::print("Failed to call aligned_alloc.\n");
+        fmt::print("Failed to allocate memory.\n");
         return nullptr;
       }
 
@@ -302,7 +302,7 @@ class Ram_t {
 
 private:
   //
-  // Get an HVA fora GPA by looking at our cache.
+  // Get an HVA for a GPA by looking at our cache.
   //
 
   [[nodiscard]] uint8_t *GetHvaFromCache(const Gpa_t Gpa) {