farce 0.1.0-aarch64-linux-gnu → 0.2.0-aarch64-linux-gnu

data/ext/farce/priority_queue.c

@@ -52,7 +52,7 @@ priority_queue_snapshot_string(VALUE string)
     rb_str_replace(copy, string);
     instance_variables = rb_obj_instance_variables(string);
     for (index = 0; index < RARRAY_LEN(instance_variables); index++) {
-        ID id = SYM2ID(RARRAY_AREF(instance_variables, index));
+        ID id = SYM2ID(rb_ary_entry(instance_variables, index));
         rb_ivar_set(copy, id, rb_ivar_get(string, id));
     }
     rb_obj_freeze(copy);
@@ -436,7 +436,7 @@ priority_queue_track_remove(priority_queue_t *queue, priority_queue_value_t *val
     queue->generation++;
 }
 
-static void priority_queue_wait_for_publication(priority_queue_t *queue);
+static void priority_queue_wait_for_publication(VALUE self, priority_queue_t *queue);
 
 typedef struct {
     VALUE receiver;
@@ -581,25 +581,27 @@ priority_queue_compact(void *pointer)
     dnode_t *node;
 
     if (!queue) return;
-    queue->owner_fiber = rb_gc_location(queue->owner_fiber);
-    queue->owner_ruby_thread = rb_gc_location(queue->owner_ruby_thread);
+    containers_gc_update(&queue->owner_fiber);
+    containers_gc_update(&queue->owner_ruby_thread);
     /* The VM already roots the running publisher. dcompact only refreshes the
      * unmarked identity handles if that Fiber or Thread moved. */
-    queue->publication_owner_fiber =
-        rb_gc_location(queue->publication_owner_fiber);
-    queue->publication_owner_ruby_thread =
-        rb_gc_location(queue->publication_owner_ruby_thread);
-    queue->signal = rb_gc_location(queue->signal);
-    queue->unshared_self = rb_gc_location(queue->unshared_self);
+    containers_gc_update(&queue->publication_owner_fiber);
+    containers_gc_update(&queue->publication_owner_ruby_thread);
+    containers_gc_update(&queue->signal);
+    containers_gc_update(&queue->unshared_self);
     for (node = dict_first(&queue->tree); node; node = dict_next(&queue->tree, node)) {
         priority_queue_bucket_t *bucket = (priority_queue_bucket_t *)node;
         priority_queue_value_t *entry;
-        bucket->priority = rb_gc_location(bucket->priority);
-        node->dict_key = (const void *)bucket->priority;
+        VALUE previous_priority = bucket->priority;
+        containers_gc_update(&bucket->priority);
+        if (previous_priority != bucket->priority) node->dict_key = (const void *)bucket->priority;
+        bool rebuild = false;
         for (entry = bucket->head; entry; entry = entry->next) {
-            entry->value = rb_gc_location(entry->value);
+            VALUE previous_value = entry->value;
+            containers_gc_update(&entry->value);
+            if (previous_value != entry->value) rebuild = true;
         }
-        priority_queue_identity_index_rebuild(bucket);
+        if (rebuild) priority_queue_identity_index_rebuild(bucket);
     }
 }
 
@@ -645,7 +647,11 @@ static const rb_data_type_t priority_queue_type = {
         .dsize = priority_queue_memsize,
         .dcompact = priority_queue_compact,
     },
