runtime: fix warnings in GCC

Author: nickwanninger

runtime/CMakeLists.txt

@@ -1,6 +1,6 @@
 # add_link_options("-fuse-ld=lld")
 
-set(WARNINGS "-Wall -Wextra -Wno-cast-qual -Wno-format -Wno-unused-function -Wno-ignored-attributes -Wno-unused-parameter -Wno-unused-variable -fno-omit-frame-pointer -Wno-sign-compare -Wno-implicit-fallthrough -Wno-unused-private-field -Wno-covered-switch-default -Wno-attributes -Wno-cast-function-type ")
+set(WARNINGS "-Wall -Werror -Wno-multichar -Wno-unused-function -Wno-attributes ")
 
 # Compile the runtime with some special flags
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -gdwarf-4 ${WARNINGS} ")
@@ -63,8 +63,10 @@ set(CORE_SOURCES
 find_library(LIBUNWIND_LIBRARIES NAMES unwind )
 message(STATUS "UNWIND: ${LIBUNWIND_LIBRARIES}")
 
-add_library(alaska_core SHARED ${CORE_SOURCES})
-target_compile_options(alaska_core PRIVATE -nostdlib++ -nostdinc++)
+add_library(alaska_core STATIC ${CORE_SOURCES})
+
+target_compile_options(alaska_core PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-nostdlib++ -nostdinc++>)
+
 set_target_properties(alaska_core PROPERTIES LINKER_LANGUAGE C)
 set_target_properties(alaska_core PROPERTIES SOVERSION ${ALASKA_VERSION})
 target_link_libraries(alaska_core ${LIBUNWIND_LIBRARIES})
@@ -104,7 +106,7 @@ if(NOT ALASKA_CORE_ONLY) # -----------------------------------------------------
   set_target_properties(alaska PROPERTIES SOVERSION ${ALASKA_VERSION})
   target_link_libraries(alaska alaska_core dl pthread ${LIBUNWIND_LIBRARIES})
 
-  target_compile_options(alaska PUBLIC -nostdlib++ -nostdinc++)
+  target_compile_options(alaska PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-nostdlib++ -nostdinc++>)
 
   install(
     TARGETS alaska

runtime/core/HandleTable.cpp

@@ -125,7 +125,7 @@ namespace alaska {
     ck::scoped_lock lk(this->lock);
 
     log_trace("Getting slab %d", idx);
-    if (idx >= m_slabs.size()) {
+    if (idx >= (slabidx_t)m_slabs.size()) {
       log_trace("Invalid slab requeset!");
       return nullptr;
     }
@@ -154,8 +154,8 @@ namespace alaska {
   void HandleTable::put(Mapping *m, alaska::ThreadCache *owner) {
     log_trace("Putting handle %p", m);
     // Validate that the handle is in this table
-    ALASKA_ASSERT(
-        mapping_slab_idx(m) < m_slabs.size(), "attempted to put a handle into the wrong table")
+    ALASKA_ASSERT(mapping_slab_idx(m) < (slabidx_t)m_slabs.size(),
+        "attempted to put a handle into the wrong table")
 
     // Get the slab that the handle is in
     auto *slab = m_slabs[mapping_slab_idx(m)];
@@ -256,12 +256,12 @@ namespace alaska {
 
 
   void HandleSlab::dump(FILE *stream) {
-    fprintf(stream, "Slab %4d | ", idx);
+    fprintf(stream, "Slab %4zu | ", idx);
     fprintf(stream, "st %d | ", state);
 
     auto owner = this->get_owner();
     fprintf(stream, "owner: %4d | ", owner ? owner->get_id() : -1);
-    fprintf(stream, "free %4d | ", allocator.num_free());
+    fprintf(stream, "free %4zu | ", allocator.num_free());
 
     fprintf(stream, "\n");
   }

runtime/core/Heap.cpp

@@ -216,15 +216,15 @@ namespace alaska {
       out("sc %d: %zu heaps\n", cls, mag.size());
 
 
-      int page_ind = 0;
+      unsigned long page_ind = 0;
       mag.foreach ([&](HeapPage *hp) {
         SizedPage *sp = static_cast<SizedPage *>(hp);
         int id = -1;
         auto owner = sp->get_owner();
         if (owner != NULL) {
           id = owner->get_id();
         }
-        out("SizedPage %016p-%016p owner:%3d avail:%7zu\n", sp->start(), sp->end(), id, sp->available());
+        out("SizedPage %016zx-%016zx owner:%3d avail:%7zu\n", (uintptr_t)sp->start(), (uintptr_t)sp->end(), id, sp->available());
         page_ind++;
         if (page_ind > mag.size()) return false;
         return true;

runtime/core/LocalityPage.cpp

@@ -61,7 +61,6 @@ namespace alaska {
 
     // Grab the guess metadata
     auto guess_ptr = get_ptr(guess_off);
-    auto original_guess_off = guess_off;
 
     // Go left or right to find the right one.
     if (ptr > guess_ptr) {

runtime/core/barrier.cpp

@@ -241,7 +241,7 @@ static bool in_might_block_function(uintptr_t start_addr) {
       msg = "\e[32m(managed)\e[0m";
     }
 
-    printf("%016lx %s\n", buffer[i], msg);
+    printf("%016lx %s\n", (uintptr_t)buffer[i], msg);
   }
   printf("\n");
 
@@ -566,7 +566,7 @@ void alaska::barrier::remove_self_thread(void) {
   }
 
   if (!found) {
-    fprintf(stderr, "Failed to remove non-added thread, %p\n", self);
+    fprintf(stderr, "Failed to remove non-added thread\n");
     abort();
   }
 
@@ -673,8 +673,6 @@ void alaska_blob_init(struct alaska_blob_config* cfg) {
   size_t size = round_up(cfg->code_end - cfg->code_start, 4096);
   mprotect(patch_page, size + 4096, PROT_EXEC | PROT_READ | PROT_WRITE);
 
-  printf("%p %p\n", cfg->code_start, cfg->code_end);
-
   if (cfg->stackmap) parse_stack_map((uint8_t*)cfg->stackmap);
 }
 

runtime/core/glue.cpp

@@ -1,17 +1,6 @@
 #include <stdlib.h>
 
-
-#define ALASKA_PRIVATE __attribute__((visibility("hidden")))
-
-ALASKA_PRIVATE
 extern "C" void __cxa_pure_virtual() {
   while (1)
     ;
 }
-
-// void *operator new(size_t size) { return malloc(size); }
-// void *operator new[](size_t size) { return malloc(size); }
-// void operator delete(void *ptr) noexcept { free(ptr); }
-// void operator delete[](void *ptr) noexcept { free(ptr); }
-// void operator delete(void *ptr, size_t s) noexcept { free(ptr); }
-// void operator delete[](void *ptr, size_t s) noexcept { free(ptr); }

runtime/core/translate.cpp

@@ -66,7 +66,7 @@ void *alaska_translate_escape(void *ptr) {
 }
 
 
-static __attribute_noinline__ void track(uintptr_t handle) { fprintf(stderr, "tr %p\n", handle); }
+static __attribute_noinline__ void track(uintptr_t handle) { fprintf(stderr, "tr %016zx\n", handle); }
 
 void *alaska_translate(void *ptr) {
   int64_t bits = (int64_t)ptr;

runtime/extra/lifetime.c

@@ -122,7 +122,7 @@ void free(void *p) {
     md_t *m = (md_t *)p - 1;
     if (m->magic != MAGIC) return;
     ssize_t dur = timestamp() - m->time_allocated_ns;
-    fprintf(lifetime_output, "%zu,%zd\n", m->size, dur);
+    fprintf(lifetime_output, "%d,%zd\n", m->size, dur);
   }
 
   // real_free(m);

runtime/include/alaska/HandleTable.hpp

@@ -22,7 +22,7 @@
 
 namespace alaska {
 
-  using slabidx_t = uint64_t;
+  using slabidx_t = size_t;
 
   class HandleTable;
   class HandleSlabQueue;

runtime/include/alaska/LocalityPage.hpp

@@ -49,8 +49,8 @@ namespace alaska {
 
     inline alaska::Mapping *get_mapping(uint32_t offset) { return get_md(offset)->mapping; }
 
-    inline int64_t get_free_space() const { return (off_t)md_bump_next - (off_t)data_bump_next; }
-    inline int64_t used_space() const { return (off_t)data_bump_next - (off_t)data; }
+    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; }
 
     void *data = nullptr;
     void *data_bump_next = nullptr;

runtime/include/ck/utility.h

@@ -857,13 +857,13 @@ namespace ck {
         "template argument must be a complete class or an unbounded array");
   };
 
-  /// is_trivially_destructible
-  template <typename _Tp>
-  struct is_trivially_destructible
-      : public __and_<__is_destructible_safe<_Tp>, __bool_constant<__is_trivially_destructible(_Tp)>> {
-    static_assert(ck::__is_complete_or_unbounded(__type_identity<_Tp>{}),
-        "template argument must be a complete class or an unbounded array");
-  };
+  // /// is_trivially_destructible
+  // template <typename _Tp>
+  // struct is_trivially_destructible
+  //     : public __and_<__is_destructible_safe<_Tp>, __bool_constant<__is_trivially_destructible(_Tp)>> {
+  //   static_assert(ck::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+  //       "template argument must be a complete class or an unbounded array");
+  // };
 
 
   /// has_virtual_destructor

runtime/test/runtime_test.cpp

@@ -100,7 +100,7 @@ TEST_F(RuntimeTest, UniqueSlabAllocations) {
 
 TEST_F(RuntimeTest, CapacityGrowth) {
   // Allocate a large number of slabs
-  for (int i = 0; i < alaska::HandleTable::initial_capacity * 2; i++) {
+  for (size_t i = 0; i < alaska::HandleTable::initial_capacity * 2; i++) {
     auto* slab = runtime.handle_table.fresh_slab(DUMMY_THREADCACHE);
     ASSERT_NE(slab, nullptr);
   }
@@ -149,7 +149,7 @@ TEST_F(RuntimeTest, SlabNFreeOnInitialAllocation) {
 // Make sure that for many slabs, get_slab returns the right one
 TEST_F(RuntimeTest, SlabGetSlab) {
   // Allocate a large number of slabs
-  for (int i = 0; i < alaska::HandleTable::initial_capacity * 2; i++) {
+  for (size_t i = 0; i < alaska::HandleTable::initial_capacity * 2; i++) {
     auto* slab = runtime.handle_table.fresh_slab(DUMMY_THREADCACHE);
     ASSERT_NE(slab, nullptr);
     // Check that get_slab returns the right slab
@@ -162,7 +162,7 @@ TEST_F(RuntimeTest, SlabGetReturnsNullWhenOutOfCapacity) {
   // Allocate a fresh slab from the handle table
   auto* slab = runtime.handle_table.fresh_slab(DUMMY_THREADCACHE);
   // Fill up the slab with handles
-  for (int i = 0; i < alaska::HandleTable::slab_capacity; i++) {
+  for (size_t i = 0; i < alaska::HandleTable::slab_capacity; i++) {
     auto handle = slab->alloc();
     ASSERT_NE(handle, nullptr);
   }
@@ -180,7 +180,7 @@ TEST_F(RuntimeTest, SlabUniqueHandles) {
   // Create a set to store the handles
   std::set<alaska::Mapping*> handles;
   // Fill up the slab with handles
-  for (int i = 0; i < alaska::HandleTable::slab_capacity; i++) {
+  for (size_t i = 0; i < alaska::HandleTable::slab_capacity; i++) {
     auto handle = slab->alloc();
     ASSERT_NE(handle, nullptr);
     // Check that the handle is unique
@@ -215,7 +215,7 @@ TEST_F(RuntimeTest, SlabMappingIndex) {
     // Allocate a fresh slab from the handle table
     auto* slab = runtime.handle_table.fresh_slab(DUMMY_THREADCACHE);
     // Fill up the slab with handles
-    for (int i = 0; i < alaska::HandleTable::slab_capacity; i++) {
+    for (size_t i = 0; i < alaska::HandleTable::slab_capacity; i++) {
       auto handle = slab->alloc();
       ASSERT_NE(handle, nullptr);
       // Check that the handle is in the right index
@@ -238,7 +238,7 @@ TEST_F(RuntimeTest, HandleSlabQueuePop) {
   // Create a vector to store the slabs
   std::vector<alaska::HandleSlab*> slabs;
   // For a few iterations...
-  for (int i = 0; i < 10; i++) {
+  for (size_t i = 0; i < 10; i++) {
     // Allocate a fresh slab from the handle table
     auto* slab = runtime.handle_table.fresh_slab(DUMMY_THREADCACHE);
     // Push the slab to the queue
@@ -248,7 +248,7 @@ TEST_F(RuntimeTest, HandleSlabQueuePop) {
   }
 
   // Pop all the slabs from the queue
-  for (int i = 0; i < 10; i++) {
+  for (size_t i = 0; i < 10; i++) {
     auto* slab = queue.pop();
     // Check that the slab is the same as the one that was pushed
     ASSERT_EQ(slab, slabs[i]);