iodine 0.3.6 → 0.4.0

data/ext/iodine/pubsub.h

@@ -0,0 +1,215 @@
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_FACIL_PUBSUB_H
+/**
+This pub/sub API is designed to unload pub/sub stress from external messanging
+systems onto the local process.
+
+For example, the NULL pub/sub engine, which is routed to the facil_cluster
+engine, will only publish a single message per process instead of a message per
+client, allowing the cluster communication channel to be less crowded when
+possible.
+
+This should allow pub/sub engines, such as Redis, to spread their workload
+between all of an application's processes, enhancing overall performance.
+*/
+#define H_FACIL_PUBSUB_H
+#include "facil.h"
+
+#ifndef FIO_PUBBSUB_MAX_CHANNEL_LEN
+#define FIO_PUBBSUB_MAX_CHANNEL_LEN 1024
+#endif
+
+/** An opaque pointer used to identify a subscription. */
+typedef struct pubsub_sub_s *pubsub_sub_pt;
+
+/** A pub/sub engine data structure. See details later on. */
+typedef struct pubsub_engine_s pubsub_engine_s;
+
+/** The information a "client" (callback) receives. */
+typedef struct pubsub_message_s {
+  /** The pub/sub engine farwarding this message. */
+  pubsub_engine_s const *engine;
+  /** The pub/sub target channnel. */
+  struct {
+    char *name;
+    uint32_t len;
+  } channel;
+  /** The pub/sub message. */
+  struct {
+    char *data;
+    uint32_t len;
+  } msg;
+  /** indicates that pattern matching was used. */
+  unsigned use_pattern : 1;
+  /** The subscription that prompted the message to be routed to the client. */
+  pubsub_sub_pt subscription;
+  /** Client opaque data pointer (from the `subscribe`) function call. */
+  void *udata1;
+  /** Client opaque data pointer (from the `subscribe`) function call. */
+  void *udata2;
+} pubsub_message_s;
+
+/** The arguments used for `pubsub_subscribe` or `pubsub_find_sub`. */
+struct pubsub_subscribe_args {
+  /** The pub/sub engine to use. NULL defaults to the local cluster engine. */
+  pubsub_engine_s const *engine;
+  /** The channel to subscribe to. */
+  struct {
+    char *name;
+    uint32_t len;
+  } channel;
+  /** The on message callback. the `*msg` pointer is to a temporary object. */
+  void (*on_message)(pubsub_message_s *msg);
+  /** An optional callback for when a subscription is fully canceled. */
+  void (*on_unsubscribe)(void *udata1, void *udata2);
+  /** Opaque user data#1 */
+  void *udata1;
+  /** Opaque user data#2 .. using two allows allocation to be avoided. */
+  void *udata2;
+  /** Use pattern matching for channel subscription. */
+  unsigned use_pattern : 1;
+};
+
+/** The arguments used for `pubsub_publish`. */
+struct pubsub_publish_args {
+  /** The pub/sub engine to use. NULL defaults to the local cluster engine. */
+  pubsub_engine_s const *engine;
+  /** The channel to publish to. */
+  struct {
+    char *name;
+    uint32_t len;
+  } channel;
+  /** The data being pushed. */
+  struct {
+    char *data;
+    uint32_t len;
+  } msg;
+  /** Use pattern matching for channel publication. */
+  unsigned use_pattern : 1;
+  /**
+   * Push the message to the whole cluster, using the cluster engine.
+   * Always TRUE unless an engine was specified.
+   */
+  unsigned push2cluster : 1;
+};
+
+/**
+ * Subscribes to a specific channel.
+ *
+ * Returns a subscription pointer or NULL (failure).
+ */ pubsub_sub_pt pubsub_subscribe(struct pubsub_subscribe_args);
+#define pubsub_subscribe(...)                                                  \
+  pubsub_subscribe((struct pubsub_subscribe_args){__VA_ARGS__})
+
+/**
+ * This helper searches for an existing subscription.
+ *
+ * Use with care, NEVER call `pubsub_unsubscribe` more times than you have
+ * called `pubsub_subscribe`, since the subscription handle memory is realesed
+ * onnce the reference count reaches 0.
+ *
+ * Returns a subscription pointer or NULL (none found).
+ */
+pubsub_sub_pt pubsub_find_sub(struct pubsub_subscribe_args);
+#define pubsub_find_sub(...)                                                   \
+  pubsub_find_sub((struct pubsub_subscribe_args){__VA_ARGS__})
+
+/**
+ * Unsubscribes from a specific channel.
+ *
+ * Returns 0 on success and -1 on failure.
+ */
+void pubsub_unsubscribe(pubsub_sub_pt subscription);
+
+/**
+ * Publishes a message to a channel belonging to a pub/sub service (engine).
+ *
+ * Returns 0 on success and -1 on failure.
+ */
+int pubsub_publish(struct pubsub_publish_args);
+#define pubsub_publish(...)                                                    \
+  pubsub_publish((struct pubsub_publish_args){__VA_ARGS__})
+
+/**
+ * defers message hadling if it can't be performed (i.e., resource is busy) or
+ * should be fragmented (allowing large tasks to be broken down).
+ *
+ * This should only be called from within the `on_message` callback.
+ *
+ * It's recommended that the `on_message` callback return immediately followin
+ * this function call, as code might run concurrently.
+ *
+ * Uses reference counting for zero copy.
+ *
+ * It's impossible to use a different `on_message` callbck without resorting to
+ * memory allocations... so when in need, manage routing withing the
+ * `on_message` callback.
+ */
+void pubsub_defer(pubsub_message_s *msg);
+
+/**
+ * Pub/Sub services (engines) MUST provide the listed function pointers.
+ *
+ * When an engine received a message to publish, they should call the
+ * `pubsub_eng_distribute` function. i.e.:
+ *
+ *       pubsub_engine_distribute(
+ *           .engine = self,
+ *           .channel.name = "channel 1",
+ *           .channel.len = 9,
+ *           .msg.data = "hello",
+ *           .msg.len = 5,
+ *           .push2cluster = self->push2cluster,
+ *           .use_pattern = 0 );
+ *
+ * Engines MUST survive until the pub/sub service is finished using them and
+ * there are no more subscriptions.
+ */
+struct pubsub_engine_s {
+  /** Should return 0 on success and -1 on failure. */
+  int (*subscribe)(const pubsub_engine_s *eng, const char *ch, size_t ch_len,
+                   uint8_t use_pattern);
+  /** Return value is ignored. */
+  void (*unsubscribe)(const pubsub_engine_s *eng, const char *ch, size_t ch_len,
+                      uint8_t use_pattern);
+  /** Should return 0 on success and -1 on failure. */
+  int (*publish)(const pubsub_engine_s *eng, const char *ch, size_t ch_len,
+                 const char *msg, size_t msg_len, uint8_t use_pattern);
+  /** Set to TRUE (1) if published messages should propegate to the cluster. */
+  unsigned push2cluster : 1;
+};
+
+/** The default pub/sub engine. */
+extern const pubsub_engine_s *PUBSUB_CLUSTER_ENGINE;
+
+/** An engine that performs pub/sub only within a single process. */
+extern const pubsub_engine_s *PUBSUB_PROCESS_ENGINE;
+
+/** Allows process wide changes to the default Pub/Sub Engine. */
+extern pubsub_engine_s *PUBSUB_DEFAULT_ENGINE;
+
+/**
+ * The function used by engines to distribute received messages.
+ * The `udata*` and `subscription` fields are ignored.
+ */
+void pubsub_engine_distribute(pubsub_message_s msg);
+#define pubsub_engine_distribute(...)                                          \
+  pubsub_engine_distribute((pubsub_message_s){__VA_ARGS__})
+
+/**
+ * Engines can ask facil.io to resubscribe to all active channels.
+ *
+ * This allows engines that lost their connection to their Pub/Sub service to
+ * resubscribe all the currently active channels with the new connection.
+ *
+ * CAUTION: This is an evented task... try not to free the engine's memory while
+ * resubscriptions are under way...
+ */
+void pubsub_engine_resubscribe(pubsub_engine_s *eng);
+
+#endif /* H_FACIL_PUBSUB_H */