-    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+    .flags =
+        RUBY_TYPED_WB_PROTECTED |
+        RUBY_TYPED_FROZEN_SHAREABLE |
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static const rb_data_type_t unshared_priority_queue_type = {
@@ -657,6 +663,7 @@ static const rb_data_type_t unshared_priority_queue_type = {
         .dcompact = priority_queue_compact,
     },
     .parent = &priority_queue_type,
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY | FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 /* The GVL protects the native fields within one Ractor. Keep the logical
@@ -737,7 +744,7 @@ priority_queue_get(VALUE self)
      * traversal cannot leak a usable half-published queue. The steady-state
      * path is one atomic load and does not touch the physical mutex. */
     if (priority_queue_publication_busy(state)) {
-        priority_queue_wait_for_publication(queue);
+        priority_queue_wait_for_publication(self, queue);
         state = RUBY_ATOMIC_LOAD(queue->publication_state);
     }
     if (state != PRIORITY_QUEUE_INITIALIZED) {
@@ -884,7 +891,7 @@ priority_queue_lock_wait_once(priority_queue_t *queue)
 }
 
 static void
-priority_queue_lock(priority_queue_t *queue, bool *acquired)
+priority_queue_lock(VALUE self, priority_queue_t *queue, bool *acquired)
 {
     VALUE current = rb_fiber_current();
     VALUE current_thread = rb_thread_current();
@@ -903,8 +910,8 @@ priority_queue_lock(priority_queue_t *queue, bool *acquired)
             rb_raise(rb_eThreadError, "deadlock; recursive priority queue access");
         }
         if (NIL_P(queue->owner_fiber) && !publication_busy) {
-            queue->owner_fiber = current;
-            queue->owner_ruby_thread = current_thread;
+            RB_OBJ_WRITE(self, &queue->owner_fiber, current);
+            RB_OBJ_WRITE(self, &queue->owner_ruby_thread, current_thread);
             *acquired = true;
             priority_queue_mutex_unlock(queue);
             return;
@@ -945,6 +952,7 @@ priority_queue_unlock(priority_queue_t *queue)
 }
 
 typedef struct {
+    VALUE self;
     priority_queue_t *queue;
     bool acquired;
 } priority_queue_publication_wait_t;
@@ -955,7 +963,7 @@ priority_queue_publication_wait_body(VALUE opaque)
     priority_queue_publication_wait_t *wait =
         (priority_queue_publication_wait_t *)opaque;
 
-    priority_queue_lock(wait->queue, &wait->acquired);
+    priority_queue_lock(wait->self, wait->queue, &wait->acquired);
     return Qnil;
 }
 
@@ -970,9 +978,10 @@ priority_queue_publication_wait_ensure(VALUE opaque)
 }
 
 static void
-priority_queue_wait_for_publication(priority_queue_t *queue)
+priority_queue_wait_for_publication(VALUE self, priority_queue_t *queue)
 {
     priority_queue_publication_wait_t wait = {
+        .self = self,
         .queue = queue,
         .acquired = false,
     };
@@ -991,6 +1000,7 @@ priority_queue_wait_for_publication(priority_queue_t *queue)
 typedef VALUE (*priority_queue_operation_t)(VALUE opaque);
 
 typedef struct {
+    VALUE self;
     priority_queue_t *queue;
     priority_queue_operation_t operation;
     VALUE argument;
@@ -1001,7 +1011,7 @@ static VALUE
 priority_queue_call_body(VALUE opaque)
 {
     priority_queue_call_t *call = (priority_queue_call_t *)opaque;
-    priority_queue_lock(call->queue, &call->acquired);
+    priority_queue_lock(call->self, call->queue, &call->acquired);
     return call->operation(call->argument);
 }
 
@@ -1016,12 +1026,14 @@ priority_queue_unlock_ensure(VALUE opaque)
 
 static VALUE
 priority_queue_call(
+    VALUE self,
     priority_queue_t *queue,
     priority_queue_operation_t operation,
     VALUE argument
 )
 {
     priority_queue_call_t call = {
+        .self = self,
         .queue = queue,
         .operation = operation,
         .argument = argument,
@@ -1217,7 +1229,7 @@ priority_queue_initialize_commit(VALUE opaque)
     queue->bounded = initialization->bounded;
     queue->capacity = initialization->capacity;
     queue->track_age = initialization->track_age;
-    queue->signal = initialization->signal;
+    RB_OBJ_WRITE(initialization->self, &queue->signal, initialization->signal);
     /* Publication installs its logical gate before marking the object shareable
      * and keeps that whole transition under nested ensure cleanup. */
     if (queue->shared) return priority_queue_publish_shareable(initialization);
@@ -1278,7 +1290,7 @@ priority_queue_initialize(int argc, VALUE *argv, VALUE self)
     priority_queue_check_initializable(self, queue);
 
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_initialize_commit,
         (VALUE)&initialization
     );
@@ -1363,7 +1375,7 @@ priority_queue_push_body(VALUE opaque)
         priority_queue_identity_index_prepare_insert(bucket->identity_index, push->value);
         entry = calloc(1, queue->track_age ? sizeof(priority_queue_tracked_value_t) : sizeof(priority_queue_value_t));
         if (!entry) rb_memerror();
-        entry->value = push->value;
+        RB_OBJ_WRITE(push->self, &entry->value, push->value);
         entry->previous = bucket->tail;
         entry->next = NULL;
         entry->identity_next = NULL;
@@ -1377,7 +1389,7 @@ priority_queue_push_body(VALUE opaque)
             free(entry);
             rb_memerror();
         }
-        entry->value = push->value;
+        RB_OBJ_WRITE(push->self, &entry->value, push->value);
         entry->previous = NULL;
         entry->next = NULL;
         entry->identity_next = NULL;
@@ -1393,7 +1405,7 @@ priority_queue_push_body(VALUE opaque)
         else {
             push->stored_priority = push->priority;
         }
-        bucket->priority = push->stored_priority;
+        RB_OBJ_WRITE(push->self, &bucket->priority, push->stored_priority);
         if (CLASS_OF(push->priority) == rb_cFloat) {
             bucket->float_priority = RFLOAT_VALUE(push->priority);
         }
@@ -1475,7 +1487,7 @@ priority_queue_push(VALUE self, VALUE priority, VALUE value)
         return priority_queue_push_locked((VALUE)&push);
     }
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_push_locked,
         (VALUE)&push
     );
