uringmachine 0.19 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e4b4b986a75268a9de9dbafacd7d2a5c31cc08058b86a9681757be698fe697e
-  data.tar.gz: 99007eb49069d9cfebc70ce6da9c45cbbd5e7c4d518892869ddcb55c401b1cdb
+  metadata.gz: ff89f34d541e086f8016156d4b5290a6a2fdc94292f04e7a3104ef9e7cda256d
+  data.tar.gz: 01dbe57b83effbab744fbd07461dcd803246a88bbf3ce1aeaf1e4eace32fd0ad
 SHA512:
-  metadata.gz: f7c55065ac4aef687f91236bf5cb55be4756dee002e61e627775a93d74d069a8ca45372c43cc71d31efce4b33cfb623443a7ef53b929563b48ec8a0e59cbdf92
-  data.tar.gz: 066a85ff0f7218e410abdc89e63cc20ae1ff858ecbc857a84f83ab812286fb1f6dd099d44e254452f466d66569046de3cffe0ba9d7d4f52bb1717670a34c5398
+  metadata.gz: ca0e44f1121384634b4234b2cd49643f87e8255e77eb250f64fb62be8bcdcb18e6a82480e5da003322c941c9ae2def119a048797d53bc064c4e1f77796b82c4d
+  data.tar.gz: 322090fd12498525d303b63f66ec1c559ed9933e89e74d3b01c9cc5c0f3f1dcee951c767625690c288478d5e460248418bbd693fbd7c31146c7aff76cf545a5d

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.19.1 2025-01-03
+
+- Add `RB_GC_GUARD` in `process_runqueue_op`
+
 # 0.19 2025-10-27
 
 - Fix usage of `RAISE_IF_EXCEPTION` after `RB_GC_GUARD`

data/TODO.md

@@ -1,3 +1,44 @@
+## immediate
+
+- make a reproducer for segfault on timeout, spin lots of fibers where a timeout
+  wraps a #shift call (from an empty queue).
+- see also: https://mensfeld.pl/2025/11/ruby-ffi-gc-bug-hash-becomes-string/
+
+Analysis:
+
+- The segfault is related to timeouts
+- Looking at process_runqueue_op (um.c):
+
+  ```c
+  inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
+    VALUE fiber = op->fiber;
+    VALUE value = op->value;
+
+    // on timeout, the op flags are changed to turn on OP_F_TRANSIENT
+    if (unlikely(op->flags & OP_F_TRANSIENT))
+      // here the op is freed, so the value is not visible to the GC anymoore
+      um_op_free(machine, op);
+
+    // if a GC occurs here, we risk a segfault
+
+    // value is used
+    return rb_fiber_transfer(fiber, 1, &value);
+  }
+  ```
+
+- So, a possible solution is to put a `RB_GC_GUARD` after the `return`.
+- But first, I want to be able to reproduce it. We can start by setting
+  `GC.stress = true` on tests and see if we segfault.
+
+## FiberScheduler implementation
+
+Some resources:
+
+- https://github.com/socketry/async/blob/main/context/getting-started.md
+- https://github.com/socketry/async/blob/main/context/scheduler.md
+- https://github.com/socketry/async/blob/main/lib/async/scheduler.rb#L28
+- 
+
 ## useful concurrency tools
 
 - debounce

data/ext/um/um.c

@@ -194,7 +194,10 @@ inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
   if (unlikely(op->flags & OP_F_TRANSIENT))
     um_op_free(machine, op);
 
-  return rb_fiber_transfer(fiber, 1, &value);
+  VALUE ret = rb_fiber_transfer(fiber, 1, &value);
+  RB_GC_GUARD(value);
+  RB_GC_GUARD(ret);
+  return ret;
 }
 
 inline VALUE um_fiber_switch(struct um *machine) {
@@ -266,6 +269,7 @@ inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind,
   VALUE fiber = (flags & OP_F_FREE_ON_COMPLETE) ? Qnil : rb_fiber_current();
   RB_OBJ_WRITE(machine->self, &op->fiber, fiber);
   RB_OBJ_WRITE(machine->self, &op->value, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 }
 
 inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
@@ -275,6 +279,7 @@ inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
   op->flags = OP_F_TRANSIENT;
   RB_OBJ_WRITE(machine->self, &op->fiber, fiber);
   RB_OBJ_WRITE(machine->self, &op->value, value);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
   um_runqueue_push(machine, op);
 }
 
@@ -311,6 +316,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
   op->ts = um_double_to_timespec(NUM2DBL(interval));
   RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());
   RB_OBJ_WRITE(machine->self, &op->value, rb_funcall(class, ID_new, 0));
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_timeout(sqe, &op->ts, 0, 0);
@@ -407,7 +413,9 @@ VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
 VALUE um_write_async(struct um *machine, int fd, VALUE str) {
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_WRITE_ASYNC, OP_F_TRANSIENT | OP_F_FREE_ON_COMPLETE);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
   RB_OBJ_WRITE(machine->self, &op->value, str);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_write(sqe, fd, RSTRING_PTR(str), RSTRING_LEN(str), -1);
@@ -434,6 +442,9 @@ VALUE um_close(struct um *machine, int fd) {
 VALUE um_close_async(struct um *machine, int fd) {
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_CLOSE_ASYNC, OP_F_FREE_ON_COMPLETE);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_close(sqe, fd);
@@ -643,6 +654,10 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
 VALUE um_shutdown_async(struct um *machine, int fd, int how) {
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_SHUTDOWN_ASYNC, OP_F_FREE_ON_COMPLETE);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
+
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_shutdown(sqe, fd, how);
 

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.19'
+  VERSION = '0.19.1'
 end

data/test/test_um.rb

@@ -142,6 +142,31 @@ class ScheduleTest < UMBaseTest
     assert_kind_of TOError, e
   end
 
+  def test_timeout_stress
+    skip
+    # GC.stress = true
+    c = 0
+    fs = 100.times.map {
+      machine.spin {
+        q = UM::Queue.new
+        1000.times {
+          machine.sleep rand(0.001..0.005)
+          begin
+            machine.timeout(rand(0.001..0.06), TOError) do
+              machine.shift(q)
+            end
+          rescue => _e
+            c += 1
+            STDOUT << '*' if c % 1000 == 0
+          end
+        }
+      }
+    }
+    machine.join(*fs)
+  ensure
+    GC.stress = false    
+  end
+
   def test_timeout_with_raising_block
     e = nil
     begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: '0.19'
+  version: 0.19.1
 platform: ruby
 authors:
 - Sharon Rosner