iodine 0.5.2 → 0.6.0

data/ext/iodine/iodine_websockets.h

@@ -1,17 +0,0 @@
-#ifndef H_IODINE_WEBSOCKETS_H
-#define H_IODINE_WEBSOCKETS_H
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#include "iodine.h"
-
-#include "http.h"
-
-void Iodine_init_websocket(void);
-
-void iodine_upgrade_websocket(http_s *request, VALUE handler);
-void iodine_upgrade_sse(http_s *h, VALUE handler);
-#endif

data/ext/iodine/rb-call.c

@@ -1,156 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#include "rb-call.h"
-#include <pthread.h>
-#include <ruby.h>
-#include <ruby/thread.h>
-
-#if __STDC_VERSION__ < 201112L || __STDC_NO_THREADS__
-#define _Thread_local __thread
-#endif
-
-typedef enum {
-  RUBY_TASK,
-  C_TASK,
-} iodine_task_type_en;
-
-typedef struct {
-  iodine_task_type_en type;
-  VALUE obj;
-  int argc;
-  VALUE *argv;
-  ID method;
-  int exception;
-} iodine_rb_task_s;
-
-typedef struct {
-  iodine_task_type_en type;
-  void *(*func)(void *);
-  void *arg;
-} iodine_c_task_s;
-
-// running the actual method call
-static VALUE iodine_ruby_caller_perform(VALUE tsk_) {
-  switch (*(iodine_task_type_en *)tsk_) {
-  case RUBY_TASK: {
-    iodine_rb_task_s *task = (void *)tsk_;
-    return rb_funcall2(task->obj, task->method, task->argc, task->argv);
-  }
-  case C_TASK: {
-    iodine_c_task_s *task = (void *)tsk_;
-    return (VALUE)task->func(task->arg);
-  }
-  }
-  return Qnil;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// Handling exceptions (printing the backtrace doesn't really work well).
-static void *handle_exception(void *ignr) {
-  (void)ignr;
-  VALUE exc = rb_errinfo();
-  if (exc != Qnil) {
-    VALUE msg = RubyCaller.call(exc, rb_intern("message"));
-    VALUE exc_class = rb_class_name(CLASS_OF(exc));
-    VALUE bt = RubyCaller.call(exc, rb_intern("backtrace"));
-    if (TYPE(bt) == T_ARRAY) {
-      bt = rb_ary_join(bt, rb_str_new_literal("\n"));
-      fprintf(stderr, "Iodine caught an unprotected exception - %.*s: %.*s\n%s",
-              (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
-              (int)RSTRING_LEN(msg), RSTRING_PTR(msg), StringValueCStr(bt));
-    } else {
-      fprintf(stderr,
-              "Iodine caught an unprotected exception - %.*s: %.*s\n"
-              "No backtrace available.\n",
-              (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
-              (int)RSTRING_LEN(msg), RSTRING_PTR(msg));
-    }
-    rb_backtrace();
-    fprintf(stderr, "\n\n");
-    rb_set_errinfo(Qnil);
-  }
-  return (void *)Qnil;
-}
-
-/* wrap the function call in the exception handling code */
-static void *iodine_protected_call(void *tsk_) {
-  int state = 0;
-  VALUE ret = rb_protect(iodine_ruby_caller_perform, (VALUE)(tsk_), &state);
-  if (state) {
-    handle_exception(NULL);
-  }
-  return (void *)ret;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// GVL state.
-
-// a thread specific global variable that lets us know if we're in the GVL
-static _Thread_local char in_gvl = 0;
-static char iodine_rb_check_in_gvl(void) { return in_gvl; }
-
-static void iodine_rb_set_gvl_state(char state) { in_gvl = state; }
-
-////////////////////////////////////////////////////////////////////////////
-// Calling C functions.
-static inline void *iodine_rb_call_c(void *(*func)(void *), void *arg) {
-  if (in_gvl) {
-    return func(arg);
-  }
-  iodine_c_task_s task = {.type = C_TASK, .func = func, .arg = arg};
-  void *ret;
-  in_gvl = 1;
-  ret = rb_thread_call_with_gvl(iodine_protected_call, &task);
-  in_gvl = 0;
-  return ret;
-}
-
-static void *iodine_rb_leave_gvl(void *(*func)(void *), void *arg) {
-  if (!in_gvl) {
-    return func(arg);
-  }
-  in_gvl = 0;
-  void *ret = rb_thread_call_without_gvl(func, arg, NULL, NULL);
-  in_gvl = 1;
-  return ret;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// A heavier (memory) design for when we're passing arguments around.
-
-// wrapping any API calls for exception management AND GVL entry
-static VALUE iodin_rb_call_arg(VALUE obj, ID method, int argc, VALUE *argv) {
-  iodine_rb_task_s task = {.type = RUBY_TASK,
-                           .obj = obj,
-                           .method = method,
-                           .argc = argc,
-                           .argv = argv};
-  void *ret;
-  if (in_gvl) {
-    return (VALUE)iodine_protected_call(&task);
-  }
-  in_gvl = 1;
-  ret = rb_thread_call_with_gvl(iodine_protected_call, &task);
-  in_gvl = 0;
-  return (VALUE)ret;
-}
-
-// wrapping any API calls for exception management AND GVL entry
-static VALUE iodin_rb_call(VALUE obj, ID method) {
-  return iodin_rb_call_arg(obj, method, 0, NULL);
-}
-
-////////////////////////////////////////////////////////////////////////////
-// the API interface
-struct _Ruby_Method_Caller_Class_ RubyCaller = {
-    .call = iodin_rb_call,
-    .call2 = iodin_rb_call_arg,
-    .call_c = iodine_rb_call_c,
-    .leave_gvl = iodine_rb_leave_gvl,
-    .in_gvl = iodine_rb_check_in_gvl,
-    .set_gvl_state = iodine_rb_set_gvl_state,
-};

data/ext/iodine/rb-call.h

@@ -1,70 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#ifndef RB_CALL_H
-#define RB_CALL_H
-#include <ruby.h>
-
-#define RB_CALL_VERSION "0.2.0"
-
-/**
-The Ruby framework manages it's own contextc switching and memory...
-this means that when we make calls to Ruby (i.e. creating Ruby objects),
-we risk currupting the Ruby framework. Also, Ruby uses all these signals (for
-it's context switchings) and long-jumps (i.e. Ruby exceptions) that can drive
-the C code a little nuts...
-
-Seperation is reqiured :-)
-
-This is a simple helper that calls Ruby methods on Ruby objects and C
-functions that require acess to the Ruby API, while managing the GVL lock
-status as required.
-
-To call a Ruby object's method, simply use:
-
-    RubyCaller.call(object, method_id);
-
-To pass arguments to the ruby object's method, use the `call2` method. i.e.:
-
-    RubyCaller.call2(object, method_id, argc, argv);
-
-
-This library keeps track of the thread, adjusting the method to be called in
-case the thread is already within the GVL.
-
-The library assums that it is within a Ruby thread that is was released of
-the GVL using `rb_thread_call_without_gvl`. If this isn t the case, use the
-`RubyCaller.set_gvl_state` function to manually set the GVL state assumption.
-*/
-extern struct _Ruby_Method_Caller_Class_ {
-  /** calls a Object's ruby method, adjusting for the GVL if needed */
-  VALUE (*call)(VALUE object, ID method_id);
-  /**
-   * calls a Object's ruby method with arguments, adjusting for the GVL if
-   * needed
-   */
-  VALUE (*call2)(VALUE obj, ID method, int argc, VALUE *argv);
-  /**
-   * calls a C method that requires the GVL for access to the Ruby API, managing
-   * the GVL state as required.
-   */
-  void *(*call_c)(void *(*func)(void *), void *arg);
-  /**
-   * Exits the GVL (if the thread is withing the GVL) and calls a C function.
-   */
-  void *(*leave_gvl)(void *(*func)(void *), void *arg);
-  /**
-   * returns the thread's GVL status (1 if inside a GVL and 0 if free from the
-   * GVL).
-   */
-  char (*in_gvl)(void);
-  /**
-   * forces a thread's GVL state flag (ignoring the actual GVL state) - careful!
-   */
-  void (*set_gvl_state)(char state);
-} RubyCaller;
-
-#endif /* RB_CALL_H */

data/ext/iodine/rb-defer.c

@@ -1,124 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-// clang-format off
-#include "rb-registry.h"
-#include "rb-call.h"
-#include "iodine.h"
-#include <ruby.h>
-#include <ruby/thread.h>
-
-#include <stdint.h>
-// clang-format on
-
-#include <spnlock.inc>
-#include "defer.h"
-
-#include <pthread.h>
-
-/* *****************************************************************************
-Local helpers
-***************************************************************************** */
-/* used to create Ruby threads and pass them the information they need */
-struct CreateThreadArgs {
-  void *(*thread_func)(void *);
-  void *arg;
-};
-
-/* used here but declared elsewhere */
-void call_async_signal(void *pool) { defer_pool_stop((pool_pt)pool); }
-
-static void *defer_thread_start(void *args_) {
-  struct CreateThreadArgs *args = args_;
-  void *(*thread_func)(void *) = args->thread_func;
-  void *arg = args->arg;
-  free(args);
-  RubyCaller.set_gvl_state(0);
-  thread_func(arg);
-  return NULL;
-}
-
-/* the thread's GVL release */
-static VALUE defer_thread_inGVL(void *args_) {
-  struct CreateThreadArgs *args = args_;
-  rb_thread_call_without_gvl(defer_thread_start, args_,
-                             (void (*)(void *))call_async_signal, args->arg);
-  return Qnil;
-}
-
-/* Within the GVL, creates a Ruby thread using an API call */
-static void *create_ruby_thread_gvl(void *args) {
-  return (void *)Registry.add(rb_thread_create(defer_thread_inGVL, args));
-}
-
-/* used during fork */
-void iodine_start_io_thread(void *a1, void *a2);
-
-static void *fork_using_ruby(void *ignr) {
-  RubyCaller.call(Iodine, rb_intern("before_fork"));
-  const VALUE ProcessClass = rb_const_get(rb_cObject, rb_intern("Process"));
-  const VALUE rb_pid = RubyCaller.call(ProcessClass, rb_intern("fork"));
-  intptr_t pid = 0;
-  if (rb_pid != Qnil) {
-    pid = NUM2INT(rb_pid);
-  } else {
-    pid = 0;
-  }
-  RubyCaller.set_gvl_state(1); /* enforce GVL state in thread storage */
-  if (!pid) {
-    Registry.on_fork();
-    RubyCaller.call(Iodine, rb_intern("after_fork"));
-    iodine_start_io_thread(NULL, NULL);
-  }
-  return (void *)pid;
-  (void)ignr;
-}
-
-/* *****************************************************************************
-The Defer library overriding functions
-***************************************************************************** */
-
-/**
-OVERRIDE THIS to replace the default pthread implementation.
-*/
-void *defer_new_thread(void *(*thread_func)(void *), void *arg) {
-  struct CreateThreadArgs *data = malloc(sizeof(*data));
-  if (!data)
-    return NULL;
-  *data = (struct CreateThreadArgs){
-      .thread_func = thread_func, .arg = arg,
-  };
-  void *thr = RubyCaller.call_c(create_ruby_thread_gvl, data);
-  if (!thr || thr == (void *)Qnil || thr == (void *)Qfalse) {
-    thr = NULL;
-  }
-  return thr;
-}
-
-/**
-OVERRIDE THIS to replace the default pthread implementation.
-*/
-int defer_join_thread(void *thr) {
-  if (!thr || (VALUE)thr == Qfalse || (VALUE)thr == Qnil)
-    return -1;
-  RubyCaller.call((VALUE)thr, rb_intern("join"));
-  Registry.remove((VALUE)thr);
-  return 0;
-}
-
-// void defer_free_thread(void *thr) { (void)thr; }
-void defer_free_thread(void *thr) { Registry.remove((VALUE)thr); }
-
-/**
-OVERRIDE THIS to replace the default `fork` implementation or to inject hooks
-into the forking function.
-
-Behaves like the system's `fork`.
-*/
-int facil_fork(void) {
-  intptr_t pid = (intptr_t)RubyCaller.call_c(fork_using_ruby, NULL);
-  return (int)pid;
-}

data/ext/iodine/rb-registry.c

@@ -1,150 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#include "rb-registry.h"
-#include <ruby.h>
-
-#include "spnlock.inc"
-
-#define FIO_OVERRIDE_MALLOC 1
-#include "fio_mem.h"
-
-#include "fio_hashmap.h"
-#include <signal.h>
-
-#ifndef RUBY_REG_DBG
-#define RUBY_REG_DBG 0
-#endif
-
-// the registry state keeper
-static struct {
-  fio_hash_s store;
-  VALUE owner;
-  spn_lock_i lock;
-} registry = {.store = {.capa = 0}, .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)
-
-/** 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;
-  lock_registry();
-  uintptr_t count = (uintptr_t)fio_hash_find(&registry.store, ruby_obj);
-#if RUBY_REG_DBG == 1
-  fprintf(stderr, "Ruby Registry: register %p ref: %" PRIu64 " + 1\n",
-          (void *)ruby_obj, (uint64_t)count);
-#endif
-  fio_hash_insert(&registry.store, (uint64_t)ruby_obj, (void *)(count + 1));
-  unlock_registry();
-  return ruby_obj;
-}
-
-/** 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();
-  uintptr_t count = (uintptr_t)fio_hash_find(&registry.store, ruby_obj);
-#if RUBY_REG_DBG == 1
-  fprintf(stderr, "Ruby Registry: unregister %p ref: %" PRIu64 " - 1\n",
-          (void *)ruby_obj, (uint64_t)count);
-#endif
-  if (count) {
-    fio_hash_insert(&registry.store, (uint64_t)ruby_obj, (void *)(count - 1));
-  }
-  unlock_registry();
-}
-
-/* a callback for the GC (marking active objects) */
-static void registry_mark(void *ignore) {
-  (void)ignore;
-#if RUBY_REG_DBG == 1
-  Registry.print();
-#endif
-  lock_registry();
-  fio_hash_compact(&registry.store);
-  FIO_HASH_FOR_LOOP(&registry.store, pos) {
-    if (pos->obj) {
-      rb_gc_mark((VALUE)pos->key);
-    }
-  }
-  unlock_registry();
-}
-
-/* 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();
-  fio_hash_free(&registry.store);
-  registry.owner = 0;
-  registry.store = (fio_hash_s){.capa = 0};
-  unlock_registry();
-}
-
-/*
-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 */
-static void init(VALUE owner) {
-  lock_registry();
-  // only one registry
-  if (registry.owner)
-    goto finish;
-  if (!owner)
-    owner = rb_cObject;
-  registry.owner = owner;
-  VALUE rReferences =
-      rb_define_class_under(owner, "RubyObjectRegistry_for_C_land", rb_cData);
-  VALUE r_registry =
-      TypedData_Wrap_Struct(rReferences, &my_registry_type_struct, &registry);
-  rb_ivar_set(owner, rb_intern("registry"), r_registry);
-finish:
-  unlock_registry();
-}
-
-static void registry_on_fork(void) { unlock_registry(); }
-
-/* print data, for testing */
-static void print(void) {
-  lock_registry();
-  fprintf(stderr, "Registry owner is %lu\n", registry.owner);
-  uintptr_t index = 0;
-  FIO_HASH_FOR_LOOP(&registry.store, pos) {
-    if (pos->obj) {
-      fprintf(stderr, "[%" PRIuPTR " ] => %" PRIuPTR " X obj %p type %d\n",
-              index++, (uintptr_t)pos->obj, (void *)pos->key, TYPE(pos->key));
-    }
-  }
-  fprintf(stderr, "Total of %" PRIuPTR " registered objects being marked\n",
-          index);
-  fprintf(stderr,
-          "Registry uses %" PRIuPTR " Hash bins for %" PRIuPTR " objects\n",
-          registry.store.capa, registry.store.count);
-  unlock_registry();
-}
-
-////////////////////////////////////////////
-// The API gateway
-struct ___RegistryClass___ Registry = {
-    .init = init,
-    .remove = unregister_object,
-    .add = register_object,
-    .print = print,
-    .on_fork = registry_on_fork,
-};