iodine 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1727f338fb31c8ab46956d8e3b45af0d374ce100771305ba73f5b690467cff54
-  data.tar.gz: ef706da6cd642d2de4a464e3a5b6b90c8afd5cec294456dde2fa841b625a222a
+  metadata.gz: d9304bf27335fe19b9c7d7ca9442fe994772c5489a70aa598cc045bda313c755
+  data.tar.gz: 8acee18f9da3f77a763fb7c93ac2c4328788c79298c5b792597e6b40ee1b14c5
 SHA512:
-  metadata.gz: 3d114bf645e22f6bef700c782dcfa3daa263d94bcadac5ecb543a67abe593884c86ea6eb6b9c99fb8480385f8e8f9c211ce27901645bf776b84a2d75b7ba1c61
-  data.tar.gz: f5029fd64683ffd485c8091686f5fc2e905abee7776d94c15c5d9b80cff3093a5147cffa502a45f1fe0d0d9de884909edc5ceac0c1a0cb565cb72d40dd5b994f
+  metadata.gz: aef5181c233342793d2c74a8d4ca6c398a357c36bc399dd133f796aa0c2e67ed881d99514b45c2e85da880e0a2b49844fa869afc28be696dc63675558b7dba2c
+  data.tar.gz: 6e6f11fd287cafbcc9eae4ef3df92fe4b4c543e9d930344745725c59cc4be587d24e8c226416ae65208516bd995afa90c210847f0e8faf9873dfe3913c4ef7dc

data/.travis.yml

@@ -24,8 +24,8 @@ addons:
 script:
   - gem uninstall -x iodine
   - rake build
-  - find pkg/iodine-*.gem -exec gem install {} +
+  - find pkg/iodine-*.gem -exec gem install -V {} +
   - gem uninstall -x iodine
-  - CC=gcc find pkg/iodine-*.gem -exec gem install {} +
+  - CC=gcc find pkg/iodine-*.gem -exec gem install -V {} +
   - gem uninstall -x iodine
-  - CC=gcc-5 find pkg/iodine-*.gem -exec gem install {} +
+  - CC=gcc-5 find pkg/iodine-*.gem -exec gem install -V {} +

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.2
+
+**Updated**: updated the logging for HTTP services startup, to minimize log clutter.
+
+**Feature**: (mustache) added features to `Iodine::Mustache`, to expose more of the functionality offered by facil.io.
+
+**Fix**: (facil.io) updated from the facil.io edge (master) branch. This should fix some exposed symbols (that should have been private), minimize name-collision risks, and fix an unknown issue with the mime-type registry cleanup and other possible issues.
+
 #### Change log v.0.7.1
 
 **Fix**: Fixed compilation issues with older `gcc` compilers.

data/bin/mustache.rb