@@ -1559,7 +1571,7 @@ priority_queue_read(VALUE self, priority_queue_read_kind_t kind, bool last)
         priority_queue_read_body((VALUE)&read);
     }
     else {
-        priority_queue_call(queue, priority_queue_read_body, (VALUE)&read);
+        priority_queue_call(self, queue, priority_queue_read_body, (VALUE)&read);
     }
     if (read.empty) return rb_block_given_p() ? rb_yield_values(0) : Qnil;
     return read.result;
@@ -1596,7 +1608,7 @@ priority_queue_pop_before(VALUE self, VALUE latest_priority)
         priority_queue_read_body((VALUE)&read);
     }
     else {
-        priority_queue_call(queue, priority_queue_read_body, (VALUE)&read);
+        priority_queue_call(self, queue, priority_queue_read_body, (VALUE)&read);
     }
     if (read.empty) return rb_block_given_p() ? rb_yield_values(0) : Qnil;
     return read.result;
@@ -1692,7 +1704,7 @@ priority_queue_delete(VALUE self, VALUE priority, VALUE value)
     if (queue->shared) priority_queue_check_shareable(priority);
     if (queue->shared) priority_queue_check_shareable(value);
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_delete_body,
         (VALUE)&deletion
     );
@@ -1713,7 +1725,7 @@ priority_queue_delete_match(VALUE self, VALUE priority, VALUE pattern)
     };
     if (queue->shared) priority_queue_check_shareable(priority);
     if (queue->shared) priority_queue_check_shareable(pattern);
-    return priority_queue_call(queue, priority_queue_delete_body, (VALUE)&deletion);
+    return priority_queue_call(self, queue, priority_queue_delete_body, (VALUE)&deletion);
 }
 
 static VALUE
@@ -1774,7 +1786,7 @@ priority_queue_delete_identity(VALUE self, VALUE priority, VALUE value)
     if (queue->shared) priority_queue_check_shareable(priority);
     if (queue->shared) priority_queue_check_shareable(value);
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_delete_identity_body,
         (VALUE)&deletion
     );
@@ -1799,7 +1811,7 @@ priority_queue_size(VALUE self)
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_size_body((VALUE)&operation);
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_size_body,
         (VALUE)&operation
     );
@@ -1819,7 +1831,7 @@ priority_queue_empty(VALUE self)
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_empty_body((VALUE)&operation);
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_empty_body,
         (VALUE)&operation
     );
@@ -1859,7 +1871,7 @@ priority_queue_seal(VALUE self)
     priority_queue_t *queue = priority_queue_get(self);
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_seal_body((VALUE)&operation);
-    return priority_queue_call(queue, priority_queue_seal_body, (VALUE)&operation);
+    return priority_queue_call(self, queue, priority_queue_seal_body, (VALUE)&operation);
 }
 
 static VALUE
