rage-iodine 5.5.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce6be54873c53f93352aa7c739c74e73f5510eaeaab015bd2afc5e0fe261ff38
-  data.tar.gz: 45bba38d8c14f66e780981c13a05a7ca1d036a6809f71f33833e8743e285c32b
+  metadata.gz: 1595ec4d4f155fbc845b37ad096018a2a4bfa4f884c0ef96b7112d268fe86e89
+  data.tar.gz: 3185d0901b132a329509238b5188dcd29de1d4145a018adda6b3f9f215e008cf
 SHA512:
-  metadata.gz: be4a8fd787b970fb21e30d6ec21e590ca27da1122d62f7efeac532f5b2fffd920c7016d489bd5c1e748e9d559058c23c3f567edc0e99e1da34a4a81b2bdde70c
-  data.tar.gz: 25e51f20a4a572caab13708ca5496e73cbcbb90810c13bf1000d8cbb0a1ec75bf797ade820d756a2c30237ac37c254e89303d0adeb7b6f060133a6cc1edc708e
+  metadata.gz: 4bbaa335fcd6202ac41a6449a5d8a38302c786b69348b66af733520e83c27bf4529c8a0e90dc7db5f19f8755aadfaf0c71edeb07fea904664b2cbf573da573f0
+  data.tar.gz: 991187eeb695f2128f83859e1025d62d580a1e41fc672822aaf7c8e5130edf15c83721e263a30799311766627fbd132393b50987486d137004f7ae439d11d0b8

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.6.0.0 (2026-09-06)
+
+**Update**: Update scheduler `read`/`write` hooks
+
+#### Change log v.5.6.0 (2026-09-06)
+
+**Update**: TCP Socket Listen: Accept Queue
+
 #### Change log v.5.5.0 (2026-07-06)
 
 **Update**: Update `pre_start` callbacks to fail the server launch in case of errors

data/Gemfile

@@ -4,7 +4,8 @@ group :test do
   gem 'pry'
   gem 'rspec'
   gem 'rack'
-  gem 'http'
+  gem 'http', '~> 5.0'
+  gem 'ostruct', '~> 0.6.3'
   gem 'base64'
   gem 'benchmark'
 end

data/ext/iodine/fio.c

@@ -3687,12 +3687,12 @@ retry_int:
 }
 
 /**
- * This is a complete copy of `fio_read` except that it doesn't attempt to force close the
- * socker on error.
+ * Performs a single read operation using the connection's read hook.
  *
- * The method is currently used by the fiber scheduler.
+ * The return value and errno match the underlying read operation. The socket
+ * isn't closed on error.
  */
-ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count) {
+ssize_t fio_read_once(intptr_t uuid, void *buffer, size_t count) {
   if (!uuid_is_valid(uuid) || !uuid_data(uuid).open) {
     errno = EBADF;
     return -1;
@@ -3704,22 +3704,36 @@ ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count) {
       uuid_data(uuid).rw_hooks->read;
   void *udata = uuid_data(uuid).rw_udata;
   fio_unlock(&uuid_data(uuid).sock_lock);
-  int old_errno = errno;
-  ssize_t ret;
-retry_int:
-  ret = rw_read(uuid, udata, buffer, count);
+  ssize_t ret = rw_read(uuid, udata, buffer, count);
   if (ret > 0) {
     fio_touch(uuid);
-    return ret;
   }
-  if (ret < 0 && errno == EINTR)
-    goto retry_int;
-  if (ret < 0 &&
-      (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOTCONN)) {
-    errno = old_errno;
+  return ret;
+}
+
+/**
+ * Performs a single write operation using the connection's write hook.
+ *
+ * The return value and errno match the underlying write operation. The socket
+ * isn't closed on error and no data is queued for the reactor.
+ */
+ssize_t fio_write_once(intptr_t uuid, const void *buffer, size_t count) {
+  if (!uuid_is_valid(uuid) || !uuid_data(uuid).open) {
+    errno = EBADF;
+    return -1;
+  }
+  if (count == 0)
     return 0;
+  fio_lock(&uuid_data(uuid).sock_lock);
+  ssize_t (*rw_write)(intptr_t, void *, const void *, size_t) =
+      uuid_data(uuid).rw_hooks->write;
+  void *udata = uuid_data(uuid).rw_udata;
+  fio_unlock(&uuid_data(uuid).sock_lock);
+  ssize_t ret = rw_write(uuid, udata, buffer, count);
+  if (ret > 0) {
+    fio_touch(uuid);
   }
-  return -1;
+  return ret;
 }
 
 /**
@@ -4532,10 +4546,22 @@ Initialize the library
 
 static void fio_pubsub_on_fork(void);
 
+#if defined(__linux__)
+/* accept-queue tracking lock for the listener registry (defined alongside
+ * fio_accept_queue_listeners in the listener section below); declared here
+ * so fio_on_fork can reset it across children. */
+static fio_lock_i fio_accept_queue_lock;
+#endif
+
 /* Called within a child process after it starts. */
 static void fio_on_fork(void) {
   fio_timer_lock = FIO_LOCK_INIT;
   fio_data->lock = FIO_LOCK_INIT;
+#if defined(__linux__)
+  /* a forked child may inherit the accept-queue lock while a parent thread
+   * held it mid-walk; that thread won't exist in the child, so reset it. */
+  fio_accept_queue_lock = FIO_LOCK_INIT;
+#endif
   fio_defer_on_fork();
   fio_malloc_after_fork();
   fio_poll_init();
@@ -5571,6 +5597,14 @@ The listening protocol (use the facil.io API to make a socket and attach it)
 typedef struct {
   fio_protocol_s pr;
   intptr_t uuid;
+#if defined(__linux__)
+/**
+* Listener node adding this listener into to fio_accept_queue_listeners,
+* so Iodine::Perf.queued_connections can find its socket's fd and read its
+* kernel length accept-queue(AcceptQ):backlog where (backlog <= somaxconn) (TCP_INFO).
+*/
+  fio_ls_embd_s listener_node;
+#endif
   void *udata;
   void (*on_open)(intptr_t uuid, void *udata);
   void (*on_start)(intptr_t uuid, void *udata);
@@ -5582,8 +5616,20 @@ typedef struct {
   void *tls;
 } fio_listen_protocol_s;
 
+#if defined(__linux__)
+/* tracks iodine's listening sockets for the accept-queue backlog query.
+ * guarded against concurrent teardown (reactor thread, no GVL) */
+static fio_ls_embd_s fio_accept_queue_listeners = FIO_LS_INIT(fio_accept_queue_listeners);
+static fio_lock_i fio_accept_queue_lock = FIO_LOCK_INIT;
+#endif
+
 static void fio_listen_cleanup_task(void *pr_) {
   fio_listen_protocol_s *pr = pr_;
+#if defined(__linux__)
+  fio_lock(&fio_accept_queue_lock);
+  fio_ls_embd_remove(&pr->listener_node);
+  fio_unlock(&fio_accept_queue_lock);
+#endif
 #ifndef __MINGW32__
   if (pr->tls)
     fio_tls_destroy(pr->tls);
@@ -5733,6 +5779,12 @@ intptr_t fio_listen FIO_IGNORE_MACRO(struct fio_listen_args args) {
   if (port_len)
     memcpy(pr->port, args.port, port_len + 1);
 
+#if defined(__linux__)
+  fio_lock(&fio_accept_queue_lock);
+  fio_ls_embd_push(&fio_accept_queue_listeners, &pr->listener_node);
+  fio_unlock(&fio_accept_queue_lock);
+#endif
+
   if (fio_is_running()) {
     fio_attach(pr->uuid, &pr->pr);
   } else {
@@ -5753,6 +5805,65 @@ error:
   return -1;
 }
 
+/* -------------------------------------------------------------------------
+ * Kernel accept-queue(AcceptQ) which is Queue length: backlog, where backlog <= somaxconn  
+ * "backlog are established connections waiting for accept()" = sk_ack_backlog.
+ * Returns the sum of the accept-queues of all iodine listening sockets, or 0.
+ * ---------------------------------------------------------------------- */
+#if defined(__linux__)
+intptr_t fio_queued_connections(void) {
+  intptr_t backlog = 0;
+
+  fio_lock(&fio_accept_queue_lock);
+  /**
+   * Walk every registered listener and sum its kernel accept-queue depth/length.
+   * The list always begins with a permanent head node (fio_accept_queue_listeners) 
+   * that works like a fixed bookmark: it holds no listener of its own, real nodes 
+   * are chained after it, and the last node links back to it, forming a circle 
+   * i.e a circular linked list also it's a doubly linked list.
+   *
+   * So the loop:
+   *   - starts at `.next`, i.e. the FIRST REAL node starting at the head
+   *     itself would be wrong, since it owns no listener and converting it
+   *     with FIO_LS_EMBD_OBJ would produce a bogus pointer;
+   *   - stops when it arrives back at the head, meaning every real node
+   *     has been visited;
+   *   - runs zero times on an empty list, because a lone head simply
+   *     points at itself.
+   */
+  for (fio_ls_embd_s *pos = fio_accept_queue_listeners.next; pos != &fio_accept_queue_listeners; pos = pos->next) {
+    fio_listen_protocol_s *pr = FIO_LS_EMBD_OBJ(fio_listen_protocol_s, listener_node, pos);
+    struct tcp_info info;
+    socklen_t tlen = sizeof(info);
+    int fd = fio_uuid2fd(pr->uuid);
+
+    fio_lock(&fd_data(fd).protocol_lock);
+
+    /* Skip sockets that were closed or reused before we could query them.
+     * Callers must run this after listeners are attached (e.g. from within
+     * Iodine.run / a background thread), so the listener's protocol slot is
+     * populated and the checks below are meaningful. */
+    if (!uuid_is_valid(pr->uuid) || fd_data(fd).protocol != &pr->pr) {
+      fio_unlock(&fd_data(fd).protocol_lock);
+      continue;
+    }
+
+    int ok = !getsockopt(fd, IPPROTO_TCP, TCP_INFO, &info, &tlen);
+
+    fio_unlock(&fd_data(fd).protocol_lock);
+
+    if (!ok) {
+      continue;
+    }
+
+    backlog += (intptr_t)info.tcpi_unacked;
+  }
+  fio_unlock(&fio_accept_queue_lock);
+
+  return backlog;
+}
+#endif
+
 /* *****************************************************************************
 Section Start Marker
 

data/ext/iodine/fio.h

@@ -1111,6 +1111,19 @@ intptr_t fio_socket(const char *address, const char *port, uint8_t is_server);
  */
 intptr_t fio_accept(intptr_t srv_uuid);
 
+/**
+ * Returns the number of established connections currently parked in the
+ * kernel's accept queue(s) (sk_ack_backlog) of all iodine listening sockets.
+ *
+ * The query goes straight to the kernel via getsockopt(TCP_INFO).
+ *
+ * Returns the total accept queue length across all iodine listeners, or 0
+ * when there are no listeners.
+ */
+#if defined(__linux__)
+intptr_t fio_queued_connections(void);
+#endif /* linux only */
+
 /**
  * Returns 1 if the uuid refers to a valid and open, socket.
  *
@@ -1185,12 +1198,20 @@ size_t fio_local_addr(char *dest, size_t limit);
 ssize_t fio_read(intptr_t uuid, void *buffer, size_t count);
 
 /**
- * This is a complete copy of `fio_read` except that it doesn't attempt to force close the
- * socker on error.
+ * Performs a single read operation using the connection's read hook.
+ *
+ * The return value and errno match the underlying read operation. The socket
+ * isn't closed on error.
+ */
+ssize_t fio_read_once(intptr_t uuid, void *buffer, size_t count);
+
+/**
+ * Performs a single write operation using the connection's write hook.
  *
- * The method is currently used by the fiber scheduler.
+ * The return value and errno match the underlying write operation. The socket
+ * isn't closed on error and no data is queued for the reactor.
  */
-ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count);
+ssize_t fio_write_once(intptr_t uuid, const void *buffer, size_t count);
 
 /** The following structure is used for `fio_write2_fn` function arguments. */
 typedef struct {

data/ext/iodine/iodine.c

@@ -1401,6 +1401,9 @@ void Init_iodine_ext(void) {
   // initialize concurrency related methods
   iodine_defer_initialize();
 
+  // initialize performance metrics
+  iodine_perf_initialize();
+
   // initialize the connection class
   iodine_connection_init();
 

data/ext/iodine/iodine.h

@@ -42,6 +42,7 @@ typedef struct {
 #include "iodine_http.h"
 #include "iodine_json.h"
 #include "iodine_mustache.h"
+#include "iodine_perf.h"
 #include "iodine_pubsub.h"
 #include "iodine_rack_io.h"
 #include "iodine_store.h"

data/ext/iodine/iodine_defer.c

@@ -415,6 +415,7 @@ static void iodine_defer_on_finish(void *ignr) {
   iodine_join_io_thread();
 }
 
+
 /* *****************************************************************************
 Add defer API to Iodine
 ***************************************************************************** */

data/ext/iodine/iodine_perf.c

@@ -0,0 +1,28 @@
+#include "iodine.h"
+
+/* *****************************************************************************
+Performance metrics
+***************************************************************************** */
+
+/**
+ * Iodine::Perf.queued_connections
+ *
+ * Returns the total number of established connections currently parked in
+ * the kernel's accept queue(s) (sk_ack_backlog) for all iodine listening
+ * sockets. Returns 0 when there are no listeners and nil on non-Linux systems.
+ */
+static VALUE iodine_perf_queued_connections(VALUE self) {
+  (void)self;
+#if defined(__linux__)
+  intptr_t backlog = fio_queued_connections();
+  return INT2NUM((long)backlog);
+#else
+  return Qnil;
+#endif
+}
+
+void iodine_perf_initialize(void) {
+  VALUE IodinePerfModule = rb_define_module_under(IodineModule, "Perf");
+  rb_define_module_function(IodinePerfModule, "queued_connections",
+                            iodine_perf_queued_connections, 0);
+}

data/ext/iodine/iodine_perf.h

@@ -0,0 +1,6 @@
+#ifndef H_IODINE_PERF_H
+#define H_IODINE_PERF_H
+
+void iodine_perf_initialize(void);
+
+#endif

data/ext/iodine/scheduler.c

@@ -1,6 +1,8 @@
 #include "iodine.h"
 #include "iodine_store.h"
 #include "ruby.h"
+#include "ruby/fiber/scheduler.h"
+#include "ruby/io/buffer.h"
 
 #include <errno.h>
 #include <stddef.h>
@@ -10,7 +12,7 @@
 
 #include "fio.h"
 
-#define IO_MAX_READ 8192
+#define IO_MAX_READ 65536
 
 static ID call_id;
 static uint8_t ATTACH_ON_READ_READY_CALLBACK;
@@ -151,51 +153,104 @@ static VALUE iodine_scheduler_attach(VALUE self, VALUE r_fd, VALUE r_waittype, V
   (void)self;
 }
 
-static VALUE iodine_scheduler_write(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
+static VALUE iodine_scheduler_write_async(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
   Check_Type(r_fd, T_FIXNUM);
   int fd = FIX2INT(r_fd);
 
-  Check_Type(r_buffer, T_STRING);
-  char *buffer = RSTRING_PTR(r_buffer);
+  const void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_reading(r_buffer, &buffer, &buffer_length);
 
   Check_Type(r_length, T_FIXNUM);
-  int length = FIX2INT(r_length);
+  size_t length = NUM2SIZET(r_length);
 
   Check_Type(r_offset, T_FIXNUM);
-  int offset = FIX2INT(r_offset);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
+  if (!length) {
+    return r_length;
+  }
 
   void *cpy = fio_malloc(length);
-  memcpy(cpy, buffer, length);
-  fio_write2(fio_fd2uuid(fd), .data.buffer = cpy, .length = length, .offset = offset, .after.dealloc = fio_free);
+  memcpy(cpy, (const char *)buffer + offset, length);
+  fio_write2(fio_fd2uuid(fd), .data.buffer = cpy, .length = length, .after.dealloc = fio_free);
 
   return r_length;
 
   (void)self;
 }
 
-static VALUE iodine_scheduler_read(VALUE self, VALUE r_fd, VALUE r_length, VALUE r_offset) {
+static VALUE iodine_scheduler_write(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
   Check_Type(r_fd, T_FIXNUM);
   int fd = FIX2INT(r_fd);
 
+  const void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_reading(r_buffer, &buffer, &buffer_length);
+
   Check_Type(r_length, T_FIXNUM);
-  int length = FIX2INT(r_length);
+  size_t length = NUM2SIZET(r_length);
 
-  if (length == 0) {
-    length = IO_MAX_READ;
+  Check_Type(r_offset, T_FIXNUM);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
+  if (!length) {
+    return rb_fiber_scheduler_io_result(0, 0);
   }
 
-  intptr_t uuid = fio_fd2uuid(fd);
-  char buffer[length];
+  ssize_t result = fio_write_once(fio_fd2uuid(fd), (const char *)buffer + offset, length);
+  int error = result < 0 ? errno : 0;
+  return rb_fiber_scheduler_io_result(result, error);
+
+  (void)self;
+}
+
+static VALUE iodine_scheduler_read(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
+  Check_Type(r_fd, T_FIXNUM);
+  int fd = FIX2INT(r_fd);
+
+  void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_writing(r_buffer, &buffer, &buffer_length);
+
+  Check_Type(r_length, T_FIXNUM);
+  size_t length = NUM2SIZET(r_length);
+
+  Check_Type(r_offset, T_FIXNUM);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
 
-  ssize_t len = fio_read_unsafe(uuid, &buffer, length);
-  if (len == -1) {
-    return Qnil;
+  #if RUBY_FIBER_SCHEDULER_VERSION >= 4
+    if (length > IO_MAX_READ) {
+      length = IO_MAX_READ;
+    }
+  #else
+    if (length == 0) {
+      length = buffer_length - offset;
+      if (length > IO_MAX_READ) {
+        length = IO_MAX_READ;
+      }
+    }
+  #endif
+
+  if (!length) {
+    return rb_fiber_scheduler_io_result(0, 0);
   }
 
-  return rb_str_new(buffer, len);
+  ssize_t result = fio_read_once(fio_fd2uuid(fd), (char *)buffer + offset, length);
+  int error = result < 0 ? errno : 0;
+  return rb_fiber_scheduler_io_result(result, error);
 
   (void)self;
-  (void)r_offset;
 }
 
 static VALUE iodine_scheduler_close(VALUE self) {
@@ -219,8 +274,9 @@ void iodine_scheduler_initialize(void) {
   VALUE SchedulerModule = rb_define_module_under(IodineModule, "Scheduler");
 
   rb_define_module_function(SchedulerModule, "attach", iodine_scheduler_attach, 3);
+  rb_define_module_function(SchedulerModule, "write_async", iodine_scheduler_write_async, 4);
   rb_define_module_function(SchedulerModule, "write", iodine_scheduler_write, 4);
-  rb_define_module_function(SchedulerModule, "read", iodine_scheduler_read, 3);
+  rb_define_module_function(SchedulerModule, "read", iodine_scheduler_read, 4);
   rb_define_module_function(SchedulerModule, "close", iodine_scheduler_close, 0);
 
   VALUE cIO = rb_const_get(rb_cObject, rb_intern2("IO", 2));

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '5.5.0'.freeze
+  VERSION = '6.0.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 5.5.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Boaz Segev
@@ -217,6 +217,8 @@ files:
 - ext/iodine/iodine_json.h
 - ext/iodine/iodine_mustache.c
 - ext/iodine/iodine_mustache.h
+- ext/iodine/iodine_perf.c
+- ext/iodine/iodine_perf.h
 - ext/iodine/iodine_pubsub.c
 - ext/iodine/iodine_pubsub.h
 - ext/iodine/iodine_rack_io.c