runtime: add a templated "Object Allocator"

This class takes the size it is allocating as a template parameter,
which should let us speedup allocation by removing a divide in the
fast path

Author: nickwanninger

runtime/CMakeLists.txt

@@ -213,6 +213,7 @@ if (ALASKA_ENABLE_TESTING)
 		test/threadcache_test.cpp
 		test/hugeobject_test.cpp
     test/sizedalloc_test.cpp
+    test/object_allocator_test.cpp
 	)
 
 	target_link_libraries(

runtime/include/alaska/ObjectAllocator.hpp

@@ -0,0 +1,134 @@
+/*
+ * This file is part of the Alaska Handle-Based Memory Management System
+ *
+ * Copyright (c) 2024, Nick Wanninger <ncw@u.northwestern.edu>
+ * Copyright (c) 2024, The Constellation Project
+ * All rights reserved.
+ *
+ * This is free software.  You are permitted to use, redistribute,
+ * and modify it as specified in the file "LICENSE".
+ */
+
+#pragma once
+
+#include <stdlib.h>
+#include <sys/cdefs.h>
+#include <alaska/ShardedFreeList.hpp>
+#include <alaska/HeapPage.hpp>
+#include <alaska/track.hpp>
+
+namespace alaska {
+
+  template <typename T>
+  class ObjectAllocator {
+   public:
+    ObjectAllocator(void) = default;
+    ObjectAllocator(void *objects, long object_count) { configure(objects, object_count); }
+
+    T *alloc(void);
+
+    // Free objects. NOTE: no checks are made that this pointer is valid!
+    inline void release_local(void *ptr) {
+      free_list.free_local(ptr);
+      alaska_track_free(ptr, 0);
+    }
+    inline void release_remote(void *ptr) {
+      free_list.free_remote(ptr);
+      alaska_track_free(ptr, 0);
+    }
+
+    void configure(void *objects, long object_count);
+
+    inline bool some_available(void) {
+      return free_list.has_local_free() || free_list.has_remote_free() ||
+             (bump_next != objects_end);
+    }
+
+
+    inline long num_free(void) const {
+      return num_free_in_free_list() + num_free_in_bump_allocator();
+    }
+
+    inline long num_free_in_free_list(void) const { return free_list.num_free(); }
+
+    inline long num_free_in_bump_allocator(void) const {
+      return (((uintptr_t)objects_end - (uintptr_t)bump_next) / sizeof(T));
+    }
+
+
+    // return the index of the object
+    inline long object_index(void *ob) {
+      return ((uintptr_t)ob - (uintptr_t)this->objects_start) / this->object_size;
+    }
+
+    long extend(long count);
+
+   private:
+    T *alloc_slow(void);
+
+    void *objects_start;                // The start of the object memory
+    void *objects_end;                  // The end of the object memory (exclusive)
+    void *bump_next;                    // The next object to be bump allocated.
+    alaska::ShardedFreeList free_list;  // A free list for tracking releases
+  };
+
+
+
+
+  template <typename T>
+  __attribute__((always_inline)) inline T *ObjectAllocator<T>::alloc(void) {
+    void *object = free_list.pop();
+
+    if (unlikely(object == nullptr)) {
+      return alloc_slow();
+    }
+
+    alaska_track_malloc_size(object, sizeof(T), object_size, 0);
+
+    return (T*)object;
+  }
+
+
+  template <typename T>
+  __attribute__((noinline)) inline T *ObjectAllocator<T>::alloc_slow(void) {
+    long extended_count = extend(128);
+
+    // 1. If we managed to extend the list, return one of the blocks from it.
+    if (extended_count > 0) {
+      // Fall back into the alloc function to do the heavy lifting of actually allocating
+      // one of the blocks we just extended the list with.
+      return alloc();
+    }
+
+    // 2. If the list was not extended, try swapping the remote_free list and the local_free list.
+    // This is a little tricky because we need to worry about atomics here.
+    free_list.swap();
+
+    // If local-free is still null, return null
+    if (not free_list.has_local_free()) return nullptr;
+
+    // Otherwise, fall back to alloc
+    return alloc();
+  }
+
+
+  template <typename T>
+  inline long ObjectAllocator<T>::extend(long count) {
+    long e = 0;
+    for (; e < count && bump_next != objects_end; e++) {
+      free_list.free_local(bump_next);
+      bump_next = (void *)((uintptr_t)bump_next + sizeof(T));
+    }
+    return e;
+  }
+
+
+  template <typename T>
+  inline void ObjectAllocator<T>::configure(void *objects, long object_count) {
+    this->objects_start = this->bump_next = objects;
+    this->objects_end = (void *)((uintptr_t)objects + (object_count * sizeof(T)));
+    // Re-construct the free list just in case
+    this->free_list = ShardedFreeList();
+  }
+
+};  // namespace alaska

runtime/test/object_allocator_test.cpp

@@ -0,0 +1,77 @@
+// This file tests alaska::HugeObjectAllocator
+
+#include <alaska/ObjectAllocator.hpp>
+#include "alaska/utils.h"
+#include <gtest/gtest.h>
+#include "alaska/Logger.hpp"
+
+
+
+class ObjectAllocatorTest : public ::testing::Test {
+ public:
+  void SetUp() override {
+    // Make it so we only get warnings
+    alaska::set_log_level(LOG_WARN);
+
+
+
+    buffer = calloc(object_count, object_size);
+    salloc.configure(buffer, object_count);
+  }
+  void TearDown() override { free(buffer); }
+
+
+  long object_size = 16;
+  long object_count = 512;
+  void *buffer;
+  alaska::ObjectAllocator<uint64_t> salloc;
+};
+
+
+
+
+TEST_F(ObjectAllocatorTest, Sanity) {
+  // Out of the gate, the number of free objects must be equal to the number of objects
+  ASSERT_EQ(salloc.num_free(), object_count);
+}
+
+TEST_F(ObjectAllocatorTest, Extend) {
+  ASSERT_EQ(salloc.num_free_in_bump_allocator(), object_count);
+  long count = salloc.extend(1);
+
+  ASSERT_EQ(salloc.num_free_in_free_list(), 1);
+  // out of the gate, the number of free objects must be equal to the number of objects
+  ASSERT_EQ(salloc.num_free_in_bump_allocator(), object_count - count);
+}
+
+
+TEST_F(ObjectAllocatorTest, Allocate) {
+  auto *b = salloc.alloc();
+  ASSERT_NE(b, nullptr);
+}
+
+
+TEST_F(ObjectAllocatorTest, AllocateNumFree) {
+  auto initial_nfree = salloc.num_free();
+  salloc.alloc();
+  ASSERT_EQ(salloc.num_free(), initial_nfree - 1);
+}
+
+
+TEST_F(ObjectAllocatorTest, ReleaseLocalNumFree) {
+  auto *b = salloc.alloc();
+  ASSERT_NE(b, nullptr);
+  ASSERT_EQ(salloc.num_free(), object_count - 1);
+
+  salloc.release_local(b);
+  ASSERT_EQ(salloc.num_free(), object_count);
+}
+
+TEST_F(ObjectAllocatorTest, ReleaseRemoteNumFree) {
+  auto *b = salloc.alloc();
+  ASSERT_NE(b, nullptr);
+  ASSERT_EQ(salloc.num_free(), object_count - 1);
+
+  salloc.release_local(b);
+  ASSERT_EQ(salloc.num_free(), object_count);
+}