data/ext/iodine/random.c

@@ -173,10 +173,10 @@ static void init_rand_fd(void) {
     return ret;                                                                \
   }
 /* rand functions */
-MAKE_RAND_FUNC(uint32_t, bscrypt_rand32);
-MAKE_RAND_FUNC(uint64_t, bscrypt_rand64);
-MAKE_RAND_FUNC(bits128_u, bscrypt_rand128);
-MAKE_RAND_FUNC(bits256_u, bscrypt_rand256);
+MAKE_RAND_FUNC(uint32_t, bscrypt_rand32)
+MAKE_RAND_FUNC(uint64_t, bscrypt_rand64)
+MAKE_RAND_FUNC(bits128_u, bscrypt_rand128)
+MAKE_RAND_FUNC(bits256_u, bscrypt_rand256)
 /* clear template */
 #undef MAKE_RAND_FUNC
 

data/ext/iodine/rb-call.c

@@ -111,9 +111,5 @@ static VALUE call_arg(VALUE obj, ID method, int argc, VALUE *argv) {
 ////////////////////////////////////////////////////////////////////////////
 // the API interface
 struct _Ruby_Method_Caller_Class_ RubyCaller = {
-    .call = call,
-    .call2 = call_arg,
-    .call_c = call_c,
-    // .leave_gvl = leave_gvl,
-    .in_gvl = check_in_gvl,
+    .call = call, .call2 = call_arg, .call_c = call_c, .in_gvl = check_in_gvl,
 };

data/ext/iodine/rb-defer.c

@@ -58,7 +58,7 @@ void *defer_new_thread(void *(*thread_func)(void *), pool_pt pool) {
     return NULL;
   *data = (struct CreateThreadArgs){.thread_func = thread_func, .arg = pool};
   void *thr = rb_thread_call_with_gvl(create_ruby_thread_gvl, data);
-  if (thr == (void *)Qnil)
+  if (!thr || thr == (void *)Qnil || thr == (void *)Qfalse)
     thr = NULL;
   return thr;
 }
@@ -67,26 +67,9 @@ void *defer_new_thread(void *(*thread_func)(void *), pool_pt pool) {
 OVERRIDE THIS to replace the default pthread implementation.
 */
 int defer_join_thread(void *thr) {
+  if (!thr || (VALUE)thr == Qfalse || (VALUE)thr == Qnil)
+    return -1;
   rb_thread_call_with_gvl(_inner_join_with_rbthread, (void *)thr);
   Registry.remove((VALUE)thr);
   return 0;
 }
-
-/******************************************************************************
-Portability - used to help port this to different frameworks (i.e. Ruby).
-*/
-
-#define THREAD_TYPE VALUE
-
-/* Don't use sentinals with Ruby */
-#ifndef ASYNC_USE_SENTINEL
-#define ASYNC_USE_SENTINEL 0
-#endif
-
-/* The unused directive */
-#ifndef UNUSED_FUNC
-#define UNUSED_FUNC __attribute__((unused))
-#endif
-
-/* used here but declared elsewhere */
-void async_signal();

data/ext/iodine/rb-rack-io.c

@@ -4,20 +4,20 @@ License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
-// clang-format off
 #include "rb-rack-io.h"
-#include "iodine_core.h"
-#include <ruby/io.h>
+
+#include "iodine.h"
+
 #include <ruby/encoding.h>
+#include <ruby/io.h>
 #include <unistd.h>
-// clang-format on
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 #include "rb-call.h"
 
-/* RackIO manages a minimal interface to act as an IO wrapper according to
+/* IodineRackIO manages a minimal interface to act as an IO wrapper according to
 these Rack specifications:
 
 The input stream is an IO-like object which contains the raw HTTP POST data.
@@ -63,10 +63,10 @@ static VALUE TCPSOCKET_CLASS;
 static ID for_fd_id;
 
 #define set_uuid(object, request)                                              \
-  rb_ivar_set((object), fd_var_id, ULONG2NUM((request)->fd))
+  rb_ivar_set((object), iodine_fd_var_id, ULONG2NUM((request)->fd))
 
 inline static intptr_t get_uuid(VALUE obj) {
-  VALUE i = rb_ivar_get(obj, fd_var_id);
+  VALUE i = rb_ivar_get(obj, iodine_fd_var_id);
   return (intptr_t)FIX2ULONG(i);
 }
 
@@ -109,7 +109,7 @@ static VALUE strio_gets(VALUE self) {
   while ((pos_e < end) && str[pos_e] != '\n')
     pos_e++;
   set_pos(self, pos_e + 1);
-  return rb_enc_str_new(str + pos, pos_e - pos, BinaryEncoding);
+  return rb_enc_str_new(str + pos, pos_e - pos, IodineBinaryEncoding);
 }
 
 // Reads data from the IO, according to the Rack specifications for `#read`.
@@ -154,10 +154,10 @@ static VALUE strio_read(int argc, VALUE *argv, VALUE self) {
   if (buffer == Qnil) {
     buffer = rb_str_buf_new(len);
     // make sure the buffer is binary encoded.
-    rb_enc_associate(buffer, BinaryEncoding);
+    rb_enc_associate(buffer, IodineBinaryEncoding);
   } else {
     // make sure the buffer is binary encoded.
-    rb_enc_associate(buffer, BinaryEncoding);
+    rb_enc_associate(buffer, IodineBinaryEncoding);
     if (rb_str_capacity(buffer) < (size_t)len)
       rb_str_resize(buffer, len);
   }
@@ -229,7 +229,7 @@ static VALUE tfio_gets(VALUE self) {
   if (pos > pos_e) {
     buffer = rb_str_buf_new(pos_e - pos);
     // make sure the buffer is binary encoded.
-    rb_enc_associate(buffer, BinaryEncoding);
+    rb_enc_associate(buffer, IodineBinaryEncoding);
     if (pread(fd, RSTRING_PTR(buffer), pos_e - pos, pos) < 0)
       return Qnil;
     rb_str_set_len(buffer, pos_e - pos);
@@ -281,10 +281,10 @@ static VALUE tfio_read(int argc, VALUE *argv, VALUE self) {
   if (buffer == Qnil) {
     buffer = rb_str_buf_new(len);
     // make sure the buffer is binary encoded.
-    rb_enc_associate(buffer, BinaryEncoding);
+    rb_enc_associate(buffer, IodineBinaryEncoding);
   } else {
     // make sure the buffer is binary encoded.
-    rb_enc_associate(buffer, BinaryEncoding);
+    rb_enc_associate(buffer, IodineBinaryEncoding);
     if (rb_str_capacity(buffer) < (size_t)len)
       rb_str_resize(buffer, len);
   }
@@ -322,9 +322,9 @@ Hijacking
 */
 
 // defined by iodine_http
-extern VALUE R_HIJACK;    // for Rack: rack.hijack
-extern VALUE R_HIJACK_CB; // for Rack: rack.hijack
-extern VALUE R_HIJACK_IO; // for Rack: rack.hijack_io
+extern VALUE IODINE_R_HIJACK;    // for Rack: rack.hijack
+extern VALUE IODINE_R_HIJACK_CB; // for Rack: rack.hijack
+extern VALUE IODINE_R_HIJACK_IO; // for Rack: rack.hijack_io
 
 static VALUE rio_get_io(int argc, VALUE *argv, VALUE self) {
   if (TCPSOCKET_CLASS == Qnil)
@@ -334,15 +334,15 @@ static VALUE rio_get_io(int argc, VALUE *argv, VALUE self) {
   VALUE fd = INT2FIX(sock_uuid2fd(fduuid));
   VALUE env = rb_ivar_get(self, env_id);
   // make sure we're not repeating ourselves
-  VALUE new_io = rb_hash_aref(env, R_HIJACK_IO);
+  VALUE new_io = rb_hash_aref(env, IODINE_R_HIJACK_IO);
   if (new_io != Qnil)
     return new_io;
   // VALUE new_io = how the fuck do we create a new IO from the fd?
   new_io = RubyCaller.call2(TCPSOCKET_CLASS, for_fd_id, 1,
                             &fd); // TCPSocket.for_fd(fd) ... cool...
-  rb_hash_aset(env, R_HIJACK_IO, new_io);
+  rb_hash_aset(env, IODINE_R_HIJACK_IO, new_io);
   if (argc)
-    rb_hash_aset(env, R_HIJACK_CB, *argv);
+    rb_hash_aset(env, IODINE_R_HIJACK_CB, *argv);
   return new_io;
 }
 
@@ -354,11 +354,11 @@ C land API
 static VALUE new_rack_io(http_request_s *request, VALUE env) {
   VALUE rack_io;
   if (request->body_file > 0) {
-    rack_io = rb_funcall2(rRackFileIO, new_func_id, 0, NULL);
+    rack_io = rb_funcall2(rRackFileIO, iodine_new_func_id, 0, NULL);
     rb_ivar_set(rack_io, io_id, ULONG2NUM(request->body_file));
     lseek(request->body_file, 0, SEEK_SET);
   } else {
-    rack_io = rb_funcall2(rRackStrIO, new_func_id, 0, NULL);
+    rack_io = rb_funcall2(rRackStrIO, iodine_new_func_id, 0, NULL);
     rb_ivar_set(rack_io, io_id, ULONG2NUM(((intptr_t)request->body_str)));
     // fprintf(stderr, "rack body IO (%lu, %p):%.*s\n", request->content_length,
     //         request->body_str, (int)request->content_length,
@@ -402,6 +402,6 @@ static void init_rack_io(void) {
 
 ////////////////////////////////////////////////////////////////////////////
 // the API interface
-struct _RackIO_ RackIO = {
+struct IodineRackIO IodineRackIO = {
     .create = new_rack_io, .init = init_rack_io,
 };

data/ext/iodine/rb-rack-io.h

@@ -6,15 +6,14 @@ Feel free to copy, use and enjoy according to the license provided.
 */
 #ifndef RUBY_RACK_IO_H
 #define RUBY_RACK_IO_H
-// clang-format off
+
 #include <ruby.h>
-// clang-format on
 
 #include "http_request.h"
 
-extern struct _RackIO_ {
+extern struct IodineRackIO {
   VALUE (*create)(http_request_s *request, VALUE env);
   void (*init)(void);
-} RackIO;
+} IodineRackIO;
 
 #endif /* RUBY_RACK_IO_H */

data/ext/iodine/rb-registry.c

@@ -9,164 +9,156 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include "spnlock.inc"
 
-// #define RUBY_REG_DBG
+#include "fio_hash_table.h"
+#include <signal.h>
 
+// #define RUBY_REG_DBG
+#ifndef REGISTRY_POOL_SIZE
 #define REGISTRY_POOL_SIZE 1024
-// the references struct (bin-tree)
-struct Object {
-  struct Object *next;
-  VALUE obj;
-  int count;
-};
+#endif
+
+#ifndef RUBY_REG_DBG
+#define RUBY_REG_DBG 0
+#endif
 
-// the registry global
-static struct Registry {
-  struct Object pool_mem[REGISTRY_POOL_SIZE];
-  struct Object *obj_pool;
-  struct Object *first;
+typedef struct {
+  union {
+    fio_list_s pool;
+    fio_ht_node_s node;
+  };
+  VALUE obj;
+  volatile uint64_t ref;
+} obj_s;
+
+// the registry state keeper
+static struct {
+  obj_s pool_mem[REGISTRY_POOL_SIZE];
+  fio_list_s pool;
+  fio_ht_s store;
   VALUE owner;
   spn_lock_i lock;
-} registry = {
-    .obj_pool = NULL, .first = NULL, .owner = 0, .lock = SPN_LOCK_INIT};
+} registry = {.pool = FIO_LIST_INIT_STATIC(registry.pool),
+              .store = FIO_HASH_TABLE_STATIC(registry.store),
+              .owner = 0,
+              .lock = SPN_LOCK_INIT};
 
 #define try_lock_registry() spn_trylock(&registry.lock)
 #define unlock_registry() spn_unlock(&registry.lock)
 #define lock_registry() spn_lock(&registry.lock)
 
-inline static void free_node(struct Object *to_free) {
+inline static void free_node(obj_s *to_free) {
   if (to_free >= registry.pool_mem &&
-      (intptr_t)to_free <= (intptr_t)(&registry.obj_pool)) {
-    to_free->next = registry.obj_pool;
-    registry.obj_pool = to_free;
-  } else {
+      (intptr_t)to_free <= (intptr_t)(&registry.pool))
+    fio_list_push(obj_s, pool, registry.pool, to_free);
+  else
     free(to_free);
-  }
 }
 
-// add an object to the registry
-//
-// allow multiple registrartions (bag)
-static VALUE register_object(VALUE obj) {
-  if (!obj || obj == Qnil)
+/** adds an object to the registry or increases it's reference count. */
+static VALUE register_object(VALUE ruby_obj) {
+  if (!ruby_obj || ruby_obj == Qnil || ruby_obj == Qfalse)
     return 0;
-  struct Object *line = registry.first;
   lock_registry();
-  while (line) {
-    if (line->obj == obj) {
-      line->count++;
-      goto finish;
-    }
-    line = line->next;
-  }
-  if (registry.obj_pool) {
-    line = registry.obj_pool;
-    registry.obj_pool = registry.obj_pool->next;
-  } else {
-    line = malloc(sizeof(struct Object));
+  obj_s *obj = (void *)fio_ht_find(&registry.store, (uint64_t)ruby_obj);
+  if (obj) {
+    obj = fio_node2obj(obj_s, node, obj);
+#if RUBY_REG_DBG == 1
+    fprintf(stderr, "Ruby Registry: register %p ref: %" PRIu64 " + 1\n",
+            (void *)ruby_obj, obj->ref);
+#endif
+    goto exists;
   }
-  if (line == NULL) {
+#if RUBY_REG_DBG == 1
+  fprintf(stderr, "Ruby Registry: register %p\n", (void *)ruby_obj);
+#endif
+  obj = fio_list_pop(obj_s, pool, registry.pool);
+  if (!obj)
+    obj = malloc(sizeof(obj_s));
+  if (!obj) {
     perror("No Memory!");
+    kill(0, SIGINT);
     exit(1);
   }
-  line->obj = obj;
-  line->next = registry.first;
-  line->count = 1;
-  registry.first = line;
-finish:
+  *obj = (obj_s){.obj = ruby_obj};
+  fio_ht_add(&registry.store, &obj->node, (uint64_t)ruby_obj);
+exists:
+  spn_add(&obj->ref, 1);
+
   unlock_registry();
-  return obj;
+  return ruby_obj;
 }
 
-// free a single registry
-//
-// free only one.
-static void unregister_object(VALUE obj) {
-  if (!obj || obj == Qnil)
+/** decreases an object's reference count or removes if from the registry. */
+static void unregister_object(VALUE ruby_obj) {
+  if (!ruby_obj || ruby_obj == Qnil)
     return;
   lock_registry();
-  struct Object **line = &registry.first;
-  while (*line) {
-    if ((*line)->obj == obj) {
-      (*line)->count -= 1;
-      if ((*line)->count <= 0) {
-        struct Object *to_free = *line;
-        *line = (*line)->next;
-        free_node(to_free);
-        goto finish;
-      }
-    }
-    line = &((*line)->next);
+  obj_s *obj = (void *)fio_ht_find(&registry.store, (uint64_t)ruby_obj);
+  if (!obj) {
+#if RUBY_REG_DBG == 1
+    fprintf(stderr, "Ruby Registry: unregister - NOT FOUND %p\n",
+            (void *)ruby_obj);
+#endif
+    goto finish;
+  }
+  obj = fio_node2obj(obj_s, node, obj);
+  if (spn_sub(&obj->ref, 1)) {
+    unlock_registry();
+#if RUBY_REG_DBG == 1
+    fprintf(stderr, "Ruby Registry: unregistered %p ref: %" PRIu64 "  \n",
+            (void *)ruby_obj, obj->ref);
+#endif
+    return;
   }
+  fio_ht_remove(&obj->node);
+  free_node(obj);
 finish:
   unlock_registry();
+#if RUBY_REG_DBG == 1
+  fprintf(stderr, "Ruby Registry: unregistered %p\n", (void *)ruby_obj);
+#endif
 }
 
-// // Replaces one registry object with another,
-// // allowing updates to the Registry with no memory allocations.
-// //
-// // returns 0 if all OK, returns -1 if it couldn't replace the object.
-// static int replace_object(VALUE obj, VALUE new_obj) {
-//   int ret = -1;
-//   if (obj == new_obj)
-//     return 0;
-//   pthread_mutex_lock(&registry_lock);
-//   struct Object* line = registry.first;
-//   while (line) {
-//     if (line->obj == obj) {
-//       line->obj = new_obj;
-//       ret = 0;
-//       goto finish;
-//     }
-//     line = line->next;
-//   }
-// finish:
-//   pthread_mutex_unlock(&registry_lock);
-//   return ret;
-// }
-
-// a callback for the GC (marking active objects)
+/* a callback for the GC (marking active objects) */
 static void registry_mark(void *ignore) {
   (void)ignore;
-#ifdef RUBY_REG_DBG
+#if RUBY_REG_DBG == 1
   Registry.print();
 #endif
   lock_registry();
-  struct Object *line = registry.first;
-  while (line) {
-    if (line->obj)
-      rb_gc_mark(line->obj);
-    line = line->next;
-  }
+  obj_s *obj;
+  fio_ht_for_each(obj_s, node, obj, registry.store) rb_gc_mark(obj->obj);
   unlock_registry();
 }
 
-// clear the registry (end of lifetime)
+/* clear the registry (end of lifetime) */
 static void registry_clear(void *ignore) {
   (void)ignore;
+#if RUBY_REG_DBG == 1
+  fprintf(stderr, "Ruby Registry:  Clear!!!\n");
+#endif
   lock_registry();
-  struct Object *line;
-  struct Object *to_free;
-  // free active object references
-  line = registry.first;
-  while (line) {
-    to_free = line;
-    line = line->next;
-    free_node(to_free);
+  obj_s *obj;
+  fio_ht_for_each(obj_s, node, obj, registry.store) {
+    fio_ht_remove(&obj->node);
+    rb_gc_mark(obj->obj);
   }
-  registry.first = NULL;
   registry.owner = 0;
+  fio_ht_free(&registry.store);
   unlock_registry();
 }
 
-// the data-type used to identify the registry
-// this sets the callbacks.
+/*
+the data-type used to identify the registry
+this sets the callbacks.
+*/
 static struct rb_data_type_struct my_registry_type_struct = {
     .wrap_struct_name = "RubyReferencesIn_C_Land",
     .function.dfree = (void (*)(void *))registry_clear,
     .function.dmark = (void (*)(void *))registry_mark,
 };
 
-// initialize the registry
+/* initialize the registry */
 static void init(VALUE owner) {
   lock_registry();
   // only one registry
@@ -181,27 +173,28 @@ static void init(VALUE owner) {
       TypedData_Wrap_Struct(rReferences, &my_registry_type_struct, &registry);
   rb_ivar_set(owner, rb_intern("registry"), r_registry);
   // initialize memory pool
-  for (size_t i = 0; i < REGISTRY_POOL_SIZE - 1; i++) {
-    registry.pool_mem[i].next = registry.pool_mem + i + 1;
+  for (size_t i = 0; i < REGISTRY_POOL_SIZE; i++) {
+    fio_list_push(obj_s, pool, registry.pool, &registry.pool_mem[i]);
   }
-  registry.pool_mem[REGISTRY_POOL_SIZE - 1].next = NULL;
-  registry.obj_pool = registry.pool_mem;
 finish:
   unlock_registry();
 }
 
-// print data, for testing
+/* print data, for testing */
 static void print(void) {
   lock_registry();
-  struct Object *line = registry.first;
   fprintf(stderr, "Registry owner is %lu\n", registry.owner);
-  long index = 0;
-  while (line) {
-    fprintf(stderr, "[%lu] => %d X obj %lu type %d at %p\n", index++,
-            line->count, line->obj, TYPE(line->obj), (void *)line);
-    line = line->next;
+  obj_s *obj;
+  uint64_t index = 0;
+  fio_ht_for_each(obj_s, node, obj, registry.store) {
+    fprintf(stderr, "[%" PRIu64 " ] => %" PRIu64 " X obj %p type %d at %p\n",
+            index++, obj->ref, (void *)obj->obj, TYPE(obj->obj), (void *)obj);
   }
-  fprintf(stderr, "Total of %lu registered objects being marked\n", index);
+  fprintf(stderr, "Total of %" PRIu64 " registered objects being marked\n",
+          index);
+  fprintf(stderr,
+          "Registry uses %" PRIu64 " Hash bins for %" PRIu64 " objects\n",
+          registry.store.bin_count, registry.store.count);
   unlock_registry();
 }