iodine 0.6.5 → 0.7.0

data/ext/iodine/iodine_caller.h

@@ -3,6 +3,8 @@
 
 #include "ruby.h"
 
+#include <stdint.h>
+
 extern struct IodineCaller_s {
   /** Calls a C function within the GVL (unprotected). */
   void *(*enterGVL)(void *(*func)(void *), void *arg);

data/ext/iodine/iodine_connection.c

@@ -1,13 +1,12 @@
 #include "iodine_connection.h"
 
-#include "facil.h"
-#include "fio_mem.h"
+#define FIO_INCLUDE_LINKED_LIST
+#define FIO_INCLUDE_STR
+#include "fio.h"
+
 #include "fiobj4sock.h"
-#include "pubsub.h"
 #include "websockets.h"
 
-#include "spnlock.inc"
-
 #include <ruby/io.h>
 
 /* *****************************************************************************
@@ -41,41 +40,32 @@ static VALUE RAWSymbol;
 Pub/Sub storage
 ***************************************************************************** */
 
-#define FIO_HASH_KEY_TYPE FIOBJ
-#define FIO_HASH_KEY_INVALID FIOBJ_INVALID
-#define FIO_HASH_KEY2UINT(key) fiobj_obj2hash((key))
-#define FIO_HASH_COMPARE_KEYS(k1, k2) (fiobj_iseq((k1), (k2)))
-#define FIO_HASH_KEY_ISINVALID(key) ((key) == FIOBJ_INVALID)
-#define FIO_HASH_KEY_COPY(key) (fiobj_dup(key))
-#define FIO_HASH_KEY_DESTROY(key) (fiobj_free((key)))
-
-#include "fio_hashmap.h"
-
-static inline VALUE iodine_sub_unsubscribe(fio_hash_s *store, FIOBJ channel) {
-  pubsub_sub_pt sub = fio_hash_insert(store, channel, NULL);
-  if (sub) {
-    pubsub_unsubscribe(sub);
-    return Qtrue;
-  }
-  return Qfalse;
+#define FIO_SET_NAME fio_subhash
+#define FIO_SET_OBJ_TYPE subscription_s *
+#define FIO_SET_KEY_TYPE fio_str_info_s
+#define FIO_SET_KEY_COMPARE(s1, s2)                                            \
+  ((s1).len == (s2).len &&                                                     \
+   ((s1).data == (s2).data || !memcmp((s1).data, (s2).data, (s1).len)))
+#define FIO_SET_OBJ_DESTROY(obj) fio_unsubscribe((obj))
+#include <fio.h> // creates the fio_str_set_s Set and functions
+
+static inline VALUE iodine_sub_unsubscribe(fio_subhash_s *store,
+                                           fio_str_info_s channel) {
+  if (fio_subhash_remove(store, fio_siphash(channel.data, channel.len),
+                         channel))
+    return Qfalse;
+  return Qtrue;
 }
-static inline void iodine_sub_add(fio_hash_s *store, pubsub_sub_pt sub) {
-  FIOBJ channel = pubsub_sub_channel(sub); /* used for memory optimization */
-  sub = fio_hash_insert(store, channel, sub);
-  if (sub) {
-    pubsub_unsubscribe(sub);
-  }
+static inline void iodine_sub_add(fio_subhash_s *store, subscription_s *sub) {
+  fio_str_info_s ch = fio_subscription_channel(sub);
+  fio_subhash_insert(store, fio_siphash(ch.data, ch.len), ch, sub);
 }
-static inline void iodine_sub_clear_all(fio_hash_s *store) {
-  FIO_HASH_FOR_FREE(store, pos) {
-    if (pos->obj) {
-      pubsub_unsubscribe(pos->obj);
-    }
-  }
+static inline void iodine_sub_clear_all(fio_subhash_s *store) {
+  fio_subhash_free(store);
 }
 
-static spn_lock_i sub_lock = SPN_LOCK_INIT;
-static fio_hash_s sub_global = FIO_HASH_INIT;
+static fio_lock_i sub_lock = FIO_LOCK_INIT;
+static fio_subhash_s sub_global = FIO_SET_INIT;
 
 /* *****************************************************************************
 C <=> Ruby Data allocation
@@ -84,8 +74,8 @@ C <=> Ruby Data allocation
 typedef struct {
   iodine_connection_s info;
   size_t ref;
-  fio_hash_s subscriptions;
-  spn_lock_i lock;
+  fio_subhash_s subscriptions;
+  fio_lock_i lock;
   uint8_t answers_on_message;
   uint8_t answers_on_drained;
   uint8_t answers_ping;
@@ -113,7 +103,7 @@ static void iodine_connection_data_mark(void *c_) {
 /* a callback for the GC (freeing inactive objects) */
 static void iodine_connection_data_free(void *c_) {
   iodine_connection_data_s *data = c_;
-  if (spn_sub(&data->ref, 1))
+  if (fio_atomic_sub(&data->ref, 1))
     return;
   free(data);
 }
@@ -142,8 +132,8 @@ static VALUE iodine_connection_data_alloc_c(VALUE self) {
       .info.handler = (VALUE)0,
       .info.uuid = -1,
       .ref = 1,
-      .subscriptions = FIO_HASH_INIT,
-      .lock = SPN_LOCK_INIT,
+      .subscriptions = FIO_SET_INIT,
+      .lock = FIO_LOCK_INIT,
   };
   return TypedData_Wrap_Struct(self, &iodine_connection_data_type, c);
 }
@@ -179,7 +169,7 @@ Ruby Connection Methods - write, close open? pending
  */
 static VALUE iodine_connection_write(VALUE self, VALUE data) {
   iodine_connection_data_s *c = iodine_connection_validate_data(self);
-  if (!c || sock_isclosed(c->info.uuid)) {
+  if (!c || fio_is_closed(c->info.uuid)) {
     // don't throw exceptions - closed connections are unavoidable.
     return Qnil;
     // rb_raise(rb_eIOError, "Connection closed or invalid.");
@@ -187,15 +177,14 @@ static VALUE iodine_connection_write(VALUE self, VALUE data) {
   switch (c->info.type) {
   case IODINE_CONNECTION_WEBSOCKET:
     /* WebSockets*/
-    websocket_write(c->info.arg, RSTRING_PTR(data), RSTRING_LEN(data),
+    websocket_write(c->info.arg, IODINE_RSTRINFO(data),
                     rb_enc_get(data) == IodineUTF8Encoding);
     return Qtrue;
     break;
   case IODINE_CONNECTION_SSE:
 /* SSE */
 #if 1
-    http_sse_write(c->info.arg, .data = {.data = RSTRING_PTR(data),
-                                         .len = RSTRING_LEN(data)});
+    http_sse_write(c->info.arg, .data = IODINE_RSTRINFO(data));
     return Qtrue;
 #else
     if (rb_enc_get(data) == IodineUTF8Encoding) {
@@ -212,14 +201,7 @@ static VALUE iodine_connection_write(VALUE self, VALUE data) {
     break;
   case IODINE_CONNECTION_RAW: /* fallthrough */
   default: {
-    size_t len = RSTRING_LEN(data);
-    char *copy = fio_malloc(len);
-    if (!copy) {
-      rb_raise(rb_eNoMemError, "failed to allocate memory for network buffer!");
-    }
-    memcpy(copy, RSTRING_PTR(data), len);
-    sock_write2(.uuid = c->info.uuid, .buffer = copy, .length = len,
-                .dealloc = fio_free);
+    fio_write(c->info.uuid, RSTRING_PTR(data), RSTRING_LEN(data));
     return Qtrue;
   } break;
   }
@@ -234,11 +216,11 @@ static VALUE iodine_connection_write(VALUE self, VALUE data) {
  */
 static VALUE iodine_connection_close(VALUE self) {
   iodine_connection_data_s *c = iodine_connection_validate_data(self);
-  if (c && !sock_isclosed(c->info.uuid)) {
+  if (c && !fio_is_closed(c->info.uuid)) {
     if (c->info.type == IODINE_CONNECTION_WEBSOCKET) {
       websocket_close(c->info.arg); /* sends WebSocket close packet */
     } else {
-      sock_close(c->info.uuid);
+      fio_close(c->info.uuid);
     }
   }
 
@@ -247,7 +229,7 @@ static VALUE iodine_connection_close(VALUE self) {
 /** Returns true if the connection appears to be open (no known issues). */
 static VALUE iodine_connection_is_open(VALUE self) {
   iodine_connection_data_s *c = iodine_connection_validate_data(self);
-  if (c && !sock_isclosed(c->info.uuid)) {
+  if (c && !fio_is_closed(c->info.uuid)) {
     return Qtrue;
   }
   return Qfalse;
@@ -261,10 +243,10 @@ static VALUE iodine_connection_is_open(VALUE self) {
  */
 static VALUE iodine_connection_pending(VALUE self) {
   iodine_connection_data_s *c = iodine_connection_validate_data(self);
-  if (!c || sock_isclosed(c->info.uuid)) {
+  if (!c || fio_is_closed(c->info.uuid)) {
     return INT2NUM(-1);
   }
-  return SIZET2NUM((sock_pending(c->info.uuid)));
+  return SIZET2NUM((fio_pending(c->info.uuid)));
 }
 
 /** Returns the connection's protocol Symbol (`:sse`, `:websocket`, etc'). */
@@ -293,8 +275,8 @@ static VALUE iodine_connection_protocol_name(VALUE self) {
  */
 static VALUE iodine_connection_timeout_get(VALUE self) {
   iodine_connection_data_s *c = iodine_connection_validate_data(self);
-  if (c && !sock_isclosed(c->info.uuid)) {
-    size_t tout = (size_t)facil_get_timeout(c->info.uuid);
+  if (c && !fio_is_closed(c->info.uuid)) {
+    size_t tout = (size_t)fio_timeout_get(c->info.uuid);
     return SIZET2NUM(tout);
   }
   return Qnil;
@@ -313,8 +295,8 @@ static VALUE iodine_connection_timeout_set(VALUE self, VALUE timeout) {
     return Qnil;
   }
   iodine_connection_data_s *c = iodine_connection_validate_data(self);
-  if (c && !sock_isclosed(c->info.uuid)) {
-    facil_set_timeout(c->info.uuid, (uint8_t)tout);
+  if (c && !fio_is_closed(c->info.uuid)) {
+    fio_timeout_set(c->info.uuid, (uint8_t)tout);
     return timeout;
   }
   return Qnil;
@@ -337,38 +319,34 @@ Pub/Sub Callbacks (internal implementation)
 
 /* calls the Ruby block assigned to a pubsub event (within the GVL). */
 static void *iodine_on_pubsub_call_block(void *msg_) {
-  pubsub_message_s *msg = msg_;
-  fio_cstr_s tmp;
+  fio_msg_s *msg = msg_;
   VALUE args[2];
-  tmp = fiobj_obj2cstr(msg->channel);
-  args[0] = rb_str_new(tmp.data, tmp.len);
-  tmp = fiobj_obj2cstr(msg->message);
-  args[1] = rb_str_new(tmp.data, tmp.len);
+  args[0] = rb_str_new(msg->channel.data, msg->channel.len);
+  args[1] = rb_str_new(msg->msg.data, msg->msg.len);
   IodineCaller.call2((VALUE)msg->udata2, call_id, 2, args);
   return NULL;
 }
 
 /* callback for incoming subscription messages */
-static void iodine_on_pubsub(pubsub_message_s *msg) {
+static void iodine_on_pubsub(fio_msg_s *msg) {
   iodine_connection_data_s *data = msg->udata1;
   VALUE block = (VALUE)msg->udata2;
   switch (block) {
   case Qnil: /* fallthrough */
   case Qtrue: {
     if (data->info.handler == Qnil || data->info.uuid == -1 ||
-        sock_isclosed(data->info.uuid))
+        fio_is_closed(data->info.uuid))
       return;
     switch (data->info.type) {
     case IODINE_CONNECTION_WEBSOCKET: {
-      fio_cstr_s str = fiobj_obj2cstr(msg->message);
-      websocket_write(data->info.arg, str.data, str.len, (block == Qnil));
+      websocket_write(data->info.arg, msg->msg, (block == Qnil));
       return;
     }
     case IODINE_CONNECTION_SSE:
-      http_sse_write(data->info.arg, .data = fiobj_obj2cstr(msg->message));
+      http_sse_write(data->info.arg, .data = msg->msg);
       return;
     default:
-      fiobj_send_free(data->info.uuid, fiobj_dup(msg->message));
+      fio_write(data->info.uuid, msg->msg.data, msg->msg.len);
       return;
     }
   }
@@ -402,8 +380,8 @@ Ruby Connection Methods - Pub/Sub
 typedef struct {
   VALUE channel;
   VALUE block;
+  fio_match_fn pattern;
   uint8_t binary;
-  uint8_t pattern;
 } iodine_sub_args_s;
 
 /** Tests the `subscribe` Ruby arguments */
@@ -454,7 +432,7 @@ static iodine_sub_args_s iodine_subscribe_args(int argc, VALUE *argv) {
       ret.binary = 1;
     }
     if (rb_hash_aref(rb_opt, match_id) == redis_id) {
-      ret.pattern = 1;
+      ret.pattern = FIO_MATCH_GLOB;
     }
     ret.block = rb_hash_aref(rb_opt, handler_id);
     if (ret.block != Qnil) {
@@ -527,31 +505,28 @@ static VALUE iodine_pubsub_subscribe(int argc, VALUE *argv, VALUE self) {
     if (args.block == Qnil && args.binary) {
       args.block = Qtrue;
     }
-    spn_add(&c->ref, 1);
+    fio_atomic_add(&c->ref, 1);
   }
 
-  FIOBJ channel =
-      fiobj_str_new(RSTRING_PTR(args.channel), RSTRING_LEN(args.channel));
-  pubsub_sub_pt sub =
-      pubsub_subscribe(.channel = channel, .on_message = iodine_on_pubsub,
-                       .on_unsubscribe = iodine_on_unsubscribe, .udata1 = c,
-                       .udata2 = (void *)args.block,
-                       .use_pattern = args.pattern);
-  fiobj_free(channel);
+  subscription_s *sub =
+      fio_subscribe(.channel = IODINE_RSTRINFO(args.channel),
+                    .on_message = iodine_on_pubsub,
+                    .on_unsubscribe = iodine_on_unsubscribe, .udata1 = c,
+                    .udata2 = (void *)args.block, .match = args.pattern);
   if (c) {
-    spn_lock(&c->lock);
+    fio_lock(&c->lock);
     if (c->info.uuid == -1) {
-      pubsub_unsubscribe(sub);
-      spn_unlock(&c->lock);
+      fio_unsubscribe(sub);
+      fio_unlock(&c->lock);
       return Qnil;
     } else {
       iodine_sub_add(&c->subscriptions, sub);
     }
-    spn_unlock(&c->lock);
+    fio_unlock(&c->lock);
   } else {
-    spn_lock(&sub_lock);
+    fio_lock(&sub_lock);
     iodine_sub_add(&sub_global, sub);
-    spn_unlock(&sub_lock);
+    fio_unlock(&sub_lock);
   }
   return args.channel;
 }
@@ -572,22 +547,20 @@ Returns `false` if the subscription didn't exist.
 static VALUE iodine_pubsub_unsubscribe(VALUE self, VALUE name) {
   // clang-format on
   iodine_connection_data_s *c = NULL;
-  FIOBJ channel = fiobj_str_new(RSTRING_PTR(name), RSTRING_LEN(name));
   VALUE ret;
   if (TYPE(self) == T_MODULE) {
-    spn_lock(&sub_lock);
-    ret = iodine_sub_unsubscribe(&sub_global, channel);
-    spn_unlock(&sub_lock);
+    fio_lock(&sub_lock);
+    ret = iodine_sub_unsubscribe(&sub_global, IODINE_RSTRINFO(name));
+    fio_unlock(&sub_lock);
   } else {
     c = iodine_connection_validate_data(self);
     if (!c) {
-      return Qnil; /* cannot subscribe a closed connection. */
+      return Qnil; /* cannot unsubscribe a closed connection. */
     }
-    spn_lock(&sub_lock);
-    ret = iodine_sub_unsubscribe(&sub_global, channel);
-    spn_unlock(&sub_lock);
+    fio_lock(&sub_lock);
+    ret = iodine_sub_unsubscribe(&sub_global, IODINE_RSTRINFO(name));
+    fio_unlock(&sub_lock);
   }
-  fiobj_free(channel);
   return ret;
 }
 
@@ -616,7 +589,7 @@ Alternatively, accepts the following named arguments:
 static VALUE iodine_pubsub_publish(int argc, VALUE *argv, VALUE self) {
   // clang-format on
   VALUE rb_ch, rb_msg, rb_engine = Qnil;
-  const pubsub_engine_s *engine = NULL;
+  const fio_pubsub_engine_s *engine = NULL;
   switch (argc) {
   case 3:
     /* fallthrough */
@@ -651,7 +624,7 @@ static VALUE iodine_pubsub_publish(int argc, VALUE *argv, VALUE self) {
   Check_Type(rb_ch, T_STRING);
 
   if (rb_engine == Qfalse) {
-    engine = PUBSUB_PROCESS_ENGINE;
+    engine = FIO_PUBSUB_PROCESS;
   } else if (rb_engine != Qnil) {
     // collect engine object
     iodine_pubsub_s *e = iodine_pubsub_CData(rb_engine);
@@ -660,15 +633,8 @@ static VALUE iodine_pubsub_publish(int argc, VALUE *argv, VALUE self) {
     }
   }
 
-  FIOBJ ch = fiobj_str_new(RSTRING_PTR(rb_ch), RSTRING_LEN(rb_ch));
-  FIOBJ msg = fiobj_str_new(RSTRING_PTR(rb_msg), RSTRING_LEN(rb_msg));
-
-  intptr_t ret =
-      pubsub_publish(.engine = engine, .channel = ch, .message = msg);
-  fiobj_free(ch);
-  fiobj_free(msg);
-  if (!ret)
-    return Qfalse;
+  fio_publish(.engine = engine, .channel = IODINE_RSTRINFO(rb_ch),
+              .message = IODINE_RSTRINFO(rb_msg));
   return Qtrue;
   (void)self;
 }
@@ -693,7 +659,7 @@ VALUE iodine_connection_new(iodine_connection_s args) {
   }
   *data = (iodine_connection_data_s){
       .info = args,
-      .subscriptions = FIO_HASH_INIT,
+      .subscriptions = FIO_SET_INIT,
       .ref = 1,
       .answers_on_open = (rb_respond_to(args.handler, on_open_id) != 0),
       .answers_on_message = (rb_respond_to(args.handler, on_message_id) != 0),
@@ -701,7 +667,7 @@ VALUE iodine_connection_new(iodine_connection_s args) {
       .answers_on_drained = (rb_respond_to(args.handler, on_drained_id) != 0),
       .answers_on_shutdown = (rb_respond_to(args.handler, on_shutdown_id) != 0),
       .answers_on_close = (rb_respond_to(args.handler, on_close_id) != 0),
-      .lock = SPN_LOCK_INIT,
+      .lock = FIO_LOCK_INIT,
   };
   return connection;
 }
@@ -756,13 +722,13 @@ void iodine_connection_fire_event(VALUE connection,
     if (data->answers_on_close) {
       IodineCaller.call2(data->info.handler, on_close_id, 1, args);
     }
-    spn_lock(&data->lock);
+    fio_lock(&data->lock);
     data->info.handler = Qnil;
     data->info.env = Qnil;
     data->info.uuid = -1;
     data->info.arg = NULL;
     iodine_sub_clear_all(&data->subscriptions);
-    spn_unlock(&data->lock);
+    fio_unlock(&data->lock);
     IodineStore.remove(connection);
     break;
   default:
@@ -821,8 +787,7 @@ void iodine_connection_init(void) {
   IodineStore.add(RAWSymbol);
 
   // define the Connection Class and it's methods
-  ConnectionKlass =
-      rb_define_class_under(IodineModule, "Connection", rb_cObject);
+  ConnectionKlass = rb_define_class_under(IodineModule, "Connection", rb_cData);
   rb_define_alloc_func(ConnectionKlass, iodine_connection_data_alloc_c);
   rb_define_method(ConnectionKlass, "write", iodine_connection_write, 1);
   rb_define_method(ConnectionKlass, "close", iodine_connection_close, 0);

data/ext/iodine/iodine_defer.c

@@ -5,8 +5,8 @@
 #include <stdint.h>
 // clang-format on
 
-#include "facil.h"
-#include <spnlock.inc>
+#define FIO_INCLUDE_LINKED_LIST
+#include "fio.h"
 
 #include <pthread.h>
 
@@ -14,7 +14,7 @@
 IO flushing dedicated thread for protection against blocking code
 ***************************************************************************** */
 
-static spn_lock_i sock_io_thread = 0;
+static fio_lock_i sock_io_thread = 0;
 static pthread_t sock_io_pthread;
 typedef struct {
   size_t threads;
@@ -23,26 +23,29 @@ typedef struct {
 
 static void *iodine_io_thread(void *arg) {
   (void)arg;
-  struct timespec tm;
   while (sock_io_thread) {
-    sock_flush_all();
-    tm = (struct timespec){.tv_nsec = 0, .tv_sec = 1};
-    nanosleep(&tm, NULL);
+    fio_flush_all();
+    fio_throttle_thread(100);
   }
   return NULL;
 }
-static void iodine_start_io_thread(void *a_, void *b_) {
-  if (!spn_trylock(&sock_io_thread)) {
+static void iodine_start_io_thread(void *a_) {
+  if (!fio_atomic_add(&sock_io_thread, 1)) {
     pthread_create(&sock_io_pthread, NULL, iodine_io_thread, NULL);
   }
   (void)a_;
+}
+
+static void iodine_start_io_thread2(void *a_, void *b_) {
+  iodine_start_io_thread(a_);
   (void)b_;
 }
+
 static void iodine_join_io_thread(void) {
-  if (spn_unlock(&sock_io_thread)) {
+  if (fio_atomic_sub(&sock_io_thread, 1) == 0) {
     sock_io_thread = 0;
     pthread_join(sock_io_pthread, NULL);
-    sock_io_pthread = NULL;
+    sock_io_pthread = (pthread_t)NULL;
   }
 }
 
@@ -54,11 +57,14 @@ The Defer library overriding functions
 struct CreateThreadArgs {
   void *(*thread_func)(void *);
   void *arg;
-  spn_lock_i lock;
+  fio_lock_i lock;
 };
 
 /* used for GVL signalling */
-void call_async_signal(void *pool) { defer_pool_stop((pool_pt)pool); }
+void call_async_signal(void *pool) {
+  fio_stop();
+  (void)pool;
+}
 
 static void *defer_thread_start(void *args_) {
   struct CreateThreadArgs *args = args_;
@@ -72,7 +78,7 @@ static VALUE defer_thread_inGVL(void *args_) {
   struct CreateThreadArgs *old_args = args_;
   struct CreateThreadArgs args = *old_args;
   IodineCaller.set_GVL(1);
-  spn_unlock(&old_args->lock);
+  fio_unlock(&old_args->lock);
   rb_thread_call_without_gvl(defer_thread_start, &args,
                              (void (*)(void *))call_async_signal, args.arg);
   return Qnil;
@@ -108,7 +114,7 @@ static void *fork_using_ruby(void *ignr) {
   }
   iodine_perform_fork_callbacks(0);
   // re-initiate IO thread
-  defer(iodine_start_io_thread, NULL, NULL);
+  fio_defer(iodine_start_io_thread2, NULL, NULL);
   return (void *)pid;
   (void)ignr;
 }
@@ -116,17 +122,19 @@ static void *fork_using_ruby(void *ignr) {
 /**
 OVERRIDE THIS to replace the default pthread implementation.
 */
-void *defer_new_thread(void *(*thread_func)(void *), void *arg) {
+void *fio_thread_new(void *(*thread_func)(void *), void *arg) {
   struct CreateThreadArgs data = (struct CreateThreadArgs){
-      .thread_func = thread_func, .arg = arg, .lock = SPN_LOCK_INIT,
+      .thread_func = thread_func,
+      .arg = arg,
+      .lock = FIO_LOCK_INIT,
   };
-  spn_lock(&data.lock);
+  fio_lock(&data.lock);
   void *thr = IodineCaller.enterGVL(create_ruby_thread_gvl, &data);
   if (!thr || thr == (void *)Qnil || thr == (void *)Qfalse) {
     thr = NULL;
   } else {
     /* wait for thread to signal it's alive. */
-    spn_lock(&data.lock);
+    fio_lock(&data.lock);
   }
   return thr;
 }
@@ -134,7 +142,7 @@ void *defer_new_thread(void *(*thread_func)(void *), void *arg) {
 /**
 OVERRIDE THIS to replace the default pthread implementation.
 */
-int defer_join_thread(void *thr) {
+int fio_thread_join(void *thr) {
   if (!thr || (VALUE)thr == Qfalse || (VALUE)thr == Qnil)
     return -1;
   IodineCaller.call((VALUE)thr, rb_intern("join"));
@@ -143,7 +151,7 @@ int defer_join_thread(void *thr) {
 }
 
 // void defer_free_thread(void *thr) { (void)thr; }
-void defer_free_thread(void *thr) { IodineStore.remove((VALUE)thr); }
+void fio_thread_free(void *thr) { IodineStore.remove((VALUE)thr); }
 
 /**
 OVERRIDE THIS to replace the default `fork` implementation or to inject hooks
@@ -151,7 +159,7 @@ into the forking function.
 
 Behaves like the system's `fork`.
 */
-int facil_fork(void) {
+int fio_fork(void) {
   intptr_t pid = (intptr_t)IodineCaller.enterGVL(fork_using_ruby, NULL);
   return (int)pid;
 }
@@ -189,7 +197,7 @@ Defer API
 static VALUE iodine_defer_run(VALUE self) {
   rb_need_block();
   VALUE block = IodineStore.add(rb_block_proc());
-  defer(iodine_defer_performe_once, (void *)block, NULL);
+  fio_defer(iodine_defer_performe_once, (void *)block, NULL);
   return block;
   (void)self;
 }
@@ -221,8 +229,8 @@ static VALUE iodine_defer_run_after(VALUE self, VALUE milliseconds) {
   if (block == Qnil)
     return Qfalse;
   IodineStore.add(block);
-  if (facil_run_every(milli, 1, iodine_defer_run_timer, (void *)block,
-                      (void (*)(void *))IodineStore.remove) == -1) {
+  if (fio_run_every(milli, 1, iodine_defer_run_timer, (void *)block,
+                    (void (*)(void *))IodineStore.remove) == -1) {
     perror("ERROR: Iodine couldn't initialize timer");
     return Qnil;
   }
@@ -265,8 +273,8 @@ static VALUE iodine_defer_run_every(int argc, VALUE *argv, VALUE self) {
   // requires a block to be passed
   rb_need_block();
   IodineStore.add(block);
-  if (facil_run_every(milli, repeat, iodine_defer_run_timer, (void *)block,
-                      (void (*)(void *))IodineStore.remove) == -1) {
+  if (fio_run_every(milli, repeat, iodine_defer_run_timer, (void *)block,
+                    (void (*)(void *))IodineStore.remove) == -1) {
     perror("ERROR: Iodine couldn't initialize timer");
     return Qnil;
   }
@@ -276,14 +284,12 @@ static VALUE iodine_defer_run_every(int argc, VALUE *argv, VALUE self) {
 /* *****************************************************************************
 Pre/Post `fork`
 ***************************************************************************** */
-#include "fio_llist.h"
-#include "spnlock.inc"
 
-static spn_lock_i iodine_before_fork_lock = SPN_LOCK_INIT;
+static fio_lock_i iodine_before_fork_lock = FIO_LOCK_INIT;
 static fio_ls_s iodine_before_fork_list = FIO_LS_INIT(iodine_before_fork_list);
-static spn_lock_i iodine_after_fork_lock = SPN_LOCK_INIT;
+static fio_lock_i iodine_after_fork_lock = FIO_LOCK_INIT;
 static fio_ls_s iodine_after_fork_list = FIO_LS_INIT(iodine_after_fork_list);
-static spn_lock_i iodine_on_shutdown_lock = SPN_LOCK_INIT;
+static fio_lock_i iodine_on_shutdown_lock = FIO_LOCK_INIT;
 static fio_ls_s iodine_on_shutdown_list = FIO_LS_INIT(iodine_on_shutdown_list);
 
 /**
@@ -294,9 +300,9 @@ VALUE iodine_before_fork_add(VALUE self) {
   rb_need_block();
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  spn_lock(&iodine_before_fork_lock);
+  fio_lock(&iodine_before_fork_lock);
   fio_ls_push(&iodine_before_fork_list, (void *)block);
-  spn_unlock(&iodine_before_fork_lock);
+  fio_unlock(&iodine_before_fork_lock);
   return block;
   (void)self;
 }
@@ -309,9 +315,9 @@ VALUE iodine_after_fork_add(VALUE self) {
   rb_need_block();
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  spn_lock(&iodine_after_fork_lock);
+  fio_lock(&iodine_after_fork_lock);
   fio_ls_push(&iodine_after_fork_list, (void *)block);
-  spn_unlock(&iodine_after_fork_lock);
+  fio_unlock(&iodine_after_fork_lock);
   return block;
   (void)self;
 }
@@ -325,9 +331,9 @@ VALUE iodine_on_shutdown_add(VALUE self) {
   rb_need_block();
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  spn_lock(&iodine_on_shutdown_lock);
+  fio_lock(&iodine_on_shutdown_lock);
   fio_ls_push(&iodine_on_shutdown_list, (void *)block);
-  spn_unlock(&iodine_on_shutdown_lock);
+  fio_unlock(&iodine_on_shutdown_lock);
   return block;
   (void)self;
 }
@@ -335,37 +341,37 @@ VALUE iodine_on_shutdown_add(VALUE self) {
 /* Runs the before / after fork callbacks (if `before` is true, before runs) */
 static void iodine_perform_fork_callbacks(uint8_t before) {
   fio_ls_s *ls = before ? &iodine_before_fork_list : &iodine_after_fork_list;
-  spn_lock_i *lock =
+  fio_lock_i *lock =
       before ? &iodine_before_fork_lock : &iodine_after_fork_lock;
-  spn_lock(lock);
+  fio_lock(lock);
   FIO_LS_FOR(ls, pos) { IodineCaller.call((VALUE)(pos->obj), call_id); }
-  spn_unlock(lock);
+  fio_unlock(lock);
 }
 
 /* Performs any cleanup before worker dies */
-void iodine_defer_on_finish(void) {
+static void iodine_defer_on_finish(void *ignr) {
+  (void)ignr;
   iodine_join_io_thread();
   /* perform and clear away shutdown Procs */
-  spn_lock(&iodine_on_shutdown_lock);
+  fio_lock(&iodine_on_shutdown_lock);
   while (fio_ls_any(&iodine_on_shutdown_list)) {
     void *obj = fio_ls_shift(&iodine_on_shutdown_list);
     IodineCaller.call((VALUE)(obj), call_id);
     IodineStore.remove((VALUE)(obj));
   }
-  spn_unlock(&iodine_on_shutdown_lock);
+  fio_unlock(&iodine_on_shutdown_lock);
   /* clear away forking Procs */
-  spn_lock(&iodine_before_fork_lock);
+  fio_lock(&iodine_before_fork_lock);
   while (fio_ls_any(&iodine_before_fork_list)) {
     IodineStore.remove((VALUE)fio_ls_shift(&iodine_before_fork_list));
   }
-  spn_unlock(&iodine_before_fork_lock);
+  fio_unlock(&iodine_before_fork_lock);
 
-  spn_lock(&iodine_after_fork_lock);
+  fio_lock(&iodine_after_fork_lock);
   while (fio_ls_any(&iodine_after_fork_list)) {
     IodineStore.remove((VALUE)fio_ls_shift(&iodine_after_fork_list));
-    void *obj = fio_ls_shift(&iodine_after_fork_list);
   }
-  spn_unlock(&iodine_after_fork_lock);
+  fio_unlock(&iodine_after_fork_lock);
 }
 
 /* *****************************************************************************
@@ -387,5 +393,6 @@ void iodine_defer_initialize(void) {
                             0);
   rb_define_module_function(IodineModule, "on_shutdown", iodine_on_shutdown_add,
                             0);
-  defer(iodine_start_io_thread, NULL, NULL);
+  fio_state_callback_add(FIO_CALL_ON_FINISH, iodine_defer_on_finish, NULL);
+  fio_state_callback_add(FIO_CALL_PRE_START, iodine_start_io_thread, NULL);
 }