rage-iodine 5.6.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ffa46cab7e0fb7fc7550dd142f42b0850287fee60cc0d72b7f52757f52720f7
-  data.tar.gz: c51b8ad9e316c21ed06e6803dcfb5af7bf70fc3eee84a0fd179b2730d2572473
+  metadata.gz: 1595ec4d4f155fbc845b37ad096018a2a4bfa4f884c0ef96b7112d268fe86e89
+  data.tar.gz: 3185d0901b132a329509238b5188dcd29de1d4145a018adda6b3f9f215e008cf
 SHA512:
-  metadata.gz: fa99ee4e7abb10b55b6f14aeeaef6bf03e85cf8aff9b33a66f7b4f64097c5ef824e0c3de6663caf00f5404b2d08b663debb60c796a0a44490138a96ac92a832c
-  data.tar.gz: ca2a4ac6f633955b202dccf09661cb7799ae92e16078ef3776c1648e18e2b1ab620f470f4b99b3c75b7d0e8f9b064fad180fd5c9b32ab6ae0ddd60c9d601b58d
+  metadata.gz: 4bbaa335fcd6202ac41a6449a5d8a38302c786b69348b66af733520e83c27bf4529c8a0e90dc7db5f19f8755aadfaf0c71edeb07fea904664b2cbf573da573f0
+  data.tar.gz: 991187eeb695f2128f83859e1025d62d580a1e41fc672822aaf7c8e5130edf15c83721e263a30799311766627fbd132393b50987486d137004f7ae439d11d0b8

data/CHANGELOG.md

@@ -6,6 +6,10 @@ 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

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;
 }
 
 /**

data/ext/iodine/fio.h

@@ -1198,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 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);
+
+/**
+ * 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);
 
 /** The following structure is used for `fio_write2_fn` function arguments. */
 typedef struct {

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.6.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.6.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Boaz Segev