runtime: allow "huge objects" to be allocated with malloc

This enables the runtime to operate at the same time as malloc without trouble.

Author: nickwanninger

runtime/core/Heap.cpp

@@ -14,6 +14,7 @@
 #include <alaska/Logger.hpp>
 #include <alaska/Heap.hpp>
 #include "alaska/HeapPage.hpp"
+#include "alaska/HugeObjectAllocator.hpp"
 #include "alaska/LocalityPage.hpp"
 #include "alaska/SizeClass.hpp"
 #include "alaska/utils.h"
@@ -156,9 +157,10 @@ namespace alaska {
 
 
   ////////////////////////////////////
-  Heap::Heap(void)
+  Heap::Heap(alaska::Configuration &config)
       : pm()
-      , pt(pm.get_start()) {
+      , pt(pm.get_start())
+      , huge_allocator(config.huge_strategy) {
     log_debug("Heap: Initialized heap");
   }
 

runtime/core/HugeObjectAllocator.cpp

@@ -10,12 +10,19 @@
  */
 
 
+#include <malloc.h>
+#include <stdlib.h>
+
 #include <alaska/Heap.hpp>
 #include <alaska/HugeObjectAllocator.hpp>
+#include <alaska/liballoc.h>
 #include <alaska/list_head.h>
 
 namespace alaska {
-  HugeObjectAllocator::HugeObjectAllocator() { INIT_LIST_HEAD(&this->allocations); }
+  HugeObjectAllocator::HugeObjectAllocator(HugeAllocationStrategy strat)
+      : strat(strat) {
+    INIT_LIST_HEAD(&this->allocations);
+  }
 
   HugeObjectAllocator::~HugeObjectAllocator() {
     HugeHeader *entry, *temp;
@@ -30,6 +37,11 @@ namespace alaska {
 
 
   void* HugeObjectAllocator::allocate(size_t size) {
+    if (strat == HugeAllocationStrategy::MALLOC_BACKED) {
+      return ::malloc(size);
+    }
+    ALASKA_ASSERT(strat == HugeAllocationStrategy::CUSTOM_MMAP_BACKED, "Invalid huge strat");
+
     ck::scoped_lock l(m_lock);
 
     size_t mapping_size = ((size + sizeof(HugeHeader)) + 4095) & ~4095;
@@ -54,6 +66,11 @@ namespace alaska {
 
 
   bool HugeObjectAllocator::free(void* ptr) {
+    if (strat == HugeAllocationStrategy::MALLOC_BACKED) {
+      ::free(ptr);
+      return true;
+    }
+    ALASKA_ASSERT(strat == HugeAllocationStrategy::CUSTOM_MMAP_BACKED, "Invalid huge strat");
     ck::scoped_lock l(m_lock);
 
     // Get the HugeHeader object from the user pointer
@@ -70,6 +87,8 @@ namespace alaska {
 
 
   size_t HugeObjectAllocator::size_of(void* ptr) {
+    if (strat == HugeAllocationStrategy::MALLOC_BACKED) return ::malloc_usable_size(ptr);
+
     ck::scoped_lock l(m_lock);
     HugeHeader* header = find_header(ptr);
     if (header != nullptr) {
@@ -80,6 +99,8 @@ namespace alaska {
 
 
   bool HugeObjectAllocator::owns(void* ptr) {
+    if (strat == HugeAllocationStrategy::MALLOC_BACKED) return true;
+
     ck::scoped_lock l(m_lock);
     // If the header is null, this allocator doesn't own it.
     return find_header(ptr) != nullptr;
@@ -97,4 +118,4 @@ namespace alaska {
     // If no matching header is found, return nullptr
     return nullptr;
   }
-}  // namespace alaska}  // namespace alaska
+}  // namespace alaska

runtime/core/Logger.cpp

@@ -100,13 +100,14 @@ namespace alaska {
 
 
       // Grab the lock
-      pthread_mutex_lock(&log_mutex);
+      // pthread_mutex_lock(&log_mutex);
 
-      time_t t = time(NULL);
-      auto time = localtime(&t);
+      // time_t t = time(NULL);
+      // auto time = localtime(&t);
 
       char buf[16];
-      buf[strftime(buf, sizeof(buf), "%H:%M:%S", time)] = '\0';
+      buf[0] = '\0';
+      // buf[strftime(buf, sizeof(buf), "%H:%M:%S", time)] = '\0';
 
       if (enable_colors) {
         log_emitf("%s %s%-5s\x1b[0m \x1b[90m%s:%d\x1b[0m | ", buf, level_colors[level],
@@ -119,7 +120,7 @@ namespace alaska {
       log_emitf("\n");
 
       // release the lock
-      pthread_mutex_unlock(&log_mutex);
+      // pthread_mutex_unlock(&log_mutex);
       va_end(args);
     }
   }

runtime/core/Runtime.cpp

@@ -27,7 +27,8 @@ namespace alaska {
 
 
   Runtime::Runtime(alaska::Configuration config)
-      : handle_table(config) {
+      : handle_table(config)
+      , heap(config) {
     // Validate that there is not already a runtime (TODO: atomics?)
     ALASKA_ASSERT(g_runtime == nullptr, "Cannot create more than one runtime");
 

runtime/include/alaska/Configuration.hpp

@@ -12,12 +12,16 @@
 #pragma once
 
 #include <stdint.h>
+#include <alaska/HugeObjectAllocator.hpp>
 
 namespace alaska {
   // This structure is threaded through the creation of the runtime to
   // allow configuration of various features.
   struct Configuration {
     uintptr_t handle_table_location =
         (0x8000000000000000LLU >> (ALASKA_SIZE_BITS - ALASKA_SQUEEZE_BITS));
+
+    // Allocate using a custom mmap backend by default for large objects.
+    HugeAllocationStrategy huge_strategy = HugeAllocationStrategy::CUSTOM_MMAP_BACKED;
   };
 }  // namespace alaska

runtime/include/alaska/Heap.hpp

@@ -18,6 +18,7 @@
 #include <alaska/Magazine.hpp>
 #include <alaska/HugeObjectAllocator.hpp>
 #include <alaska/track.hpp>
+#include "alaska/Configuration.hpp"
 #include "alaska/LocalityPage.hpp"
 #include <ck/vec.h>
 #include <stdlib.h>
@@ -137,7 +138,7 @@ namespace alaska {
 
     HugeObjectAllocator huge_allocator;
 
-    Heap(void);
+    Heap(alaska::Configuration &config);
     ~Heap(void);
 
     // Get an unowned sized page given a certain size request.
@@ -175,17 +176,6 @@ namespace alaska {
     ck::mutex lock;
     alaska::Magazine<alaska::SizedPage> size_classes[alaska::num_size_classes];
     alaska::Magazine<alaska::LocalityPage> locality_pages;
-
-
-    // Huge objects are managed independently of the size classes. They are allocated
-    // directly from the kernel and are *not handles*
-    ck::mutex huge_lock;
-    struct list_head huge_allocations;
-
-    struct HugeHeader {
-      struct list_head list;
-      size_t size;
-    };
   };
 
 

runtime/include/alaska/HugeObjectAllocator.hpp

@@ -16,9 +16,18 @@
 #include <ck/lock.h>
 
 namespace alaska {
+
+
+  // The HugeObjectAllocator can be configured with different strategies. The main one
+  // uses a custom mmap based strategy to track large objects. The other option is one
+  // which is backed by libc's malloc, instead
+  enum class HugeAllocationStrategy {
+    CUSTOM_MMAP_BACKED,
+    MALLOC_BACKED,
+  };
   class HugeObjectAllocator final {
    public:
-    HugeObjectAllocator();
+    HugeObjectAllocator(HugeAllocationStrategy strat);
     ~HugeObjectAllocator();
 
     void* allocate(size_t size);
@@ -32,6 +41,7 @@ namespace alaska {
     bool owns(void* ptr);
 
    private:
+    HugeAllocationStrategy strat;
     ck::mutex m_lock;
     struct list_head allocations = LIST_HEAD_INIT(allocations);
 
@@ -50,4 +60,4 @@ namespace alaska {
 
     HugeHeader* find_header(void* ptr);
   };
-}  // namespace alaska
+}  // namespace alaska

runtime/test/heap_test.cpp

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 #include <alaska.h>
+#include "alaska/Configuration.hpp"
 #include "alaska/Logger.hpp"
 #include "alaska/SizeClass.hpp"
 #include "gtest/gtest.h"
@@ -8,6 +9,8 @@
 
 #include <alaska/Runtime.hpp>
 
+
+static alaska::Configuration g_config;
 class HeapTest : public ::testing::Test {
  public:
   void SetUp() override {
@@ -16,7 +19,7 @@ class HeapTest : public ::testing::Test {
   }
   void TearDown() override {}
 
-  alaska::Heap heap;
+  alaska::Heap heap {g_config};
 };
 
 

runtime/test/hugeobject_test.cpp

@@ -8,7 +8,13 @@
 
 class HugeObjectTest : public ::testing::Test {
  public:
-  alaska::HugeObjectAllocator allocator;
+  alaska::HugeObjectAllocator allocator{alaska::HugeAllocationStrategy::CUSTOM_MMAP_BACKED};
+};
+
+
+class HugeObjectMallocTest : public ::testing::Test {
+ public:
+  alaska::HugeObjectAllocator allocator{alaska::HugeAllocationStrategy::MALLOC_BACKED};
 };
 
 TEST_F(HugeObjectTest, AllocateAndDeallocate) {
@@ -97,3 +103,47 @@ TEST_F(HugeObjectTest, FreeNonOwnedPointer) {
   // Deallocate the owned pointer
   allocator.free(ptr);
 }
+
+
+
+TEST_F(HugeObjectMallocTest, ValidMalloc) {
+  // Allocate a huge object
+  void* ptr = allocator.allocate(1024);
+
+  // Verify that the allocation was successful
+  ASSERT_NE(ptr, nullptr);
+
+  EXPECT_EXIT(
+      {
+        // Code that might crash.
+        ::free(ptr);
+        fprintf(stderr, "Free worked!\n");
+        exit(0);  // Prevents the test from failing due to lack of exit
+      },
+      ::testing::ExitedWithCode(0), "Free worked");
+}
+
+TEST_F(HugeObjectMallocTest, FreeWorks) {
+  // Allocate a huge object
+  void* ptr = ::malloc(1024);
+
+  // Verify that the allocation was successful
+  ASSERT_NE(ptr, nullptr);
+
+  EXPECT_EXIT(
+      {
+        // Code that might crash.
+        ASSERT_TRUE(allocator.free(ptr));
+        fprintf(stderr, "Free worked!\n");
+        exit(0);  // Prevents the test from failing due to lack of exit
+      },
+      ::testing::ExitedWithCode(0), "Free worked");
+}
+
+
+
+TEST_F(HugeObjectMallocTest, SizeofWorks) {
+  // Allocate a huge object
+  void* ptr = ::malloc(1024);
+  ASSERT_GE(allocator.size_of(ptr), 1024);
+}

runtime/yukon/yukon.cpp

@@ -14,8 +14,8 @@
 #include <alaska/alaska.hpp>
 #include <alaska/utils.h>
 #include <alaska/Runtime.hpp>
-#include "alaska/Configuration.hpp"
-#include "alaska/liballoc.h"
+#include <alaska/Configuration.hpp>
+#include <alaska/liballoc.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <signal.h>
@@ -47,6 +47,8 @@ static alaska::Runtime *the_runtime = NULL;
 
 static bool dead = false;
 
+static bool is_initialized() { return the_runtime != NULL; }
+
 
 static void print_hex(const char *msg, uint64_t val) {
   char buf[512];
@@ -63,25 +65,8 @@ static void print_words(unsigned *words, int n) {
   write(STDOUT_FILENO, "\n", 1);
 }
 
-void segfault_handler(int sig) {
-  dead = true;
-  write(STDOUT_FILENO, "segfault\n", 4);
-  void *array[BACKTRACE_SIZE];
-  size_t size;
-
-  // Get the backtrace
-  size = backtrace(array, BACKTRACE_SIZE);
-
-  for (size_t i = 0; i < size; i++) {
-    print_hex("bt:", (uint64_t)array[i]);
-    print_words((unsigned *)array[i], 4);
-  }
-  exit(0);
-
-  // Print the backtrace to stderr
-  char **ns = backtrace_symbols(array, size);
-}
 
+static void print_string(const char *msg) { write(STDOUT_FILENO, msg, strlen(msg)); }
 
 static char stdout_buf[BUFSIZ];
 static char stderr_buf[BUFSIZ];
@@ -115,17 +100,18 @@ static alaska::ThreadCache *get_tc() {
 }
 
 void __attribute__((constructor(102))) alaska_init(void) {
-  init();
+  unsetenv("LD_PRELOAD"); // make it so we don't run alaska in subprocesses!
+  get_tc();
 }
 
 void __attribute__((destructor)) alaska_deinit(void) {
-  if (the_runtime != NULL) {
-    if (tc != NULL) {
-      the_runtime->del_threadcache(tc);
-    }
-    delete the_runtime;
-  }
-  set_ht_addr(NULL);
+  // if (the_runtime != NULL) {
+  //   if (tc != NULL) {
+  //     the_runtime->del_threadcache(tc);
+  //   }
+  //   delete the_runtime;
+  // }
+  // set_ht_addr(NULL);
 }