@@ -25,6 +25,7 @@ def benchmark_mustache
   """
 
   IO.write "test_template.mustache", template
+  filename = "test_template.mustache"
 
   data_1 = {
     products: [ {
@@ -33,31 +34,6 @@ def benchmark_mustache
       :image=>"products/product.jpg"
     } ]
   }
-
-  data_10 = {
-    products: []
-  }
-
-  10.times do
-    data_10[:products] << {
-      :external_index=>"product",
-      :url=>"/products/7",
-      :image=>"products/product.jpg"
-    }
-  end
-
-  data_100 = {
-    products: []
-  }
-
-  100.times do
-    data_100[:products] << {
-      :external_index=>"product",
-      :url=>"/products/7",
-      :image=>"products/product.jpg"
-    }
-  end
-
   data_1000 = {
     products: []
   }
@@ -85,7 +61,7 @@ def benchmark_mustache
   view = Mustache.new
   view.template = template
   view.render # Call render once so the template will be compiled
-  iodine_view = Iodine::Mustache.new("test_template")
+  iodine_view = Iodine::Mustache.new(filename)
 
   puts "Ruby Mustache rendering (and HTML escaping) results in:",
        view.render(data_1), "",
@@ -95,20 +71,6 @@ def benchmark_mustache
   # return;
 
   Benchmark.ips do |x|
-    x.report("Ruby Mustache render list of 10") do |times|
-      view.render(data_10)
-    end
-    x.report("Iodine::Mustache render list of 10") do |times|
-      iodine_view.render(data_10)
-    end
-
-    x.report("Ruby Mustache render list of 100") do |times|
-      view.render(data_100)
-    end
-    x.report("Iodine::Mustache render list of 100") do |times|
-      iodine_view.render(data_100)
-    end
-
     x.report("Ruby Mustache render list of 1000") do |times|
       view.render(data_1000)
     end
@@ -122,6 +84,16 @@ def benchmark_mustache
     x.report("Iodine::Mustache render list of 1000 with escaped data") do |times|
       iodine_view.render(data_1000_escaped)
     end
+
+    x.report("Ruby Mustache - no chaching - render list of 1000") do |times|
+      tmp = Mustache.new
+      tmp.template = template
+      tmp.render(data_1000)
+    end
+    x.report("Iodine::Mustache - no chaching - render list of 1000") do |times|
+      Iodine::Mustache.render(nil, data_1000, template)
+    end
+
   end
 end
 

data/ext/iodine/fio.c

@@ -69,6 +69,10 @@ Feel free to copy, use and enjoy according to the license provided.
 #define DEBUG_SPINLOCK 0
 #endif
 
+#if !defined(__clang__) && !defined(__GNUC__)
+#define __thread _Thread_value
+#endif
+
 /* *****************************************************************************
 Patch for OSX version < 10.12 from https://stackoverflow.com/a/9781275/4025095
 ***************************************************************************** */
@@ -218,7 +222,13 @@ typedef struct {
   fio_fd_data_s info[];
 } fio_data_s;
 
-fio_data_s *fio_data = NULL;
+/** The logging level */
+#if DEBUG
+size_t FIO_LOG_LEVEL = FIO_LOG_LEVEL_DEBUG;
+#else
+size_t FIO_LOG_LEVEL = FIO_LOG_LEVEL_INFO;
+#endif
+static fio_data_s *fio_data = NULL;
 
 /* used for protocol locking by task type. */
 typedef struct {
@@ -294,11 +304,15 @@ static void fio_max_fd_shrink(void) {
 static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
   fio_packet_s *packet;
   fio_protocol_s *protocol;
+  fio_rw_hook_s *rw_hooks;
+  void *rw_udata;
   fio_uuid_links_s links;
   fio_lock(&(fd_data(fd).sock_lock));
   links = fd_data(fd).links;
   packet = fd_data(fd).packet;
   protocol = fd_data(fd).protocol;
+  rw_hooks = fd_data(fd).rw_hooks;
+  rw_udata = fd_data(fd).rw_udata;
   fd_data(fd) = (fio_fd_data_s){
       .open = is_open,
       .sock_lock = fd_data(fd).sock_lock,
@@ -308,6 +322,8 @@ static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
       .packet_last = &fd_data(fd).packet,
   };
   fio_unlock(&(fd_data(fd).sock_lock));
+  if (rw_hooks && rw_hooks->cleanup)
+    rw_hooks->cleanup(rw_udata);
   while (packet) {
     fio_packet_s *tmp = packet;
     packet = packet->next;
@@ -319,6 +335,7 @@ static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
         pos->obj((void *)pos->hash);
     }
   }
+  fio_uuid_links_free(&links);
   if (protocol && protocol->on_close) {
     fio_defer(deferred_on_close, (void *)fd2uuid(fd), protocol);
   }
@@ -365,12 +382,10 @@ inline static void protocol_unlock(fio_protocol_s *pr,
 }
 
 /** returns 1 if the UUID is valid and 0 if it isn't. */
-inline static size_t uuid_is_valid(uintptr_t uuid) {
-  if (uuid == (uintptr_t)-1 || (uintptr_t)fio_uuid2fd(uuid) >= fio_data->capa ||
-      (uuid & 0xFF) != uuid_data(uuid).counter)
-    return 0;
-  return 1;
-}
+#define uuid_is_valid(uuid)                                                    \
+  ((intptr_t)(uuid) != -1 &&                                                   \
+   ((uint32_t)fio_uuid2fd((uuid))) < fio_data->capa &&                         \
+   ((uintptr_t)(uuid)&0xFF) == uuid_data((uuid)).counter)
 
 /* public API. */
 fio_protocol_s *fio_protocol_try_lock(intptr_t uuid,
@@ -516,7 +531,7 @@ typedef struct {
   void (*on_finish)(void *);
 } fio_timer_s;
 
-fio_ls_embd_s fio_timers = FIO_LS_INIT(fio_timers);
+static fio_ls_embd_s fio_timers = FIO_LS_INIT(fio_timers);
 
 static fio_lock_i fio_timer_lock = FIO_LOCK_INIT;
 
@@ -961,8 +976,7 @@ static fio_defer_thread_pool_s *fio_defer_thread_pool_new(size_t count) {
   }
   return pool;
 error:
-  fprintf(stderr, "CRITICAL ERROR: couldn't spawn threads for thread pool, "
-                  "attempting shutdown.\n");
+  FIO_LOG_FATAL("couldn't spawn threads for thread pool, attempting shutdown.");
   fio_stop();
   fio_defer_thread_pool_join(pool);
   return NULL;
@@ -1209,11 +1223,11 @@ static inline size_t fio_detect_cpu_cores(void) {
 #ifdef _SC_NPROCESSORS_ONLN
   cpu_count = sysconf(_SC_NPROCESSORS_ONLN);
   if (cpu_count < 0) {
-    FIO_LOG_STATE("WARNING: CPU core count auto-detection failed.\n");
+    FIO_LOG_WARNING("CPU core count auto-detection failed.");
     return 0;
   }
 #else
-  FIO_LOG_STATE("WARNING: CPU core count auto-detection failed.\n");
+  FIO_LOG_WARNING("CPU core count auto-detection failed.");
 #endif
   return cpu_count;
 }
@@ -1236,13 +1250,11 @@ void fio_expected_concurrency(int16_t *threads, int16_t *processes) {
     if (cpu_count > FIO_CPU_CORES_LIMIT) {
       static int print_cores_warning = 1;
       if (print_cores_warning) {
-        fprintf(
-            stderr,
-            "INFO: Detected %zu cores. Capping auto-detection of cores "
-            "to %zu.\n"
+        FIO_LOG_WARNING(
+            "Detected %zu cores. Capping auto-detection of cores to %zu.\n"
             "      Avoid this message by setting threads / workers manually.\n"
             "      To increase auto-detection limit, recompile with:\n"
-            "             -DFIO_CPU_CORES_LIMIT=%zu \n",
+            "             -DFIO_CPU_CORES_LIMIT=%zu",
             (size_t)cpu_count, (size_t)FIO_CPU_CORES_LIMIT, (size_t)cpu_count);
         print_cores_warning = 0;
       }
@@ -1500,7 +1512,7 @@ static void fio_poll_init(void) {
   fio_poll_close();
   evio_fd = kqueue();
   if (evio_fd == -1) {
-    fprintf(stderr, "FATAL ERROR: couldn't open kqueue.\n");
+    FIO_LOG_FATAL("couldn't open kqueue.\n");
     exit(errno);
   }
 }
@@ -1580,6 +1592,7 @@ static size_t fio_poll(void) {
         //         (events[i].flags & EV_EOF)
         //             ? "EV_EOF"
         //             : (events[i].flags & EV_ERROR) ? "EV_ERROR" : "WTF?");
+        // uuid_data(events[i].udata).open = 0;
         fio_force_close(fd2uuid(events[i].udata));
       } else if (events[i].filter == EVFILT_WRITE) {
         // we can only write if there's no error in the socket
@@ -1715,22 +1728,22 @@ static size_t fio_poll(void) {
       touchfd(i);
       ++count;
       if (list[i].revents & FIO_POLL_READ_EVENTS) {
-        // fprintf(stderr, "Poll Read %zu => %p\n", i, (void *)fd2uuid(i));
+        // FIO_LOG_DEBUG("Poll Read %zu => %p", i, (void *)fd2uuid(i));
         fio_poll_remove_read(i);
         fio_defer(deferred_on_data, (void *)fd2uuid(i), NULL);
       }
       if (list[i].revents & FIO_POLL_WRITE_EVENTS) {
-        // fprintf(stderr, "Poll Write %zu => %p\n", i, (void *)fd2uuid(i));
+        // FIO_LOG_DEBUG("Poll Write %zu => %p", i, (void *)fd2uuid(i));
         fio_poll_remove_write(i);
         fio_defer(deferred_on_ready, (void *)fd2uuid(i), NULL);
       }
       if (list[i].revents & (POLLHUP | POLLERR)) {
-        // fprintf(stderr, "Poll Hangup %zu => %p\n", i, (void *)fd2uuid(i));
+        // FIO_LOG_DEBUG("Poll Hangup %zu => %p", i, (void *)fd2uuid(i));
         fio_poll_remove_fd(i);
         fio_force_close(fd2uuid(i));
       }
       if (list[i].revents & POLLNVAL) {
-        // fprintf(stderr, "Poll Invalid %zu => %p\n", i, (void *)fd2uuid(i));
+        // FIO_LOG_DEBUG("Poll Invalid %zu => %p", i, (void *)fd2uuid(i));
         fio_poll_remove_fd(i);
         fio_lock(&fd_data(i).protocol_lock);
         fio_clear_fd(i, 0);
@@ -2104,15 +2117,15 @@ static intptr_t fio_unix_socket(const char *address, uint8_t server) {
   /* Unix socket */
   if (!address) {
     errno = EINVAL;
-    fprintf(stderr,
-            "ERROR: (fio) a Unix socket requires a valid address."
-            "             Specify port for TCP/IP socket or change address.\n");
+    FIO_LOG_ERROR(
+        "(fio) a Unix socket requires a valid address.\n"
+        "             Specify port for TCP/IP socket or change address.");
     return -1;
   }
   struct sockaddr_un addr = {0};
   size_t addr_len = strlen(address);
   if (addr_len >= sizeof(addr.sun_path)) {
-    fprintf(stderr, "ERROR: (fio) a Unix socket address too long.\n");
+    FIO_LOG_ERROR("(fio) a Unix socket address too long.");
     errno = ENAMETOOLONG;
     return -1;
   }
@@ -2563,7 +2576,7 @@ void fio_force_close(intptr_t uuid) {
     errno = EBADF;
     return;
   }
-  /* clear away any packets in case we want to cut the connection short */
+  /* clear away any packets in case we want to cut the connection short. */
   fio_packet_s *packet;
   fio_lock(&uuid_data(uuid).sock_lock);
   packet = uuid_data(uuid).packet;
@@ -2702,12 +2715,16 @@ static ssize_t fio_hooks_default_flush(intptr_t uuid, void *udata) {
   (void)(udata);
 }
 
+static void fio_hooks_default_cleanup(void *udata) { (void)(udata); }
+
 const fio_rw_hook_s FIO_DEFAULT_RW_HOOKS = {
     .read = fio_hooks_default_read,
     .write = fio_hooks_default_write,
     .flush = fio_hooks_default_flush,
     .close = fio_hooks_default_close,
+    .cleanup = fio_hooks_default_cleanup,
 };
+
 /** Sets a socket hook state (a pointer to the struct). */
 int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata) {
   if (fio_is_closed(uuid))
@@ -2720,11 +2737,19 @@ int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata) {
     rw_hooks->flush = fio_hooks_default_flush;
   if (!rw_hooks->close)
     rw_hooks->close = fio_hooks_default_close;
+  if (!rw_hooks->cleanup)
+    rw_hooks->cleanup = fio_hooks_default_cleanup;
   uuid = fio_uuid2fd(uuid);
+  fio_rw_hook_s *old_rw_hooks;
+  void *old_udata;
   fio_lock(&fd_data(uuid).sock_lock);
+  old_rw_hooks = fd_data(uuid).rw_hooks;
+  old_udata = fd_data(uuid).rw_udata;
   fd_data(uuid).rw_hooks = rw_hooks;
   fd_data(uuid).rw_udata = udata;
   fio_unlock(&fd_data(uuid).sock_lock);
+  if (old_rw_hooks && old_rw_hooks->cleanup)
+    old_rw_hooks->cleanup(old_udata);
   return 0;
 }
 
@@ -2852,6 +2877,10 @@ typedef struct {
 
 static callback_collection_s callback_collection[FIO_CALL_NEVER + 1];
 
+static void fio_state_on_idle_perform(void *task, void *arg) {
+  ((void (*)(void *))(uintptr_t)task)(arg);
+}
+
 static inline void fio_state_callback_ensure(callback_collection_s *c) {
   if (c->callbacks.next)
     return;
@@ -2905,12 +2934,46 @@ void fio_state_callback_force(callback_type_e c_type) {
   fio_ls_embd_s copy = FIO_LS_INIT(copy);
   fio_lock(&callback_collection[c_type].lock);
   fio_state_callback_ensure(&callback_collection[c_type]);
-  FIO_LS_EMBD_FOR(&callback_collection[c_type].callbacks, pos) {
-    callback_data_s *tmp = fio_malloc(sizeof(*tmp));
-    FIO_ASSERT_ALLOC(tmp);
-    *tmp = *(FIO_LS_EMBD_OBJ(callback_data_s, node, pos));
-    fio_ls_embd_push(&copy, &tmp->node);
+  switch (c_type) {            /* the difference between `unshift` and `push` */
+  case FIO_CALL_ON_INITIALIZE: /* overflow */
+  case FIO_CALL_PRE_START:     /* overflow */
+  case FIO_CALL_BEFORE_FORK:   /* overflow */
+  case FIO_CALL_AFTER_FORK:    /* overflow */
+  case FIO_CALL_IN_CHILD:      /* overflow */
+  case FIO_CALL_IN_MASTER:     /* overflow */
+  case FIO_CALL_ON_START:      /* overflow */
+    FIO_LS_EMBD_FOR(&callback_collection[c_type].callbacks, pos) {
+      callback_data_s *tmp = fio_malloc(sizeof(*tmp));
+      FIO_ASSERT_ALLOC(tmp);
+      *tmp = *(FIO_LS_EMBD_OBJ(callback_data_s, node, pos));
+      fio_ls_embd_unshift(&copy, &tmp->node);
+    }
+    break;
+
+  case FIO_CALL_ON_IDLE: /* idle callbacks are orderless and evented */
+    FIO_LS_EMBD_FOR(&callback_collection[c_type].callbacks, pos) {
+      callback_data_s *tmp = FIO_LS_EMBD_OBJ(callback_data_s, node, pos);
+      fio_defer(fio_state_on_idle_perform, (void *)(uintptr_t)tmp->func,
+                tmp->arg);
+    }
+    break;
+
+  case FIO_CALL_ON_SHUTDOWN:     /* overflow */
+  case FIO_CALL_ON_FINISH:       /* overflow */
+  case FIO_CALL_ON_PARENT_CRUSH: /* overflow */
+  case FIO_CALL_ON_CHILD_CRUSH:  /* overflow */
+  case FIO_CALL_AT_EXIT:         /* overflow */
+  case FIO_CALL_NEVER:           /* overflow */
+  default:
+    FIO_LS_EMBD_FOR(&callback_collection[c_type].callbacks, pos) {
+      callback_data_s *tmp = fio_malloc(sizeof(*tmp));
+      FIO_ASSERT_ALLOC(tmp);
+      *tmp = *(FIO_LS_EMBD_OBJ(callback_data_s, node, pos));
+      fio_ls_embd_push(&copy, &tmp->node);
+    }
+    break;
   }
+
   fio_unlock(&callback_collection[c_type].lock);
   /* run callbacks + free data */
   while (fio_ls_embd_any(&copy)) {
@@ -3004,7 +3067,6 @@ void fio_defer_io_task FIO_IGNORE_MACRO(intptr_t uuid,
 Initialize the library
 ***************************************************************************** */
 
-static void fio_malloc_after_fork(void);
 static void fio_pubsub_on_fork(void);
 
 static void fio_mem_destroy(void);
@@ -3018,10 +3080,8 @@ static void __attribute__((destructor)) fio_lib_destroy(void) {
   fio_free(fio_data);
   /* memory library destruction must be last */
   fio_mem_destroy();
-#if DEBUG
-  FIO_LOG_STATE("* (%d) facil.io resources released, exit complete.\n",
-                getpid());
-#endif
+  FIO_LOG_DEBUG("(%d) facil.io resources released, exit complete.", getpid());
+  fprintf(stderr, "\n"); /* add EOL to logs (logging adds EOL before text */
 }
 
 /* Called within a child process after it starts. */
@@ -3071,7 +3131,7 @@ static void __attribute__((constructor)) fio_lib_init(void) {
     // try to maximize limits - collect max and set to max
     struct rlimit rlim = {.rlim_max = 0};
     if (getrlimit(RLIMIT_NOFILE, &rlim) == -1) {
-      fprintf(stderr, "WARNING: `getrlimit` failed in `sock_max_capacity`.\n");
+      FIO_LOG_WARNING("`getrlimit` failed in `sock_max_capacity`.");
     } else {
       // #if defined(__APPLE__) /* Apple's getrlimit is broken. */
       //     rlim.rlim_cur = rlim.rlim_max >= FOPEN_MAX ? FOPEN_MAX :
@@ -3092,7 +3152,7 @@ static void __attribute__((constructor)) fio_lib_init(void) {
     FIO_LOG_STATE("facil.io " FIO_VERSION_STRING " capacity initialization:\n"
                   "*    Meximum open files %zu out of %zu\n"
                   "*    Allocating %zu bytes for state handling.\n"
-                  "*    %zu bytes per connection + %zu for state handling.\n",
+                  "*    %zu bytes per connection + %zu for state handling.",
                   capa, (size_t)rlim.rlim_max,
                   (sizeof(*fio_data) + (capa * (sizeof(*fio_data->poll))) +
                    (capa * (sizeof(*fio_data->info)))),
@@ -3102,7 +3162,7 @@ static void __attribute__((constructor)) fio_lib_init(void) {
     FIO_LOG_STATE("facil.io " FIO_VERSION_STRING " capacity initialization:\n"
                   "*    Meximum open files %zu out of %zu\n"
                   "*    Allocating %zu bytes for state handling.\n"
-                  "*    %zu bytes per connection + %zu for state handling.\n",
+                  "*    %zu bytes per connection + %zu for state handling.",
                   capa, (size_t)rlim.rlim_max,
                   (sizeof(*fio_data) + (capa * (sizeof(*fio_data->info)))),
                   (sizeof(*fio_data->info)), sizeof(*fio_data));
@@ -3277,7 +3337,7 @@ static void fio_worker_startup(void) {
     fio_data->is_worker = 1;
   } else if (fio_data->is_worker) {
     /* Worker Process */
-    FIO_LOG_STATE("* %d is running.\n", getpid());
+    FIO_LOG_INFO("%d is running.", getpid());
   } else {
     /* Root Process should run in single thread mode */
     fio_data->threads = 1;
@@ -3298,9 +3358,9 @@ static void fio_worker_startup(void) {
 static void fio_worker_cleanup(void) {
   /* switch to winding down */
   if (fio_data->is_worker)
-    FIO_LOG_STATE("* (%d) detected exit signal.\n", getpid());
+    FIO_LOG_INFO("(%d) detected exit signal.", getpid());
   else
-    FIO_LOG_STATE("* Server Detected exit signal.\n");
+    FIO_LOG_INFO("Server Detected exit signal.");
   fio_state_callback_force(FIO_CALL_ON_SHUTDOWN);
   for (size_t i = 0; i <= fio_data->max_protocol_fd; ++i) {
     if (fd_data(i).protocol) {
@@ -3325,9 +3385,9 @@ static void fio_worker_cleanup(void) {
   fio_defer_perform();
   fio_signal_handler_reset();
   if (fio_data->parent == getpid()) {
-    FIO_LOG_STATE("\n   ---  Shutdown Complete  ---\n");
+    FIO_LOG_INFO("   ---  Shutdown Complete  ---\n");
   } else {
-    FIO_LOG_STATE("* (%d) cleanup complete.\n", getpid());
+    FIO_LOG_INFO("(%d) cleanup complete.", getpid());
   }
 }
 
@@ -3338,7 +3398,8 @@ static void *fio_sentinel_worker_thread(void *arg) {
   /* release fork lock. */
   fio_unlock(&fio_fork_lock);
   if (child == -1) {
-    perror("FATAL ERROR: couldn't spawn worker.");
+    FIO_LOG_FATAL("couldn't spawn worker.");
+    perror("\n           errno");
     kill(fio_parent_pid(), SIGINT);
     fio_stop();
     return NULL;
@@ -3348,17 +3409,10 @@ static void *fio_sentinel_worker_thread(void *arg) {
 #if DEBUG
     if (fio_data->active) { /* !WIFEXITED(status) || WEXITSTATUS(status) */
       if (!WIFEXITED(status) || WEXITSTATUS(status)) {
-        FIO_LOG_STATE(
-            "FATAL ERROR: Child worker (%d) crashed. Stopping services in "
-            "DEBUG mode.\n",
-            child);
+        FIO_LOG_FATAL("Child worker (%d) crashed. Stopping services.", child);
         fio_state_callback_force(FIO_CALL_ON_CHILD_CRUSH);
       } else {
-        fprintf(
-            stderr,
-            "INFO (FATAL): Child worker (%d) shutdown. Stopping services in "
-            "DEBUG mode.\n",
-            child);
+        FIO_LOG_FATAL("Child worker (%d) shutdown. Stopping services.", child);
       }
       kill(0, SIGINT);
     }
@@ -3367,13 +3421,11 @@ static void *fio_sentinel_worker_thread(void *arg) {
       /* don't call any functions while forking. */
       fio_lock(&fio_fork_lock);
       if (!WIFEXITED(status) || WEXITSTATUS(status)) {
-        fprintf(stderr,
-                "ERROR: Child worker (%d) crashed. Respawning worker.\n",
-                child);
+        FIO_LOG_ERROR("Child worker (%d) crashed. Respawning worker.", child);
         fio_state_callback_force(FIO_CALL_ON_CHILD_CRUSH);
       } else {
-        FIO_LOG_STATE("INFO: Child worker (%d) shutdown. Respawning worker.\n",
-                      child);
+        FIO_LOG_WARNING("Child worker (%d) shutdown. Respawning worker.",
+                        child);
       }
       fio_defer(fio_sentinel_task, NULL, NULL);
       fio_unlock(&fio_fork_lock);
@@ -3402,6 +3454,7 @@ static void fio_sentinel_task(void *arg1, void *arg2) {
   fio_lock(&fio_fork_lock);   /* will wait for worker thread to release lock. */
   fio_unlock(&fio_fork_lock); /* release lock for next fork. */
   fio_state_callback_force(FIO_CALL_AFTER_FORK);
+  fio_state_callback_force(FIO_CALL_IN_MASTER);
   (void)arg1;
   (void)arg2;
 }
@@ -3846,10 +3899,10 @@ static void fio_listen_on_startup(void *pr_) {
   fio_listen_protocol_s *pr = pr_;
   fio_attach(pr->uuid, &pr->pr);
   if (pr->port_len)
-    FIO_LOG_STATE("* (%d) started listening on port %s\n", getpid(), pr->port);
+    FIO_LOG_INFO("(%d) started listening on port %s", getpid(), pr->port);
   else
-    FIO_LOG_STATE("* (%d) started listening on Unix Socket at %s\n", getpid(),
-                  pr->addr);
+    FIO_LOG_INFO("(%d) started listening on Unix Socket at %s", getpid(),
+                 pr->addr);
 }
 
 static void fio_listen_on_close(intptr_t uuid, fio_protocol_s *pr_) {
@@ -3867,6 +3920,8 @@ static void fio_listen_on_data(intptr_t uuid, fio_protocol_s *pr_) {
   }
 }
 
+/* stub for editor - unused */
+void fio_listen____(void);
 /**
  * Schedule a network service on a listening socket.
  *
@@ -3922,9 +3977,9 @@ intptr_t fio_listen FIO_IGNORE_MACRO(struct fio_listen_args args) {
   }
 
   if (args.port)
-    FIO_LOG_STATE("* Listening on port %s\n", args.port);
+    FIO_LOG_INFO("Listening on port %s", args.port);
   else
-    FIO_LOG_STATE("* Listening on Unix Socket at %s\n", args.address);
+    FIO_LOG_INFO("Listening on Unix Socket at %s", args.address);
 
   return uuid;
 error:
@@ -4160,7 +4215,7 @@ struct fio_collection_s {
 #define COLLECTION_INIT                                                        \
   { .channels = FIO_SET_INIT, .lock = FIO_LOCK_INIT }
 
-struct {
+static struct {
   fio_collection_s filters;
   fio_collection_s pubsub;
   fio_collection_s patterns;
@@ -4281,7 +4336,7 @@ static channel_s *fio_channel_dup_lock(fio_str_info_s name) {
       .lock = FIO_LOCK_INIT,
   };
   fio_str_write(&ch->id, name.data, name.len);
-  // fio_str_freeze(&ch->id);
+  fio_str_freeze(&ch->id);
   uint64_t hashed_name = fio_str_hash(&ch->id);
   ch = fio_filter_dup_lock_internal(ch, hashed_name, &fio_postoffice.pubsub);
   if (fio_ls_embd_is_empty(&ch->subscriptions)) {
@@ -4331,7 +4386,7 @@ static inline void fio_subscription_free(subscription_s *s) {
 /** Subscribes to a filter, pub/sub channle or patten */
 subscription_s *fio_subscribe FIO_IGNORE_MACRO(subscribe_args_s args) {
   if (!args.on_message)
-    return NULL;
+    goto error;
   channel_s *ch;
   subscription_s *s = fio_malloc(sizeof(*s));
   FIO_ASSERT_ALLOC(s);
@@ -4354,6 +4409,10 @@ subscription_s *fio_subscribe FIO_IGNORE_MACRO(subscribe_args_s args) {
   fio_ls_embd_push(&ch->subscriptions, &s->node);
   fio_unlock((&ch->lock));
   return s;
+error:
+  if (args.on_unsubscribe)
+    args.on_unsubscribe(args.udata1, args.udata2);
+  return NULL;
 }
 
 /** Unsubscribes from a filter, pub/sub channle or patten */
@@ -4375,6 +4434,7 @@ void fio_unsubscribe(subscription_s *s) {
     if (c == &fio_postoffice.patterns) {
       pattern_s *pat = (pattern_s *)ch;
       hashed ^= ((uintptr_t)pat->match);
+      match = ((pattern_s *)(ch))->match;
     }
     /* lock collection */
     fio_lock(&c->lock);
@@ -4387,9 +4447,6 @@ void fio_unsubscribe(subscription_s *s) {
   }
   fio_unlock(&ch->lock);
   if (removed) {
-    if (ch->parent == &fio_postoffice.patterns) {
-      match = ((pattern_s *)(ch))->match;
-    }
     pubsub_on_channel_destroy(ch, match);
   }
 
@@ -4678,9 +4735,6 @@ static void fio_perform_subscription_callback(void *s_, void *msg_) {
 
 /** UNSAFE! publishes a message to a channel, managing the reference counts */
 static void fio_publish2channel(channel_s *ch, fio_msg_internal_s *msg) {
-  if (!ch || !msg) {
-    return;
-  }
   FIO_LS_EMBD_FOR(&ch->subscriptions, pos) {
     subscription_s *s = FIO_LS_EMBD_OBJ(subscription_s, node, pos);
     if (!s) {
@@ -4694,12 +4748,18 @@ static void fio_publish2channel(channel_s *ch, fio_msg_internal_s *msg) {
 }
 static void fio_publish2channel_task(void *ch_, void *msg) {
   channel_s *ch = ch_;
+  if (!ch_)
+    return;
+  if (!msg)
+    goto finish;
   if (fio_trylock(&ch->lock)) {
     fio_defer(fio_publish2channel_task, ch, msg);
     return;
   }
   fio_publish2channel(ch, msg);
   fio_unlock(&ch->lock);
+finish:
+  fio_str_free(&ch->id);
 }
 
 /** Publishes the message to the current process and frees the strings. */
@@ -4718,7 +4778,8 @@ static void fio_publish2process(fio_msg_internal_s *m) {
   }
   /* exact match */
   if (ch) {
-    fio_defer(fio_publish2channel_task, ch, fio_msg_internal_dup(m));
+    fio_defer(fio_publish2channel_task, fio_str_dup(&ch->id),
+              fio_msg_internal_dup(m));
   }
   if (m->filter == 0) {
     /* pattern matching match */
@@ -4729,7 +4790,7 @@ static void fio_publish2process(fio_msg_internal_s *m) {
       }
       pattern_s *pattern = (pattern_s *)p->obj;
       if (pattern->match(fio_str_info(&pattern->ch.id), m->channel)) {
-        fio_defer(fio_publish2channel_task, &pattern->ch,
+        fio_defer(fio_publish2channel_task, fio_str_dup(&pattern->ch.id),
                   fio_msg_internal_dup(m));
       }
     }
@@ -4750,6 +4811,7 @@ static void fio_publish2process(fio_msg_internal_s *m) {
 #define FIO_SET_KEY_COPY(k1, k2)                                               \
   (k1) = FIO_STR_INIT;                                                         \
   fio_str_concat(&(k1), &(k2))
+#define FIO_SET_KEY_COMPARE(k1, k2) fio_str_iseq(&(k1), &(k2))
 #define FIO_SET_KEY_DESTROY(key) fio_str_free(&(key))
 #define FIO_SET_OBJ_DESTROY(obj) fio_unsubscribe(obj)
 #include <fio.h>
@@ -4771,7 +4833,7 @@ typedef struct cluster_pr_s {
   uint8_t buffer[CLUSTER_READ_BUFFER];
 } cluster_pr_s;
 
-struct cluster_data_s {
+static struct cluster_data_s {
   intptr_t uuid;
   fio_ls_s clients;
   fio_lock_i lock;
@@ -4782,7 +4844,7 @@ struct cluster_data_s {
 static void fio_cluster_data_cleanup(int delete_file) {
   if (delete_file && cluster_data.name[0]) {
 #if DEBUG
-    FIO_LOG_STATE("* INFO: (%d) unlinking cluster's Unix socket.\n", getpid());
+    FIO_LOG_DEBUG("(%d) unlinking cluster's Unix socket.", getpid());
 #endif
     unlink(cluster_data.name);
   }
@@ -4896,20 +4958,16 @@ static void fio_cluster_on_data(intptr_t uuid, fio_protocol_s *pr_) {
       c->filter = (int32_t)fio_str2u32(c->buffer + i + 12);
       if (c->exp_channel) {
         if (c->exp_channel >= (1024 * 1024 * 16)) {
-          fprintf(stderr,
-                  "FATAL ERROR: (%d) cluster message name too long (16Mb "
-                  "limit): %u\n",
-                  getpid(), (unsigned int)c->exp_channel);
+          FIO_LOG_FATAL("(%d) cluster message name too long (16Mb limit): %u\n",
+                        getpid(), (unsigned int)c->exp_channel);
           exit(1);
           return;
         }
       }
       if (c->exp_msg) {
         if (c->exp_msg >= (1024 * 1024 * 64)) {
-          fprintf(stderr,
-                  "FATAL ERROR: (%d) cluster message data too long (64Mb "
-                  "limit): %u\n",
-                  getpid(), (unsigned int)c->exp_msg);
+          FIO_LOG_FATAL("(%d) cluster message data too long (64Mb limit): %u\n",
+                        getpid(), (unsigned int)c->exp_msg);
           exit(1);
           return;
         }
@@ -4988,8 +5046,7 @@ static void fio_cluster_on_close(intptr_t uuid, fio_protocol_s *pr_) {
   } else if (fio_data->active) {
     /* no shutdown message received - parent crashed. */
     if (c->type != FIO_CLUSTER_MSG_SHUTDOWN && fio_is_running()) {
-      FIO_LOG_STATE("* FATAL ERROR: (%d) Parent Process crash detected!\n",
-                    getpid());
+      FIO_LOG_FATAL("(%d) Parent Process crash detected!", getpid());
       fio_state_callback_force(FIO_CALL_ON_PARENT_CRUSH);
       fio_state_callback_clear(FIO_CALL_ON_PARENT_CRUSH);
       fio_cluster_data_cleanup(1);
@@ -5009,7 +5066,7 @@ fio_cluster_protocol_alloc(intptr_t uuid,
                            void (*sender)(fio_str_s *data, intptr_t auuid)) {
   cluster_pr_s *p = fio_mmap(sizeof(*p));
   if (!p) {
-    FIO_LOG_STATE("FATAL ERROR: Cluster protocol allocation failed");
+    FIO_LOG_FATAL("Cluster protocol allocation failed.");
     exit(errno);
   }
   p->protocol = (fio_protocol_s){
@@ -5142,8 +5199,7 @@ static void fio_cluster_listen_on_close(intptr_t uuid,
   cluster_data.uuid = -1;
   if (fio_parent_pid() == getpid()) {
 #if DEBUG
-    FIO_LOG_STATE("* INFO: (%d) stopped listening for cluster connections\n",
-                  getpid());
+    FIO_LOG_DEBUG("(%d) stopped listening for cluster connections", getpid());
 #endif
     if (fio_data->active)
       kill(0, SIGINT);
@@ -5158,8 +5214,8 @@ static void fio_listen2cluster(void *ignore) {
   cluster_data.uuid = fio_socket(cluster_data.name, NULL, 1);
   fio_unlock(&cluster_data.lock);
   if (cluster_data.uuid < 0) {
-    perror("FATAL ERROR: (facil.io cluster) failed to open cluster socket.\n"
-           "             check file permissions");
+    FIO_LOG_FATAL("(facil.io cluster) failed to open cluster socket.");
+    perror("             check file permissions. errno:");
     exit(errno);
   }
   fio_protocol_s *p = malloc(sizeof(*p));
@@ -5171,8 +5227,7 @@ static void fio_listen2cluster(void *ignore) {
       .on_close = fio_cluster_listen_on_close,
   };
 #if DEBUG
-  FIO_LOG_STATE("* INFO: (%d) Listening to cluster: %s\n", getpid(),
-                cluster_data.name);
+  FIO_LOG_DEBUG("(%d) Listening to cluster: %s", getpid(), cluster_data.name);
 #endif
   fio_attach(cluster_data.uuid, p);
   (void)ignore;
@@ -5226,7 +5281,7 @@ static void fio_cluster_client_sender(fio_str_s *data, intptr_t ignr_) {
  *
  * Should either call `facil_attach` or close the connection.
  */
-void fio_cluster_on_connect(intptr_t uuid, void *udata) {
+static void fio_cluster_on_connect(intptr_t uuid, void *udata) {
   cluster_data.uuid = uuid;
 
   /* inform root about all existing channels */
@@ -5256,8 +5311,9 @@ void fio_cluster_on_connect(intptr_t uuid, void *udata) {
  * The `on_fail` is called when a socket fails to connect. The old sock UUID
  * is passed along.
  */
-void fio_cluster_on_fail(intptr_t uuid, void *udata) {
-  perror("FATAL ERROR: (facil.io) unknown cluster connection error");
+static void fio_cluster_on_fail(intptr_t uuid, void *udata) {
+  FIO_LOG_FATAL("(facil.io) unknown cluster connection error");
+  perror("       errno");
   kill(fio_parent_pid(), SIGINT);
   fio_stop();
   // exit(errno ? errno : 1);
@@ -5276,7 +5332,7 @@ static void fio_connect2cluster(void *ignore) {
 static void fio_send2cluster(int32_t filter, fio_str_info_s ch,
                              fio_str_info_s msg, uint8_t is_json) {
   if (!fio_is_running()) {
-    FIO_LOG_STATE("ERROR: cluster inactive, can't send message.\n");
+    FIO_LOG_ERROR("facio.io cluster inactive, can't send message.");
     return;
   }
   if (fio_data->workers == 1) {
@@ -5313,7 +5369,7 @@ static inline void fio_cluster_inform_root_about_channel(channel_s *ch,
   fio_str_info_s ch_name = fio_str_info(&ch->id);
   fio_str_info_s msg = {.data = NULL, .len = 0};
 #if DEBUG
-  FIO_LOG_STATE("* (%d) informing root about: %s (%zu) msg type %d\n", getpid(),
+  FIO_LOG_DEBUG("(%d) informing root about: %s (%zu) msg type %d", getpid(),
                 ch_name.data, ch_name.len,
                 (match ? (add ? FIO_CLUSTER_MSG_PATTERN_SUB
                               : FIO_CLUSTER_MSG_PATTERN_UNSUB)
@@ -5494,8 +5550,8 @@ void fio_publish FIO_IGNORE_MACRO(fio_publish_args_s args) {
     break;
   default:
     if (args.filter != 0) {
-      fprintf(stderr, "ERROR: (pub/sub) pub/sub engines can only be used for "
-                      "pub/sub messages (no filter).\n");
+      FIO_LOG_ERROR("(pub/sub) pub/sub engines can only be used for "
+                    "pub/sub messages (no filter).");
       return;
     }
     args.engine->publish(args.engine, args.channel, args.message, args.is_json);
@@ -5663,57 +5719,32 @@ Section Start Marker
 
 ***************************************************************************** */
 
-/* *****************************************************************************
-If FIO_FORCE_MALLOC is set, use glibc / library malloc
-***************************************************************************** */
 #if FIO_FORCE_MALLOC
-
-void *fio_malloc(size_t size) { return malloc(size); }
-
-void *fio_calloc(size_t size, size_t count) { return calloc(size, count); }
-
-void fio_free(void *ptr) { free(ptr); }
-
-void *fio_realloc(void *ptr, size_t new_size) { return realloc(ptr, new_size); }
-void *fio_realloc2(void *ptr, size_t new_size, size_t valid_len) {
-  return realloc(ptr, new_size);
-  (void)valid_len;
-}
-/** Clears any memory locks, in case of a system call to `fork`. */
-static void fio_malloc_after_fork(void) {}
+void fio_mem_destroy(void) {}
+void fio_mem_init(void) {}
 
 #else
-/* *****************************************************************************
-facil.io malloc implementation
-***************************************************************************** */
-
-#if !defined(__clang__) && !defined(__GNUC__)
-#define __thread _Thread_value
-#endif
-
-#undef malloc
-#undef calloc
-#undef free
-#undef realloc
 
 /* *****************************************************************************
 Memory Copying by 16 byte units
 ***************************************************************************** */
 
+static inline void fio_memcpy(void *__restrict dest_, void *__restrict src_,
+                              size_t units) {
 #if __SIZEOF_INT128__ == 9 /* a 128bit type exists... but tests favor 64bit */
-static inline void fio_memcpy(__uint128_t *__restrict dest,
-                              __uint128_t *__restrict src, size_t units) {
+  register __uint128_t *dest = dest_;
+  register __uint128_t *src = src_;
 #elif SIZE_MAX == 0xFFFFFFFFFFFFFFFF /* 64 bit size_t */
-static inline void fio_memcpy(size_t *__restrict dest, size_t *__restrict src,
-                              size_t units) {
+  register size_t *dest = dest_;
+  register size_t *src = src_;
   units = units << 1;
 #elif SIZE_MAX == 0xFFFFFFFF         /* 32 bit size_t */
-static inline void fio_memcpy(size_t *__restrict dest, size_t *__restrict src,
-                              size_t units) {
+  register size_t *dest = dest_;
+  register size_t *src = src_;
   units = units << 2;
 #else                                /* unknow... assume 16 bit? */
-static inline void fio_memcpy(uint16_t *__restrict dest,
-                              uint16_t *__restrict src, size_t units) {
+  register size_t *dest = dest_;
+  register size_t *src = src_;
   units = units << 3;
 #endif
   while (units >= 16) { /* unroll loop */
@@ -5926,7 +5957,7 @@ static void arena_enter(void) { arena_last_used = arena_lock(arena_last_used); }
 static inline void arena_exit(void) { fio_unlock(&arena_last_used->lock); }
 
 /** Clears any memory locks, in case of a system call to `fork`. */
-static void fio_malloc_after_fork(void) {
+void fio_malloc_after_fork(void) {
   arena_last_used = NULL;
   if (!arenas) {
     return;
@@ -5972,7 +6003,7 @@ static inline void block_free(block_s *blk) {
   }
   memset(blk, 0, FIO_MEMORY_BLOCK_SIZE);
   fio_lock(&memory.lock);
-  *(block_s **)blk = memory.available;
+  ((block_s **)blk)[0] = memory.available;
   memory.available = (block_s *)blk;
   fio_unlock(&memory.lock);
 }
@@ -5983,13 +6014,15 @@ static inline block_s *block_new(void) {
 
   if (memory.available) {
     fio_lock(&memory.lock);
-    blk = (block_s *)memory.available;
+    blk = memory.available;
     if (blk) {
       memory.available = ((block_s **)blk)[0];
     }
     fio_unlock(&memory.lock);
   }
   if (blk) {
+    FIO_ASSERT(((uintptr_t)blk & FIO_MEMORY_BLOCK_MASK) == 0,
+               "Memory allocator error! double `fio_free`?\n");
     fio_atomic_sub(&memory.count, 1);
     ((block_s **)blk)[0] = NULL;
     ((block_s **)blk)[1] = NULL;
@@ -6003,6 +6036,7 @@ static inline block_s *block_new(void) {
   ;
 }
 
+/* allocates memory from within a block - called within an arena's lock */
 static inline void *block_slice(uint16_t units) {
   block_s *blk = arena_last_used->block;
   if (!blk) {
@@ -6025,7 +6059,6 @@ static inline void *block_slice(uint16_t units) {
   fio_atomic_add(&blk->ref, 1);
   blk->pos += units;
   if (blk->pos >= blk->max) {
-    /* it's true that a 16 bytes slice remains, but statistically... */
     /* ... the block was fully utilized, clear arena */
     block_free(blk);
     arena_last_used->block = NULL;
@@ -6033,6 +6066,7 @@ static inline void *block_slice(uint16_t units) {
   return (void *)mem;
 }
 
+/* handle's a bock's reference count - called without a lock */
 static inline void block_slice_free(void *mem) {
   /* locate block boundary */
   block_s *blk = (block_s *)((uintptr_t)mem & (~FIO_MEMORY_BLOCK_MASK));
@@ -6043,6 +6077,7 @@ static inline void block_slice_free(void *mem) {
 Non-Block allocations (direct from the system)
 ***************************************************************************** */
 
+/* allocates directly from the system adding size header - no lock required. */
 static inline void *big_alloc(size_t size) {
   size = sys_round_size(size + 16);
   size_t *mem = sys_alloc(size, 1);
@@ -6054,11 +6089,13 @@ error:
   return NULL;
 }
 
+/* reads size header and frees memory back to the system */
 static inline void big_free(void *ptr) {
   size_t *mem = (void *)(((uintptr_t)ptr) - 16);
   sys_free(mem, *mem);
 }
 
+/* reallocates memory using the system, resetting the size header */
 static inline void *big_realloc(void *ptr, size_t new_size) {
   size_t *mem = (void *)(((uintptr_t)ptr) - 16);
   new_size = sys_round_size(new_size + 16);
@@ -6088,10 +6125,7 @@ static void fio_mem_init(void) {
   memory.cores = cpu_count;
   memory.count = 0 - (intptr_t)cpu_count;
   arenas = big_alloc(sizeof(*arenas) * cpu_count);
-  if (!arenas) {
-    perror("FATAL ERROR: Couldn't initialize memory allocator");
-    exit(errno);
-  }
+  FIO_ASSERT_ALLOC(arenas);
   size_t pre_pool = cpu_count > 32 ? 32 : cpu_count;
   for (size_t i = 0; i < pre_pool; ++i) {
     void *block = sys_alloc(FIO_MEMORY_BLOCK_SIZE, 0);
@@ -6107,16 +6141,14 @@ static void fio_mem_destroy(void) {
   if (!arenas)
     return;
 
-  arena_s *arena = arenas;
   for (size_t i = 0; i < memory.cores; ++i) {
-    if (arena->block)
-      block_free(arena->block);
-    arena->block = NULL;
-    ++arena;
+    if (arenas[i].block)
+      block_free(arenas[i].block);
+    arenas[i].block = NULL;
   }
   while (memory.available) {
     block_s *b = memory.available;
-    memory.available = *(block_s **)b;
+    memory.available = ((block_s **)b)[0];
     sys_free(b, FIO_MEMORY_BLOCK_SIZE);
   }
   big_free(arenas);
@@ -6980,7 +7012,7 @@ fio_sha2_s fio_sha2_init(fio_sha2_variant_e variant) {
         .digest.i64[7] = 0x0eb72ddc81c52ca2,
     };
   }
-  fprintf(stderr, "FATAL ERROR: SHA-2 ERROR - variant unknown\n");
+  FIO_LOG_FATAL("SHA-2 ERROR - variant unknown");
   exit(2);
 }
 
@@ -7609,6 +7641,15 @@ Testing Strings
 #define fio_str_test()
 #else
 
+static int fio_str_test_dealloc_counter = 0;
+
+FIO_FUNC void fio_str_test_dealloc(void *s) {
+  FIO_ASSERT(!fio_str_test_dealloc_counter,
+             "fio_str_s reference count error!\n");
+  fio_free(s);
+  fprintf(stderr, "* reference counting `fio_str_free2` pass.\n");
+}
+
 /**
  * Tests the fio_str functionality.
  */
@@ -7764,12 +7805,16 @@ FIO_FUNC inline void fio_str_test(void) {
                "`fio_str_new2` error, string not initialized (%p)!", (void *)s);
     fio_str_s *s2 = fio_str_dup(s);
 
+    ++fio_str_test_dealloc_counter;
+
     FIO_ASSERT(s2 == s, "`fio_str_dup` error, should return self!");
     FIO_ASSERT(s->ref == 1,
                "`fio_str_dup` error, reference counter not incremented!");
 
     fprintf(stderr, "* reading a file.\n");
     fio_str_info_s state = fio_str_readfile(s, __FILE__, 0, 0);
+    if (!s->small) /* attach deallocation test */
+      s->dealloc = fio_str_test_dealloc;
 
     FIO_ASSERT(state.data,
                "`fio_str_readfile` error, no data was read for file %s!",
@@ -7793,6 +7838,7 @@ FIO_FUNC inline void fio_str_test(void) {
 
     fprintf(stderr, "* reviewing reference counting `fio_str_free2` (1/2).\n");
     fio_str_free2(s2);
+    --fio_str_test_dealloc_counter;
     FIO_ASSERT(s->ref == 0,
                "`fio_str_free2` error, reference counter not subtracted!");
     FIO_ASSERT(s->small == 0, "`fio_str_free2` error, strring reinitialized!");
@@ -7885,11 +7931,11 @@ FIO_FUNC inline void fio_str_test(void) {
                "Static string length should be automatically calculated.");
     FIO_ASSERT(str.dealloc == NULL,
                "Static string deallocation function should be NULL.");
-    fio_free(&str);
+    fio_str_free(&str);
     str = FIO_STR_INIT_STATIC("Welcome");
     fio_str_info_s state = fio_str_write(&str, " Home", 5);
     FIO_ASSERT(state.capa > 0, "Static string not converted to non-static.");
-    fio_free(&str);
+    fio_str_free(&str);
   }
   fprintf(stderr, "* passed.\n");
 }
@@ -7899,6 +7945,9 @@ FIO_FUNC inline void fio_str_test(void) {
 Testing Memory Allocator
 ***************************************************************************** */
 
+#if FIO_FORCE_MALLOC
+#define fio_malloc_test()
+#else
 void fio_malloc_test(void) {
   fprintf(stderr, "=== Testing facil.io memory allocator's system calls\n");
   char *mem = sys_alloc(FIO_MEMORY_BLOCK_SIZE, 0);
@@ -7929,8 +7978,18 @@ void fio_malloc_test(void) {
   FIO_ASSERT(mem[0] == 'a', "fio_realloc memory wasn't copied!\n");
   FIO_ASSERT(arena_last_used, "arena_last_used wasn't initialized!\n");
   block_s *b = arena_last_used->block;
-  size_t count = 2;
-  intptr_t old_memory_pool_count = memory.count;
+
+  /* move arena to block's start */
+  while (arena_last_used->block == b) {
+    mem = fio_malloc(1);
+    FIO_ASSERT(mem, "fio_malloc failed to allocate memory!\n");
+    fio_free(mem);
+  }
+  /* make sure a block is assigned */
+  fio_free(fio_malloc(1));
+  b = arena_last_used->block;
+  size_t count = 1;
+  /* count allocations within block */
   do {
     FIO_ASSERT(mem, "fio_malloc failed to allocate memory!\n");
     FIO_ASSERT(!((uintptr_t)mem & 15),
@@ -7947,18 +8006,21 @@ void fio_malloc_test(void) {
     ++count;
   } while (arena_last_used->block == b);
   {
+    fprintf(stderr, "* Confirm block address: %p, last allocation was %p\n",
+            (void *)arena_last_used->block, (void *)mem);
     fprintf(
         stderr,
         "* Performed %zu allocations out of expected %zu allocations per "
         "block.\n",
         count,
         (size_t)((FIO_MEMORY_BLOCK_SLICES - 2) - (sizeof(block_s) >> 4) - 1));
+    intptr_t old_memory_pool_count = memory.count;
+    fio_free(mem);
     FIO_ASSERT(memory.available,
                "memory pool empty (memory block wasn't freed)!\n");
-    FIO_ASSERT(old_memory_pool_count == memory.count,
-               "memory.count == %ld (memory block not counted)!\n",
-               (long)old_memory_pool_count);
-    fio_free(mem);
+    FIO_ASSERT(old_memory_pool_count + 1 == memory.count,
+               "memory.count == %ld , was %ld (memory block counting error)!\n",
+               (long)memory.count, (long)old_memory_pool_count);
   }
   /* rotate block again */
   b = arena_last_used->block;
@@ -8019,6 +8081,7 @@ void fio_malloc_test(void) {
 
   fprintf(stderr, "* passed.\n");
 }
+#endif
 
 /* *****************************************************************************
 Testing Core Callback add / remove / ensure
@@ -8346,114 +8409,159 @@ Set data-structure Testing
 
 #define FIO_SET_TEXT_COUNT 524288UL
 
-#define FIO_SET_NAME fio_hashmap_test
+#define FIO_SET_NAME fio_set_test
 #define FIO_SET_OBJ_TYPE uintptr_t
+#include <fio.h>
 
+#define FIO_SET_NAME fio_hash_test
+#define FIO_SET_KEY_TYPE uintptr_t
+#define FIO_SET_OBJ_TYPE uintptr_t
 #include <fio.h>
-#define FIO_SET_NAME(s) fio_hashmap_test_##s
 
 FIO_FUNC void fio_set_test(void) {
-  FIO_SET_NAME(s) s = FIO_SET_INIT;
+  fio_set_test_s s = FIO_SET_INIT;
+  fio_hash_test_s h = FIO_SET_INIT;
   fprintf(
       stderr,
       "=== Testing Core ordered Set (re-including fio.h with FIO_SET_NAME)\n");
   fprintf(stderr, "* Inserting %lu items\n", FIO_SET_TEXT_COUNT);
-  union {
-    uintptr_t obj;
-    uintptr_t i;
-  } obj_mem;
-  memset(&obj_mem, 0, sizeof(obj_mem));
-
-  FIO_ASSERT(FIO_SET_NAME(count)(&s) == 0,
-             "empty set should have zero objects");
-  FIO_ASSERT(FIO_SET_NAME(capa)(&s) == 0, "empty set should have no capacity");
-  FIO_ASSERT(!FIO_SET_NAME(is_fragmented)(&s),
+
+  FIO_ASSERT(fio_set_test_count(&s) == 0, "empty set should have zero objects");
+  FIO_ASSERT(fio_set_test_capa(&s) == 0, "empty set should have no capacity");
+  FIO_ASSERT(fio_hash_test_capa(&h) == 0, "empty hash should have no capacity");
+  FIO_ASSERT(!fio_set_test_is_fragmented(&s),
              "empty set shouldn't be considered fragmented");
-  FIO_ASSERT(!FIO_SET_NAME(last)(&s), "empty set shouldn't have a last object");
+  FIO_ASSERT(!fio_hash_test_is_fragmented(&h),
+             "empty hash shouldn't be considered fragmented");
+  FIO_ASSERT(!fio_set_test_last(&s), "empty set shouldn't have a last object");
+  FIO_ASSERT(!fio_hash_test_last(&h),
+             "empty hash shouldn't have a last object");
 
   for (uintptr_t i = 1; i < FIO_SET_TEXT_COUNT; ++i) {
-    obj_mem.i = i;
-    FIO_SET_NAME(insert)(&s, i, obj_mem.obj);
-    FIO_ASSERT(FIO_SET_NAME(find)(&s, i, obj_mem.obj),
-               "find failed after insert");
-    obj_mem.obj = *FIO_SET_NAME(find)(&s, i, obj_mem.obj);
-    FIO_ASSERT(i == obj_mem.i, "insertion != find");
+    fio_set_test_insert(&s, i, i);
+    fio_hash_test_insert(&h, i, i, i + 1);
+    FIO_ASSERT(fio_set_test_find(&s, i, i), "set find failed after insert");
+    FIO_ASSERT(fio_hash_test_find(&h, i, i), "hash find failed after insert");
+    FIO_ASSERT(i == *fio_set_test_find(&s, i, i), "set insertion != find");
+    FIO_ASSERT(i + 1 == *fio_hash_test_find(&h, i, i),
+               "hash insertion != find");
   }
   fprintf(stderr, "* Seeking %lu items\n", FIO_SET_TEXT_COUNT);
   for (unsigned long i = 1; i < FIO_SET_TEXT_COUNT; ++i) {
-    obj_mem.i = i;
-    obj_mem.obj = *FIO_SET_NAME(find)(&s, i, obj_mem.obj);
-    FIO_ASSERT((i == obj_mem.i), "insertion != find (seek)");
+    FIO_ASSERT((i == *fio_set_test_find(&s, i, i)),
+               "set insertion != find (seek)");
+    FIO_ASSERT((i + 1 == *fio_hash_test_find(&h, i, i)),
+               "hash insertion != find (seek)");
   }
   {
-    fprintf(stderr, "* Testing order for %lu items\n", FIO_SET_TEXT_COUNT);
+    fprintf(stderr, "* Testing order for %lu items in set\n",
+            FIO_SET_TEXT_COUNT);
     uintptr_t i = 1;
     FIO_SET_FOR_LOOP(&s, pos) {
-      obj_mem.obj = pos->obj;
-      FIO_ASSERT(obj_mem.i == i, "object order mismatch %lu != %lu.",
-                 (unsigned long)i, (unsigned long)obj_mem.i);
+      FIO_ASSERT(pos->obj == i, "object order mismatch %lu != %lu.",
+                 (unsigned long)i, (unsigned long)pos->obj);
+      ++i;
+    }
+  }
+  {
+    fprintf(stderr, "* Testing order for %lu items in hash\n",
+            FIO_SET_TEXT_COUNT);
+    uintptr_t i = 1;
+    FIO_SET_FOR_LOOP(&h, pos) {
+      FIO_ASSERT(pos->obj.obj == i + 1 && pos->obj.key == i,
+                 "object order mismatch %lu != %lu.", (unsigned long)i,
+                 (unsigned long)pos->obj.key);
       ++i;
     }
   }
 
   fprintf(stderr, "* Removing odd items from %lu items\n", FIO_SET_TEXT_COUNT);
   for (unsigned long i = 1; i < FIO_SET_TEXT_COUNT; i += 2) {
-    obj_mem.i = i;
-    FIO_SET_NAME(remove)(&s, i, obj_mem.obj);
-    FIO_ASSERT(!(FIO_SET_NAME(find)(&s, i, obj_mem.obj)),
-               "Removal failed (still exists).");
+    fio_set_test_remove(&s, i, i);
+    fio_hash_test_remove(&h, i, i);
+    FIO_ASSERT(!(fio_set_test_find(&s, i, i)),
+               "Removal failed in set (still exists).");
+    FIO_ASSERT(!(fio_hash_test_find(&h, i, i)),
+               "Removal failed in hash (still exists).");
   }
   {
     fprintf(stderr, "* Testing for %lu / 2 holes\n", FIO_SET_TEXT_COUNT);
     uintptr_t i = 1;
     FIO_SET_FOR_LOOP(&s, pos) {
-      obj_mem.obj = pos->obj;
       if (pos->hash == 0) {
         FIO_ASSERT((i & 1) == 1, "deleted object wasn't odd");
       } else {
-        FIO_ASSERT(obj_mem.i == i, "deleted object value mismatch %lu != %lu",
-                   (unsigned long)i, (unsigned long)obj_mem.i);
+        FIO_ASSERT(pos->obj == i, "deleted object value mismatch %lu != %lu",
+                   (unsigned long)i, (unsigned long)pos->obj);
+      }
+      ++i;
+    }
+    i = 1;
+    FIO_SET_FOR_LOOP(&h, pos) {
+      if (pos->hash == 0) {
+        FIO_ASSERT((i & 1) == 1, "deleted object wasn't odd");
+      } else {
+        FIO_ASSERT(pos->obj.key == i,
+                   "deleted object value mismatch %lu != %lu", (unsigned long)i,
+                   (unsigned long)pos->obj.key);
       }
       ++i;
     }
     {
       fprintf(stderr, "* Poping two elements (testing pop through holes)\n");
-      FIO_ASSERT(FIO_SET_NAME(last)(&s),
-                 "Pop `last` 1 failed - no last object");
-      obj_mem.obj = *FIO_SET_NAME(last)(&s);
-      uintptr_t tmp_i = obj_mem.i;
-      FIO_ASSERT(obj_mem.obj, "Pop `last` 1 failed to collect object");
-      FIO_SET_NAME(pop)(&s);
-      FIO_ASSERT(FIO_SET_NAME(last)(&s),
-                 "Pop `last` 2 failed - no last object");
-      obj_mem.obj = *FIO_SET_NAME(last)(&s);
-      FIO_ASSERT(obj_mem.i != tmp_i,
-                 "Pop `last` 2 same as `last` 1 - failed to collect object");
-      FIO_SET_NAME(pop)(&s);
+      FIO_ASSERT(fio_set_test_last(&s), "Pop `last` 1 failed - no last object");
+      uintptr_t tmp = *fio_set_test_last(&s);
+      FIO_ASSERT(tmp, "Pop set `last` 1 failed to collect object");
+      fio_set_test_pop(&s);
+      FIO_ASSERT(
+          *fio_set_test_last(&s) != tmp,
+          "Pop `last` 2 in set same as `last` 1 - failed to collect object");
+      tmp = fio_hash_test_last(&h)->key;
+      FIO_ASSERT(tmp, "Pop hash `last` 1 failed to collect object");
+      fio_hash_test_pop(&h);
+      FIO_ASSERT(
+          fio_hash_test_last(&h)->key != tmp,
+          "Pop `last` 2 in hash same as `last` 1 - failed to collect object");
+      FIO_ASSERT(fio_set_test_last(&s), "Pop `last` 2 failed - no last object");
+      FIO_ASSERT(fio_hash_test_last(&h),
+                 "Pop `last` 2 failed in hash - no last object");
+      fio_set_test_pop(&s);
+      fio_hash_test_pop(&h);
     }
     if (1) {
-      obj_mem.i = 1;
-      FIO_SET_NAME(remove)(&s, obj_mem.i, obj_mem.obj);
+      uintptr_t tmp = 1;
+      fio_set_test_remove(&s, tmp, tmp);
+      fio_hash_test_remove(&h, tmp, tmp);
       size_t count = s.count;
-      FIO_SET_NAME(overwrite)(&s, obj_mem.i, obj_mem.obj);
-      FIO_ASSERT(count + 1 == s.count,
-                 "Re-adding a removed item should increase count by 1 (%zu + "
-                 "1 != %zu).",
-                 count, (size_t)s.count);
-      obj_mem.obj = *FIO_SET_NAME(find)(&s, obj_mem.i, obj_mem.obj);
-      FIO_ASSERT(obj_mem.i == 1,
-                 "Re-adding a removed item should update the item (%p != 1)!",
-                 (void *)FIO_SET_NAME(find)(&s, obj_mem.i, obj_mem.obj));
-      FIO_SET_NAME(remove)(&s, obj_mem.i, obj_mem.obj);
-      FIO_ASSERT(count == s.count,
+      fio_set_test_overwrite(&s, tmp, tmp);
+      FIO_ASSERT(
+          count + 1 == s.count,
+          "Re-adding a removed item in set should increase count by 1 (%zu + "
+          "1 != %zu).",
+          count, (size_t)s.count);
+      count = h.count;
+      fio_hash_test_insert(&h, tmp, tmp, tmp);
+      FIO_ASSERT(
+          count + 1 == h.count,
+          "Re-adding a removed item in hash should increase count by 1 (%zu + "
+          "1 != %zu).",
+          count, (size_t)s.count);
+      tmp = *fio_set_test_find(&s, tmp, tmp);
+      FIO_ASSERT(tmp == 1,
+                 "Re-adding a removed item should update the item in the set "
+                 "(%lu != 1)!",
+                 (unsigned long)*fio_set_test_find(&s, tmp, tmp));
+      fio_set_test_remove(&s, tmp, tmp);
+      fio_hash_test_remove(&h, tmp, tmp);
+      FIO_ASSERT(count == h.count,
                  "Re-removing an item should decrease count (%zu != %zu).",
                  count, (size_t)s.count);
-      FIO_ASSERT(!FIO_SET_NAME(find)(&s, obj_mem.i, obj_mem.obj),
+      FIO_ASSERT(!fio_set_test_find(&s, tmp, tmp),
                  "Re-removing a re-added item should update the item!");
     }
   }
   fprintf(stderr, "* Compacting HashMap to %lu\n", FIO_SET_TEXT_COUNT >> 1);
-  FIO_SET_NAME(compact)(&s);
+  fio_set_test_compact(&s);
   {
     fprintf(stderr, "* Testing that %lu items are continuous\n",
             FIO_SET_TEXT_COUNT >> 1);
@@ -8465,11 +8573,12 @@ FIO_FUNC void fio_set_test(void) {
     FIO_ASSERT(i == s.count, "count error (%lu != %lu).", i, s.count);
   }
 
-  FIO_SET_NAME(free)(&s);
+  fio_set_test_free(&s);
+  fio_hash_test_free(&h);
   FIO_ASSERT(!s.map && !s.ordered && !s.pos && !s.capa,
              "HashMap not re-initialized after free.");
 
-  FIO_SET_NAME(capa_require)(&s, FIO_SET_TEXT_COUNT);
+  fio_set_test_capa_require(&s, FIO_SET_TEXT_COUNT);
 
   FIO_ASSERT(
       s.map && s.ordered && !s.pos && s.capa >= FIO_SET_TEXT_COUNT,
@@ -8477,16 +8586,15 @@ FIO_FUNC void fio_set_test(void) {
       (void *)s.map, (void *)s.ordered, s.pos, s.capa, FIO_SET_TEXT_COUNT);
 
   for (unsigned long i = 1; i < FIO_SET_TEXT_COUNT; ++i) {
-    obj_mem.i = i;
-    FIO_SET_NAME(insert)(&s, obj_mem.i, obj_mem.obj);
-    FIO_ASSERT(FIO_SET_NAME(find)(&s, obj_mem.i, obj_mem.obj),
+    fio_set_test_insert(&s, i, i);
+    FIO_ASSERT(fio_set_test_find(&s, i, i),
                "find failed after insert (2nd round)");
-    obj_mem.obj = *FIO_SET_NAME(find)(&s, obj_mem.i, obj_mem.obj);
-    FIO_ASSERT(i == obj_mem.i, "insertion (2nd round) != find");
+    FIO_ASSERT(i == *fio_set_test_find(&s, i, i),
+               "insertion (2nd round) != find");
     FIO_ASSERT(i == s.count, "count error (%lu != %lu) post insertion.", i,
                s.count);
   }
-  FIO_SET_NAME(free)(&s);
+  fio_set_test_free(&s);
 }
 #undef FIO_SET_NAME
 
@@ -8561,14 +8669,14 @@ SHA-1 tests
 static void fio_sha1_speed_test(void) {
   /* test based on code from BearSSL with credit to Thomas Pornin */
   uint8_t buffer[8192];
-  uint8_t result[65];
+  uint8_t result[21];
   fio_sha1_s sha1;
   memset(buffer, 'T', sizeof(buffer));
   /* warmup */
   for (size_t i = 0; i < 4; i++) {
     sha1 = fio_sha1_init();
     fio_sha1_write(&sha1, buffer, sizeof(buffer));
-    memcpy(result, fio_sha1_result(&sha1), 65);
+    memcpy(result, fio_sha1_result(&sha1), 21);
   }
   /* loop until test runs for more than 2 seconds */
   for (size_t cycles = 8192;;) {
@@ -8595,7 +8703,7 @@ static void fio_sha1_speed_test(void) {
 static void fio_sha1_open_ssl_speed_test(void) {
   /* test based on code from BearSSL with credit to Thomas Pornin */
   uint8_t buffer[8192];
-  uint8_t result[65];
+  uint8_t result[21];
   SHA_CTX o_sh1;
   memset(buffer, 'T', sizeof(buffer));
   /* warmup */
@@ -8993,8 +9101,7 @@ void fio_base64_test(void) {
       {"foob", "Zm9vYg=="},
       {"fooba", "Zm9vYmE="},
       {"foobar", "Zm9vYmFy"},
-      { NULL,
-        NULL } // Stop
+      {NULL, NULL} // Stop
   };
   int i = 0;
   char buffer[1024];