@@ -1869,7 +1881,7 @@ priority_queue_clear(VALUE self)
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_clear_body((VALUE)&operation);
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_clear_body,
         (VALUE)&operation
     );
@@ -1893,7 +1905,7 @@ priority_queue_close(VALUE self)
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_close_body((VALUE)&operation);
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_close_body,
         (VALUE)&operation
     );
@@ -1913,7 +1925,7 @@ priority_queue_closed(VALUE self)
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_closed_body((VALUE)&operation);
     return priority_queue_call(
-        queue,
+        self, queue,
         priority_queue_closed_body,
         (VALUE)&operation
     );
@@ -1932,7 +1944,7 @@ priority_queue_sealed(VALUE self)
     priority_queue_t *queue = priority_queue_get(self);
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_sealed_body((VALUE)&operation);
-    return priority_queue_call(queue, priority_queue_sealed_body, (VALUE)&operation);
+    return priority_queue_call(self, queue, priority_queue_sealed_body, (VALUE)&operation);
 }
 
 static VALUE
@@ -1955,7 +1967,7 @@ priority_queue_generation(VALUE self)
     if (!queue->track_age) return Qnil;
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_generation_body((VALUE)&operation);
-    return priority_queue_call(queue, priority_queue_generation_body, (VALUE)&operation);
+    return priority_queue_call(self, queue, priority_queue_generation_body, (VALUE)&operation);
 }
 
 static VALUE
@@ -1973,7 +1985,7 @@ priority_queue_oldest_enqueued_at(VALUE self)
     if (!queue->track_age) return Qnil;
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_oldest_body((VALUE)&operation);
-    return priority_queue_call(queue, priority_queue_oldest_body, (VALUE)&operation);
+    return priority_queue_call(self, queue, priority_queue_oldest_body, (VALUE)&operation);
 }
 
 static VALUE
@@ -1991,7 +2003,7 @@ priority_queue_oldest_age(VALUE self)
     if (!queue->track_age) return Qnil;
     priority_queue_self_operation_t operation = {.queue = queue, .self = self};
     if (priority_queue_can_run_direct(queue)) return priority_queue_oldest_age_body((VALUE)&operation);
-    return priority_queue_call(queue, priority_queue_oldest_age_body, (VALUE)&operation);
+    return priority_queue_call(self, queue, priority_queue_oldest_age_body, (VALUE)&operation);
 }
 
 static VALUE

data/ext/farce/queue.c

@@ -198,7 +198,7 @@ queue_compact(void *pointer)
     if (!queue->values) return;
     size_t index = queue->head;
     for (size_t remaining = queue->size; remaining > 0; remaining--) {
-        queue->values[index] = rb_gc_location(queue->values[index]);
+        containers_gc_update(&queue->values[index]);
         if (++index == queue->storage_capacity) index = 0;
     }
 }
@@ -231,7 +231,11 @@ static const rb_data_type_t queue_type = {
         .dsize = queue_memsize,
         .dcompact = queue_compact,
     },
