runtime: integrate an optional "sim" api for simulating htlb

Author: nickwanninger

runtime/core/LocalityPage.cpp

@@ -36,6 +36,8 @@ namespace alaska {
 
     log_trace("setting md to %p", &m);
     md->mapping = const_cast<alaska::Mapping *>(&m);
+    md->size = size;
+    md->allocated = true;
     log_trace("set md!");
 
     return data;
@@ -46,6 +48,8 @@ namespace alaska {
     // Don't do anything other than
     auto md = find_md(ptr);
     md->mapping = nullptr;
+    md->data_raw = ptr;
+    md->allocated = false;
     return true;
   }
 
@@ -84,8 +88,8 @@ namespace alaska {
 
 
   size_t LocalityPage::size_of(void *data) {
-    abort();
-    return 0;
+    auto md = find_md(data);
+    return md->size;
   }
 
 }  // namespace alaska

runtime/core/Runtime.cpp

@@ -16,12 +16,14 @@
 #include "alaska/alaska.hpp"
 #include "alaska/utils.h"
 #include <stdlib.h>
+#include <alaska/utils.h>
 
 namespace alaska {
   // The default instance of a barrier manager.
   static BarrierManager global_nop_barrier_manager;
   // The current global instance of the runtime, since we can only have one at a time
   static Runtime *g_runtime = nullptr;
+  static volatile bool runtime_initialized = false;
 
 
   Runtime::Runtime() {
@@ -33,6 +35,7 @@ namespace alaska {
     this->barrier_manager = &global_nop_barrier_manager;
 
     log_debug("Created a new Alaska Runtime @ %p", this);
+    atomic_set(runtime_initialized, true);
   }
 
   Runtime::~Runtime() {
@@ -73,4 +76,17 @@ namespace alaska {
   }
 
 
+  void wait_for_initialization(void) {
+    printf("waiting for initialization!\n");
+    while (not is_initialized()) {
+      sched_yield();
+    }
+    printf("Initialized!\n");
+  }
+
+
+  bool is_initialized(void) {
+    return atomic_get(runtime_initialized);
+  }
+
 }  // namespace alaska

runtime/core/ThreadCache.cpp

@@ -76,14 +76,12 @@ namespace alaska {
 
     // And set the owner
     heap->set_owner(this);
-    log_info("ThreadCache::halloc got new heap: %p. Avail = %lu", heap, heap->available());
 
     // Swap the heaps in the thread cache
     if (size_classes[cls] != nullptr) runtime.heap.put_page(size_classes[cls]);
     size_classes[cls] = heap;
 
     ALASKA_ASSERT(heap->available() > 0, "New heap must have space");
-    log_info("new heaps avail = %lu", heap->available());
     return heap;
   }
 
@@ -97,7 +95,6 @@ namespace alaska {
     this->locality_page = lp;
 
     ALASKA_ASSERT(lp->available() > 0, "New heap must have space");
-    log_info("new heaps avail = %lu", heap->available());
     return lp;
   }
 
@@ -240,43 +237,65 @@ namespace alaska {
   }
 
 
-
   bool ThreadCache::localize(void *handle, uint64_t epoch) {
     alaska::Mapping *m = alaska::Mapping::from_handle_safe(handle);
-    if (unlikely(m == nullptr)) return false;
+    if (unlikely(m == nullptr)) {
+      printf("%p No because not handle\n", handle);
+      return false;
+    }
 
+    return localize(*m, epoch);
+  }
 
-    void *ptr = m->get_pointer();
+
+  bool ThreadCache::localize(alaska::Mapping &m, uint64_t epoch) {
+    if (m.is_pinned() or m.is_free()) {
+      return false;
+    }
+    void *ptr = m.get_pointer();
     auto *source_page = this->runtime.heap.pt.get_unaligned(ptr);
     // if there wasn't a page for some reason, we can't localize.
-    if (unlikely(source_page == nullptr)) return false;
+    if (unlikely(source_page == nullptr)) {
+      // printf("no because no page for %p\n", (void*)m.encode());
+      return false;
+    }
     // if the page has recently been localized into, don't try again
-    if (unlikely(!source_page->should_localize_from(epoch))) return false;
-
+    if (unlikely(!source_page->should_localize_from(epoch))) {
+      // printf("no because shouldnt localize\n");
+      return false;
+    }
 
-    auto size = source_page->size_of(ptr);
-    if (locality_page == nullptr || locality_page->available() < size * 2) {
-      locality_page = new_locality_page(size);
+   auto size = source_page->size_of(ptr);
+    if (locality_page == nullptr or locality_page->available() < size * 2) {
+      locality_page = new_locality_page(size + 32);
     }
 
     // If we are moving an object within the locality page, don't.
     if (unlikely(source_page == locality_page)) return false;
 
+  //   void *dst = NULL;
 
-    void *d = locality_page->alloc(*m, size);
+  //   while (dst == NULL) {
+  //   dst = locality_page->alloc(m, size);
+  //   if (dst == nullptr) locality_page = new_locality_page(size);
+  // }
+
+    void *d = locality_page->alloc(m, size);
     locality_page->last_localization_epoch = epoch;
     memcpy(d, ptr, size);
+    memset(ptr, 0xFA, size);
 
     // TODO: invalidate!
-    m->set_pointer(d);
-
-    if (source_page->is_owned_by(this)) {
-      log_trace("Free handle %p locally (ptr = %p)", &m, ptr);
-      source_page->release_local(*m, ptr);
-    } else {
-      log_trace("Free handle %p remotely (ptr = %p)", &m, ptr);
-      source_page->release_remote(*m, ptr);
-    }
+    m.set_pointer(d);
+
+    // if (source_page->is_owned_by(this)) {
+    //   log_trace("Free handle %p locally (ptr = %p)", &m, ptr);
+    //   source_page->release_local(m, ptr);
+    // } else {
+    //   log_trace("Free handle %p remotely (ptr = %p)", &m, ptr);
+    //   source_page->release_remote(m, ptr);
+    // }
+    source_page->release_remote(m, ptr);
 
     return true;
   }

runtime/include/alaska/Heap.hpp

@@ -152,6 +152,8 @@ namespace alaska {
     // Dump the state of the global heap to some file stream.
     void dump(FILE *stream);
 
+    long jumble();
+
    private:
     template <typename T, typename Fn>
     T *find_or_alloc_page(
@@ -197,7 +199,6 @@ namespace alaska {
 
     // Allocate a new sized page
     void *memory = this->pm.alloc_page();
-    log_trace("Heap::get(%zu) :: allocating new SizedPage to manage %p", size, memory);
     T *p = new T(memory);
     // Map it in the page table for fast lookup
     pt.set(memory, p);

runtime/include/alaska/LocalityPage.hpp

@@ -28,7 +28,17 @@ namespace alaska {
   class LocalityPage final : public alaska::HeapPage {
    public:
     struct Metadata {
-      alaska::Mapping *mapping;
+      union {
+        alaska::Mapping *mapping;
+        void *data_raw;
+      };
+      bool allocated;
+      uint32_t size;
+
+      void *get_data(void) const {
+        if (not allocated) return data_raw;
+        return mapping->get_pointer();
+      }
     };
 
     LocalityPage(void *backing_memory)
@@ -43,9 +53,10 @@ namespace alaska {
     void *alloc(const alaska::Mapping &m, alaska::AlignedSize size) override;
     bool release_local(const alaska::Mapping &m, void *ptr) override;
     size_t size_of(void *) override;
-    inline size_t available() const { return get_free_space(); }
+    inline size_t available() const { return get_free_space() - sizeof(Metadata); }
 
     bool should_localize_from(uint64_t current_epoch) const override {
+      return false;
       return current_epoch - last_localization_epoch > localization_epoch_hysteresis;
     }
 
@@ -56,12 +67,10 @@ namespace alaska {
       return (Metadata *)((uintptr_t)data + page_size) - (offset + 1);
     }
 
-    inline void *get_ptr(uint32_t index) { return get_mapping(index)->get_pointer(); }
+    inline void *get_ptr(uint32_t index) { return get_md(index)->get_data(); }
 
     inline int num_allocated(void) { return get_md(0) - (md_bump_next); }
 
-    inline alaska::Mapping *get_mapping(uint32_t offset) { return get_md(offset)->mapping; }
-
     inline size_t get_free_space() const { return (off_t)md_bump_next - (off_t)data_bump_next; }
     inline size_t used_space() const { return (off_t)data_bump_next - (off_t)data; }
 
@@ -73,6 +82,6 @@ namespace alaska {
 
    public:
     uint64_t last_localization_epoch = 0;
-    uint64_t localization_epoch_hysteresis = 1;
+    uint64_t localization_epoch_hysteresis = 10;
   };
 };  // namespace alaska

runtime/include/alaska/Runtime.hpp

@@ -61,6 +61,8 @@ namespace alaska {
     // These are of an arbitrary unit.
     uint64_t localization_epoch = 0;
 
+    bool in_barrier = false;
+
 
     Runtime();
     ~Runtime();
@@ -74,12 +76,20 @@ namespace alaska {
     template <typename Fn>
     void with_barrier(Fn &&cb) {
       barrier_manager->begin();
+      in_barrier = true;
       barrier_manager->barrier_count++;
       cb();
+      in_barrier = false;
       barrier_manager->end();
     }
 
    private:
     int next_thread_cache_id = 0;
   };
+
+
+  // Spin until the runtime has been initialized somehow
+  void wait_for_initialization(void);
+  // Has the runtime been initialized?
+  bool is_initialized(void);
 }  // namespace alaska

runtime/include/alaska/ThreadCache.hpp

@@ -38,6 +38,7 @@ namespace alaska {
     size_t get_size(void *handle);
 
 
+    bool localize(alaska::Mapping &m, uint64_t epoch);
     bool localize(void *handle, uint64_t epoch);
 
    private:

runtime/include/alaska/sim/StatisticsManager.hpp

@@ -39,12 +39,12 @@ namespace alaska::sim {
   class StatisticsManager {
     std::array<uint64_t, statistic::COUNT> stats;
 
+   public:
     float l1_tlb_hr = 0;
     float l2_tlb_hr = 0;
     float l1_htlb_hr = 0;
     float l2_htlb_hr = 0;
 
-   public:
     StatisticsManager(void);
     ~StatisticsManager();
 

runtime/rt/halloc.cpp

@@ -19,7 +19,7 @@
 // TODO: don't have this be global!
 static __thread alaska::ThreadCache *g_tc = nullptr;
 
-static auto get_tc(void) {
+alaska::ThreadCache *get_tc(void) {
   if (unlikely(g_tc == nullptr)) {
     g_tc = alaska::Runtime::get().new_threadcache();
   }

runtime/rt/init.cpp

@@ -39,12 +39,18 @@ extern "C" void alaska_dump(void) { the_runtime->dump(stderr); }
 
 static pthread_t barrier_thread;
 static void *barrier_thread_func(void *) {
-  // while (1) {
-  //   usleep(250 * 1000);
-  //   alaska::barrier::begin();
-  //   printf("Barrier.\n");
-  //   alaska::barrier::end();
-  // }
+  return NULL;
+  while (1) {
+    usleep(50 * 1000);
+
+    alaska::Runtime::get().with_barrier([]() {
+      long swapped = alaska::Runtime::get().heap.jumble();
+      printf("Swapped %ld\n", swapped);
+    });
+    // alaska::barrier::begin();
+    // printf("Barrier.\n");
+    // alaska::barrier::end();
+  }
 
   return NULL;
 }
@@ -57,7 +63,7 @@ void __attribute__((constructor(102))) alaska_init(void) {
   // Attach the runtime's barrier manager
   the_runtime->barrier_manager = &the_barrier_manager;
 
-  pthread_create(&barrier_thread, NULL, barrier_thread_func, NULL);
+  // pthread_create(&barrier_thread, NULL, barrier_thread_func, NULL);
 }
 
 void __attribute__((destructor)) alaska_deinit(void) {

runtime/rt/sim.cpp

@@ -1,10 +1,14 @@
 #include <ck/lock.h>
+#include <pthread.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 
+#include <alaska/Runtime.hpp>
 #include <alaska/sim/HTLB.hpp>
+#include "alaska/config.h"
+#include <semaphore.h>
 
 
 #define L1_ENTS 96
@@ -15,44 +19,93 @@
 #define L2_SETS 32
 #define TOTAL_ENTRIES (L1_WAYS * L1_SETS + L2_WAYS * L2_SETS)
 
-
-#define RATE 100'000'000
+#define RATE 10'000
 
 static long access_count = 0;
-static alaska::sim::HTLB *htlb;
+static alaska::sim::HTLB *g_htlb = NULL;
 static ck::mutex htlb_lock;
+static thread_local volatile bool track_on_this_thread = true;
+
+
+static pthread_mutex_t dump_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t dump_cond = PTHREAD_COND_INITIALIZER;
+static uint64_t dump_buf[TOTAL_ENTRIES * 2];
 
-static alaska::sim::HTLB &get_htlb() {
-  if (unlikely(htlb == nullptr)) {
-    htlb = new alaska::sim::HTLB(L1_SETS, L1_WAYS, L2_SETS, L2_WAYS);
+extern alaska::ThreadCache *get_tc(void);
+
+static alaska::sim::HTLB &get_htlb(void) {
+  if (g_htlb == NULL) {
+    g_htlb = new alaska::sim::HTLB(L1_SETS, L1_WAYS, L2_SETS, L2_WAYS);
   }
 
-  return *htlb;
+  return *g_htlb;
 }
 
+static pthread_t sim_background_thread;
+static void *sim_background_thread_func(void *) {
+  track_on_this_thread = false;
+
+  alaska::wait_for_initialization();
+
+  while (true) {
+    pthread_mutex_lock(&dump_mutex);
+    pthread_cond_wait(&dump_cond, &dump_mutex);
+
+
+    // // Got a dump!
+    auto &rt = alaska::Runtime::get();
+
+    rt.with_barrier([&]() {
+      unsigned long moved_objects = 0;
+      for (int i = 0; i < TOTAL_ENTRIES; i++) {
+        if (dump_buf[i] == 0) continue;
+        uint64_t val = dump_buf[i] << ALASKA_SIZE_BITS;
+        if (get_tc()->localize((void *)val, rt.localization_epoch)) {
+          moved_objects++;
+        }
+      }
+      auto sm = get_htlb().get_stats();
+      sm.compute();
+      // sm.dump();
+      rt.localization_epoch++;
+      printf("Objects moved: %lu\n", moved_objects);
+      printf("TLB Hitrates: %f%% %f%%\n", sm.l1_tlb_hr, sm.l2_tlb_hr);
+    });
+    pthread_mutex_unlock(&dump_mutex);
+  }
+
+
+  return NULL;
+}
+
+static void __attribute__((constructor)) sim_init(void) {
+  pthread_create(&sim_background_thread, NULL, sim_background_thread_func, NULL);
+}
+
+
+
 void alaska_htlb_sim_track(uintptr_t maybe_handle) {
+  if (not alaska::is_initialized()) return;
   ck::scoped_lock l(htlb_lock);
   auto m = alaska::Mapping::from_handle_safe((void *)maybe_handle);
+  auto &htlb = get_htlb();
   if (m) {
-    auto &htlb = get_htlb();
     htlb.access(*m);
     access_count++;
 
     if (access_count > RATE) {
       access_count = 0;
 
-      // uint64_t *buf = (uint64_t *)calloc(TOTAL_ENTRIES, sizeof(uint64_t));
-      // htlb.dump_entries(buf);
-      // free(buf);
+      // dump, and notify the movement thread!
+      pthread_mutex_lock(&dump_mutex);
 
-      auto sm = htlb.get_stats();
-      sm.compute();
-      sm.dump();
-      // Reset the htlb for this run
-      htlb.reset();
+      htlb.dump_entries(dump_buf);
+      // htlb.reset();
+
+      pthread_cond_signal(&dump_cond);
+      pthread_mutex_unlock(&dump_mutex);
     }
   } else {
-    auto &htlb = get_htlb();
-    htlb.access_non_handle((void*)maybe_handle);
+    htlb.access_non_handle((void *)maybe_handle);
   }
 }

runtime/yukon/yukon.cpp

@@ -73,7 +73,7 @@ void segfault_handler(int sig) {
 
   for (size_t i = 0; i < size; i++) {
     print_hex("bt:", (uint64_t)array[i]);
-    print_words((unsigned*)array[i], 4);
+    print_words((unsigned *)array[i], 4);
   }
   exit(0);
 
@@ -83,7 +83,6 @@ void segfault_handler(int sig) {
   // for (int i = 0; i < size; i++) {
   //   write_int(
   // }
-
 }
 
 static void init(void) {
@@ -185,3 +184,6 @@ extern "C" void free(void *ptr) {
   // Simply ask the thread cache to free it!
   get_tc()->hfree(ptr);
 }
+
+
+extern "C" size_t malloc_usable_size(void *ptr) { return get_tc()->get_size(ptr); }