Alloc refactor

include/runtime/arena.h

@@ -10,7 +10,53 @@ extern "C" {
 
 // An arena can be used to allocate objects that can then be deallocated all at
 // once.
-struct arena {
+class arena {
+public:
+  arena(char id)
+      : allocation_semispace_id(id) { }
+  void *kore_arena_alloc(size_t requested);
+
+  // Returns the address of the first byte that belongs in the given arena.
+  // Returns 0 if nothing has been allocated ever in that arena.
+  char *arena_start_ptr() const;
+
+  // Returns a pointer to a location holding the address of last allocated
+  // byte in the given arena plus 1.
+  // This address is 0 if nothing has been allocated ever in that arena.
+  char **arena_end_ptr();
+
+  // return the total number of allocatable bytes currently in the arena in its
+  // active semispace.
+  size_t arena_size() const;
+
+  // Clears the current allocation space by setting its start back to its first
+  // block. It is used during garbage collection to effectively collect all of the
+  // arena.
+  void arena_clear();
+
+  // Resizes the last allocation as long as the resize does not require a new
+  // block allocation.
+  // Returns the address of the byte following the last newlly allocated byte when
+  // the resize succeeds, returns 0 otherwise.
+  void *arena_resize_last_alloc(ssize_t increase);
+
+  // Returns the given arena's current collection semispace ID.
+  // Each arena has 2 semispace IDs one equal to the arena ID and the other equal
+  // to the 1's complement of the arena ID. At any time one of these semispaces
+  // is used for allocation and the other is used for collection.
+  char get_arena_collection_semispace_id() const;
+
+  // Exchanges the current allocation and collection semispaces and clears the new
+  // current allocation semispace by setting its start back to its first block.
+  // It is used before garbage collection.
+  void arena_swap_and_clear();
+
+private:
+  void fresh_block();
+
+  // helper function for `kore_arena_alloc`. Do not call directly.
+  void *do_alloc_slow(size_t requested);
+
   char *first_block;
   char *block;
   char *block_start;
@@ -29,78 +75,43 @@ using memory_block_header = struct {
 
 // Macro to define a new arena with the given ID. Supports IDs ranging from 0 to
 // 127.
-#define REGISTER_ARENA(name, id)                                               \
-  static struct arena name = {.allocation_semispace_id = (id)}
+#define REGISTER_ARENA(name, id) static thread_local arena name(id)
 
 #define MEM_BLOCK_START(ptr)                                                   \
   ((char *)(((uintptr_t)(ptr)-1) & ~(BLOCK_SIZE - 1)))
 
+#ifdef __MACH__
+//
+//	thread_local disabled for Apple
+//
 extern bool time_for_collection;
+#else
+extern thread_local bool time_for_collection;
+#endif
 
 size_t get_gc_threshold();
 
-// Resets the given arena.
-void arena_reset(struct arena *);
-
-// Returns the given arena's current allocation semispace ID.
-// Each arena has 2 semispace IDs one equal to the arena ID and the other equal
-// to the 1's complement of the arena ID. At any time one of these semispaces
-// is used for allocation and the other is used for collection.
-char get_arena_allocation_semispace_id(const struct arena *);
-
-// Returns the given arena's current collection semispace ID.
-// See above for details.
-char get_arena_collection_semispace_id(const struct arena *);
-
 // Returns the ID of the semispace where the given address was allocated.
 // The behavior is undefined if called with an address that has not been
 // allocated within an arena.
 char get_arena_semispace_id_of_object(void *);
 
-// helper function for `kore_arena_alloc`. Do not call directly.
-void *do_alloc_slow(size_t, struct arena *);
-
 // Allocates the requested number of bytes as a contiguous region and returns a
 // pointer to the first allocated byte.
 // If called with requested size greater than the maximun single allocation
 // size, the space is allocated in a general (not garbage collected pool).
-inline void *kore_arena_alloc(struct arena *arena, size_t requested) {
-  if (arena->block + requested > arena->block_end) {
-    return do_alloc_slow(requested, arena);
+inline void *arena::kore_arena_alloc(size_t requested) {
+  if (block + requested > block_end) {
+    return do_alloc_slow(requested);
   }
-  void *result = arena->block;
-  arena->block += requested;
+  void *result = block;
+  block += requested;
   MEM_LOG(
       "Allocation at %p (size %zd), next alloc at %p (if it fits)\n", result,
-      requested, arena->block);
+      requested, block);
   return result;
 }
 
-// Resizes the last allocation as long as the resize does not require a new
-// block allocation.
-// Returns the address of the byte following the last newlly allocated byte when
-// the resize succeeds, returns 0 otherwise.
-void *arena_resize_last_alloc(struct arena *, ssize_t);
-
-// Exchanges the current allocation and collection semispaces and clears the new
-// current allocation semispace by setting its start back to its first block.
-// It is used before garbage collection.
-void arena_swap_and_clear(struct arena *);
-
-// Clears the current allocation space by setting its start back to its first
-// block. It is used during garbage collection to effectively collect all of the
-// arena.
-void arena_clear(struct arena *);
-
-// Returns the address of the first byte that belongs in the given arena.
-// Returns 0 if nothing has been allocated ever in that arena.
-char *arena_start_ptr(const struct arena *);
-
-// Returns a pointer to a location holding the address of last allocated
-// byte in the given arena plus 1.
-// This address is 0 if nothing has been allocated ever in that arena.
-char **arena_end_ptr(struct arena *);
-
 // Given a starting pointer to an address allocated in an arena and a size in
 // bytes, this function returns a pointer to an address allocated in the
 // same arena after size bytes from the starting pointer.
@@ -119,10 +130,6 @@ char *move_ptr(char *, size_t, char const *);
 // different arenas.
 ssize_t ptr_diff(char *, char *);
 
-// return the total number of allocatable bytes currently in the arena in its
-// active semispace.
-size_t arena_size(const struct arena *);
-
 // Deallocates all the memory allocated for registered arenas.
 void free_all_memory(void);
 }

include/runtime/collect.h

@@ -26,8 +26,8 @@ using set_node = set::iterator::node_t;
 using set_impl = set::iterator::tree_t;
 
 extern "C" {
-extern size_t numBytesLiveAtCollection[1 << AGE_WIDTH];
-extern bool collect_old;
+extern thread_local size_t numBytesLiveAtCollection[1 << AGE_WIDTH];
+extern thread_local bool collect_old;
 size_t get_size(uint64_t, uint16_t);
 void migrate_static_roots(void);
 void migrate(block **block_ptr);

include/runtime/header.h

@@ -47,8 +47,14 @@ size_t hash_k(block *);
 void k_hash(block *, void *);
 bool hash_enter(void);
 void hash_exit(void);
-
+#ifdef __MACH__
+//
+//	thread_local disabled for Apple
+//
 extern bool gc_enabled;
+#else
+extern thread_local bool gc_enabled;
+#endif
 }
 
 class k_elem {

lib/codegen/CreateTerm.cpp

@@ -782,18 +782,47 @@ llvm::Value *create_term::disable_gc() {
   llvm::Constant *global
       = module_->getOrInsertGlobal("gc_enabled", llvm::Type::getInt1Ty(ctx_));
   auto *global_var = llvm::cast<llvm::GlobalVariable>(global);
+#ifdef __MACH__
+  //
+  //	thread_local disabled for Apple
+  //
+  /*
+  global_var->setThreadLocal(true);
+  llvm::IRBuilder b(current_block_);
+  auto *global_var_address = b.CreateThreadLocalAddress(global_var);
+  */
+  auto *global_var_address = global_var;
+#else
+  global_var->setThreadLocal(true);
+  auto *global_var_address = global_var;
+#endif
   auto *old_val = new llvm::LoadInst(
-      llvm::Type::getInt1Ty(ctx_), global_var, "was_enabled", current_block_);
+      llvm::Type::getInt1Ty(ctx_), global_var_address, "was_enabled",
+      current_block_);
   new llvm::StoreInst(
-      llvm::ConstantInt::getFalse(ctx_), global_var, current_block_);
+      llvm::ConstantInt::getFalse(ctx_), global_var_address, current_block_);
   return old_val;
 }
 
 void create_term::enable_gc(llvm::Value *was_enabled) {
   llvm::Constant *global
       = module_->getOrInsertGlobal("gc_enabled", llvm::Type::getInt1Ty(ctx_));
   auto *global_var = llvm::cast<llvm::GlobalVariable>(global);
-  new llvm::StoreInst(was_enabled, global_var, current_block_);
+#ifdef __MACH__
+  //
+  //	thread_local disabled for Apple
+  //
+  /*
+  global_var->setThreadLocal(true);
+  llvm::IRBuilder b(current_block_);
+  auto *global_var_address = b.CreateThreadLocalAddress(global_var);
+  */
+  auto *global_var_address = global_var;
+#else
+  global_var->setThreadLocal(true);
+  auto *global_var_address = global_var;
+#endif
+  new llvm::StoreInst(was_enabled, global_var_address, current_block_);
 }
 
 // We use tailcc calling convention for apply_rule_* and eval_* functions to

lib/codegen/Decision.cpp

@@ -5,6 +5,7 @@
 #include "kllvm/codegen/ProofEvent.h"
 #include "kllvm/codegen/Util.h"
 
+#include "llvm/IR/IRBuilder.h"
 #include <llvm/ADT/APInt.h>
 #include <llvm/ADT/SmallString.h>
 #include <llvm/ADT/StringMap.h>
@@ -1012,9 +1013,25 @@ std::pair<std::vector<llvm::Value *>, llvm::BasicBlock *> step_function_header(
 
   auto *collection = module->getOrInsertGlobal(
       "time_for_collection", llvm::Type::getInt1Ty(module->getContext()));
+
+#ifdef __MACH__
+  //
+  //	thread_local disabled for Apple
+  //
+  /*
+  llvm::cast<llvm::GlobalVariable>(collection)->setThreadLocal(true);
+  llvm::IRBuilder b(check_collect);
+  auto *collection_address = b.CreateThreadLocalAddress(collection);
+  */
+  auto *collection_address = collection;
+#else
+  llvm::cast<llvm::GlobalVariable>(collection)->setThreadLocal(true);
+  auto *collection_address = collection;
+#endif
+
   auto *is_collection = new llvm::LoadInst(
-      llvm::Type::getInt1Ty(module->getContext()), collection, "is_collection",
-      check_collect);
+      llvm::Type::getInt1Ty(module->getContext()), collection_address,
+      "is_collection", check_collect);
   set_debug_loc(is_collection);
   auto *collect = llvm::BasicBlock::Create(
       module->getContext(), "isCollect", block->getParent());