-    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+    .flags =
+        RUBY_TYPED_WB_PROTECTED |
+        RUBY_TYPED_FROZEN_SHAREABLE |
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static const rb_data_type_t unshared_queue_type = {
@@ -243,6 +247,7 @@ static const rb_data_type_t unshared_queue_type = {
         .dcompact = queue_compact,
     },
     .parent = &queue_type,
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY | FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 /* Unshared queues are confined to one Ractor. These critical sections call no
@@ -662,7 +667,8 @@ queue_capacity(VALUE self)
     return queue->bounded ? SIZET2NUM(queue->limit) : Qnil;
 }
 
-/* Called with queue->lock held. The queue is unchanged if allocation fails. */
+/* Called with queue->lock held. The queue is unchanged if allocation fails.
+ * Ruby allocators could trigger GC while a peer is blocked on this mutex. */
 static bool
 queue_grow(queue_t *queue)
 {
@@ -921,7 +927,7 @@ queue_push_with_timeout(VALUE self, queue_t *queue, VALUE value, queue_timeout_t
                 queue_unlock(queue);
                 rb_memerror();
             }
-            queue->values[queue->tail] = value;
+            RB_OBJ_WRITE(self, &queue->values[queue->tail], value);
             if (queue->track_age) queue->enqueued_at[queue->tail] = monotonic_now();
             if (++queue->tail == queue->storage_capacity) queue->tail = 0;
             queue->size++;

data/ext/farce/reactor.c

@@ -9,21 +9,46 @@
 // Tell Ruby's garbage collector which Ruby objects one fiber's wait still needs.
 static int mark_wait(st_data_t key, st_data_t value, st_data_t arg) {
     fs_wait *w = (fs_wait *)value;
-    rb_gc_mark(w->fiber); rb_gc_mark(w->token); rb_gc_mark(w->value);
-    rb_gc_mark(w->error); rb_gc_mark(w->groups); rb_gc_mark(w->ios);
+    rb_gc_mark_movable(w->fiber); rb_gc_mark_movable(w->token); rb_gc_mark_movable(w->value);
+    rb_gc_mark_movable(w->error); rb_gc_mark_movable(w->groups); rb_gc_mark_movable(w->ios);
     return ST_CONTINUE;
 }
 
 // Keep the scheduler's Ruby objects alive, including fibers that are starting or waiting.
 static void mark(void *data) {
     fs_state *s = data;
-    rb_gc_mark(s->root); rb_gc_mark(s->active);
-    for (fs_admission *a = s->admission; a; a = a->previous) { rb_gc_mark(a->parent); rb_gc_mark(a->child); }
-    rb_gc_mark(s->owner);
-    rb_gc_mark(s->backend); rb_gc_mark(s->fallback);
+    rb_gc_mark_movable(s->root); rb_gc_mark_movable(s->active);
+    for (fs_admission *a = s->admission; a; a = a->previous) { rb_gc_mark_movable(a->parent); rb_gc_mark_movable(a->child); }
+    rb_gc_mark_movable(s->owner);
+    rb_gc_mark_movable(s->backend); rb_gc_mark_movable(s->fallback);
     if (s->fibers) st_foreach(s->fibers, mark_wait, 0);
 }
 
+// Update wait references and the table's fiber identity keys together.
+static int compact_wait(st_data_t key, st_data_t value, st_data_t arg, int error) {
+    fs_wait *w = (fs_wait *)value;
+    containers_gc_update(&w->fiber); containers_gc_update(&w->token);
+    containers_gc_update(&w->value); containers_gc_update(&w->error);
+    containers_gc_update(&w->groups); containers_gc_update(&w->ios);
+    return key == (st_data_t)w->fiber ? ST_CONTINUE : ST_REPLACE;
+}
+
+static int compact_wait_key(st_data_t *key, st_data_t *value, st_data_t arg, int existing) {
+    *key = (st_data_t)((fs_wait *)*value)->fiber;
+    return ST_CONTINUE;
+}
+
+static void compact(void *data) {
+    fs_state *s = data;
+    containers_gc_update(&s->root); containers_gc_update(&s->active);
+    containers_gc_update(&s->owner); containers_gc_update(&s->backend);
+    containers_gc_update(&s->fallback);
+    for (fs_admission *a = s->admission; a; a = a->previous) {
+        containers_gc_update(&a->parent); containers_gc_update(&a->child);
+    }
+    if (s->fibers) st_foreach_with_replace(s->fibers, compact_wait, compact_wait_key, 0);
+}
+
 // Free a fiber's wait record and any extra IO watches it owns.
 // The first watch is stored inside the record and needs no separate free.
 static int free_wait(st_data_t key, st_data_t value, st_data_t arg) {
@@ -97,8 +122,8 @@ static size_t memsize(const void *data) {
 // Describe how Ruby should mark, free, and measure the native scheduler object.
 const rb_data_type_t fs_type = {
     .wrap_struct_name = "Farce::Internal::FiberScheduler",
-    .function = {.dmark = mark, .dfree = free_state, .dsize = memsize},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+    .function = {.dmark = mark, .dfree = free_state, .dsize = memsize, .dcompact = compact},
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY | FARCE_TYPED_THREAD_SAFE_FREE
 };
 
 // Create an empty scheduler in a closed state.
@@ -128,8 +153,8 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self) {
     }
     fs_state *s = fs_get(self);
     if (!NIL_P(s->owner)) rb_raise(rb_eRuntimeError, "scheduler already initialized");
-    s->owner = rb_thread_current();
-    s->root = rb_fiber_current();
+    RB_OBJ_WRITE(self, &s->owner, rb_thread_current());
+    RB_OBJ_WRITE(self, &s->root, rb_fiber_current());
     s->fibers = st_init_numtable();
     int driver = 0;
     if (backend == ID2SYM(rb_intern("auto"))) {
@@ -144,7 +169,7 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self) {
     else rb_raise(rb_eArgError, "unknown native scheduler backend");
     int error = fs_driver_init(s, driver);
     if (error) rb_syserr_fail(error, "requested fiber scheduler backend is unavailable");
-    s->backend = backend;
+    RB_OBJ_WRITE(self, &s->backend, backend);
     if (s->descriptor >= 0) fcntl(s->descriptor, F_SETFD, FD_CLOEXEC);
     if (pipe(s->wake) < 0) rb_sys_fail("scheduler wake pipe");
     for (int i = 0; i < 2; i++) {
@@ -212,7 +237,7 @@ VALUE fs_arm_checked(VALUE self) {
     fs_slot *slot = &s->slots[w->slot];
     if (slot->generation == (UINT64_MAX >> (FS_SLOT_BITS + 2))) rb_raise(rb_eRangeError, "scheduler generation exhausted");
     VALUE token = ULL2NUM((++slot->generation << FS_SLOT_BITS) | w->slot);
-    w->token = token; w->status = w->events = w->selected = w->native_error = 0;
+    RB_OBJ_WRITE(self, &w->token, token); w->status = w->events = w->selected = w->native_error = 0;
     w->value = w->error = w->groups = w->ios = Qnil;
     s->pending++;
     return token;
@@ -257,7 +282,7 @@ static fs_wait *ready_pop(fs_state *s) {
 VALUE fs_resume(VALUE self, VALUE token, VALUE value, VALUE error) {
     fs_state *s = fs_get(self); fs_wait *w = fs_lookup(s, token);
     if (!w || w->status != 0) return Qfalse;
-    w->status = 1; w->value = value; w->error = error;
+    w->status = 1; RB_OBJ_WRITE(self, &w->value, value); RB_OBJ_WRITE(self, &w->error, error);
     ready_push(s, w); return Qtrue;
 }
 
@@ -273,7 +298,7 @@ static VALUE interrupt(VALUE self, VALUE token, VALUE error) {
     fs_state *s = fs_get(self); fs_wait *w = fs_lookup(s, token);
     if (!w || w->status == 2) return Qfalse;
     if (!w->status) ready_push(s, w);
-    w->status = 1; w->error = error; return Qtrue;
+    w->status = 1; RB_OBJ_WRITE(self, &w->error, error); return Qtrue;
 }
 
 // Declare the closed-IO check used below to detect descriptor reuse.
@@ -359,14 +384,14 @@ VALUE fs_retire(VALUE self, VALUE token) {
 // Switch from the root to a ready fiber.
 // If a newly started child finishes, return control to its waiting parent
 // before returning to the root dispatcher.
-static VALUE transfer_to(fs_state *s, VALUE fiber) {
-    s->active = fiber;
+static VALUE transfer_to(VALUE self, fs_state *s, VALUE fiber) {
+    RB_OBJ_WRITE(self, &s->active, fiber);
     VALUE result = rb_fiber_transfer(fiber, 0, NULL);
     s->active = Qnil;
     // A transferred fiber returns to the thread root when its block finishes.
     // Complete nested immediate admissions before returning to the driver.
     while (s->admission && s->admission->parent != s->root) {
-        s->active = s->admission->parent;
+        RB_OBJ_WRITE(self, &s->active, s->admission->parent);
         result = rb_fiber_transfer(s->admission->parent, 0, NULL);
         s->active = Qnil;
     }
@@ -377,8 +402,8 @@ static VALUE transfer_to(fs_state *s, VALUE fiber) {
 static VALUE start_body(VALUE data) {
     VALUE *args = (VALUE *)data;
     fs_state *s = fs_get(args[0]);
-    if (rb_fiber_current() == s->root) return transfer_to(s, args[1]);
-    s->active = args[1];
+    if (rb_fiber_current() == s->root) return transfer_to(args[0], s, args[1]);
+    RB_OBJ_WRITE(args[0], &s->active, args[1]);
     return rb_fiber_transfer(args[1], 0, NULL);
 }
 
@@ -387,7 +412,7 @@ static VALUE start_body(VALUE data) {
 static VALUE start_cleanup(VALUE data) {
     VALUE *args = (VALUE *)data;
     fs_state *s = fs_get(args[0]);
-    s->active = s->admission->parent == s->root ? Qnil : s->admission->parent;
+    RB_OBJ_WRITE(args[0], &s->active, s->admission->parent == s->root ? Qnil : s->admission->parent);
     s->admission = s->admission->previous;
     return Qnil;
 }
@@ -410,9 +435,11 @@ static VALUE start_fiber(VALUE self, VALUE fiber) {
         index = s->slot_count++;
     }
     fs_wait *w = ZALLOC(fs_wait); w->slot = index; s->slots[index].wait = w;
-    w->fiber = fiber; w->token = w->value = w->error = w->groups = w->ios = Qnil;
+    RB_OBJ_WRITE(self, &w->fiber, fiber); w->token = w->value = w->error = w->groups = w->ios = Qnil;
     st_insert(s->fibers, (st_data_t)fiber, (st_data_t)w);
     fs_admission admission = {rb_fiber_current(), fiber, s->admission};
+    RB_OBJ_WRITTEN(self, Qundef, admission.parent);
+    RB_OBJ_WRITTEN(self, Qundef, admission.child);
     s->admission = &admission;
     VALUE args[] = {self, fiber};
     return rb_ensure(start_body, (VALUE)args, start_cleanup, (VALUE)args);
@@ -441,9 +468,9 @@ static VALUE park_body(VALUE data) {
             break;
         }
     }
-    s->active = next == s->root ? Qnil : next;
+    RB_OBJ_WRITE(args[0], &s->active, next == s->root ? Qnil : next);
     rb_fiber_transfer(next, 0, NULL);
-    s->active = current;
+    RB_OBJ_WRITE(args[0], &s->active, current);
     fs_wait *w = fs_lookup(fs_get(args[0]), args[1]);
     if (!w) rb_raise(rb_eRuntimeError, "retired scheduler suspension");
     if (!NIL_P(w->error)) rb_exc_raise(w->error);
@@ -486,7 +513,7 @@ VALUE fs_checkpoint(VALUE self, VALUE value) {
 // Keep the original groups so the result can return the caller's objects.
 static VALUE register_select(VALUE self, VALUE token, VALUE groups, VALUE ios) {
     fs_state *s = fs_get(self); fs_wait *w = fs_lookup(s, token);
-    w->groups = groups; w->ios = ios;
+    RB_OBJ_WRITE(self, &w->groups, groups); RB_OBJ_WRITE(self, &w->ios, ios);
     for (int i = 0; i < 3; i++) {
         VALUE list = rb_ary_entry(ios, i);
         for (long j = 0; j < RARRAY_LEN(list); j++)
@@ -728,7 +755,7 @@ drain_ready:;
         if (w->status != 1) continue;
         w->status = 2;
         s->dispatch_left--;
-        transfer_to(s, w->fiber);
+        transfer_to(self, s, w->fiber);
     }
     int count = limit - s->dispatch_left;
     s->dispatch_left = 0;

data/ext/farce/reactor.h

@@ -1,6 +1,6 @@
 #ifndef FARCE_FIBER_REACTOR_H
 #define FARCE_FIBER_REACTOR_H
-#include <ruby.h>
+#include "containers.h"
 #include <ruby/io.h>
 #include <ruby/io/buffer.h>
 #include <ruby/thread.h>

data/ext/farce/signal.c

@@ -119,7 +119,11 @@ static const rb_data_type_t containers_signal_type = {
         .dsize = containers_signal_memsize,
         .dcompact = NULL,
     },
-    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+    .flags =
+        RUBY_TYPED_WB_PROTECTED |
+        RUBY_TYPED_FROZEN_SHAREABLE |
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        FARCE_TYPED_THREAD_SAFE_FREE,
 };
 
 static VALUE