farce 0.4.0-x86-linux-gnu → 0.5.0-x86-linux-gnu

data/ext/farce/queue.c

@@ -33,6 +33,8 @@ typedef struct {
 #endif
 } readiness_signal_t;
 
+typedef struct queue_wait_context queue_wait_context_t;
+
 typedef struct {
     pthread_mutex_t lock;
     VALUE *values;
@@ -44,8 +46,14 @@ typedef struct {
     size_t tail;
     size_t pop_waiters;
     size_t push_waiters;
+    VALUE interrupt_token;
+    uint64_t interrupt_generation;
+    size_t interrupt_pending;
+    queue_wait_context_t *interrupt_waiters;
     readiness_signal_t can_pop;
     readiness_signal_t can_push;
+    readiness_signal_t interrupts_drained;
+    size_t interrupt_drain_waiters;
     farce_unshared_wait_list_t unshared_pop_waiters;
     farce_unshared_wait_list_t unshared_push_waiters;
     bool bounded;
@@ -160,20 +168,25 @@ queue_update_readiness(queue_t *queue)
     }
     readiness_set(
         &queue->can_pop,
-        queue->pop_waiters > 0 && (queue->closed || queue->size > 0)
+        queue->pop_waiters > 0 && (queue->closed || queue->size > 0 || queue->interrupt_pending > 0)
     );
     readiness_set(
         &queue->can_push,
         queue->push_waiters > 0 &&
             (queue->sealed || !queue->bounded || queue->size < queue->limit)
     );
+    readiness_set(
+        &queue->interrupts_drained,
+        queue->interrupt_drain_waiters > 0 && (queue->closed || queue->interrupt_pending == 0)
+    );
     if (!queue->shared) {
         /* Keep the slow path until both waiter mechanisms and every pending
          * readiness byte have drained. Interrupted direct waits may leave the
          * flag set, which is harmless and corrected by the next mutation. */
         queue->unshared_notifications_needed = queue->pop_waiters || queue->push_waiters ||
             queue->unshared_pop_waiters.count || queue->unshared_push_waiters.count ||
-            queue->can_pop.set || queue->can_push.set;
+            queue->can_pop.set || queue->can_push.set ||
+            queue->interrupt_drain_waiters || queue->interrupts_drained.set;
     }
 }
 
@@ -181,6 +194,7 @@ static void
 queue_mark(void *pointer)
 {
     queue_t *queue = pointer;
+    rb_gc_mark_movable(queue->interrupt_token);
     farce_unshared_wait_mark(&queue->unshared_pop_waiters);
     farce_unshared_wait_mark(&queue->unshared_push_waiters);
     if (!queue->values) return;
@@ -195,6 +209,7 @@ static void
 queue_compact(void *pointer)
 {
     queue_t *queue = pointer;
+    containers_gc_update(&queue->interrupt_token);
     if (!queue->values) return;
     size_t index = queue->head;
     for (size_t remaining = queue->size; remaining > 0; remaining--) {
@@ -212,6 +227,7 @@ queue_free(void *pointer)
     free(queue->enqueued_at);
     readiness_close(&queue->can_pop);
     readiness_close(&queue->can_push);
+    readiness_close(&queue->interrupts_drained);
     ruby_xfree(queue);
 }
 
@@ -224,7 +240,7 @@ queue_memsize(const void *pointer)
 }
 
 static const rb_data_type_t queue_type = {
-    .wrap_struct_name = "Ractor::Containers::Queue",
+    .wrap_struct_name = "Farce::Internal::Queue",
     .function = {
         .dmark = queue_mark,
         .dfree = queue_free,
@@ -277,8 +293,14 @@ queue_allocate_type(VALUE klass, bool shared)
     queue->tail = 0;
     queue->pop_waiters = 0;
     queue->push_waiters = 0;
+    queue->interrupt_token = Qnil;
+    queue->interrupt_generation = 0;
+    queue->interrupt_pending = 0;
+    queue->interrupt_waiters = NULL;
     queue->can_pop = (readiness_signal_t){.read_fd = -1, .write_fd = -1, .set = false};
     queue->can_push = (readiness_signal_t){.read_fd = -1, .write_fd = -1, .set = false};
+    queue->interrupts_drained = (readiness_signal_t){.read_fd = -1, .write_fd = -1, .set = false};
+    queue->interrupt_drain_waiters = 0;
     queue->unshared_pop_waiters = (farce_unshared_wait_list_t){0};
     queue->unshared_push_waiters = (farce_unshared_wait_list_t){0};
     queue->bounded = true;
@@ -384,6 +406,8 @@ typedef struct {
     bool finite;
     bool collected;
     double deadline;
+    bool interruptible;
+    VALUE token;
 } queue_timeout_t;
 
 static double
@@ -449,13 +473,44 @@ queue_wait_for_descriptor(int fd, queue_timeout_t *timeout)
     return containers_wait_for_readable(fd, wait_timeout);
 }
 
-typedef struct {
+struct queue_wait_context {
     queue_t *queue;
     readiness_signal_t *signal;
     size_t *waiter_count;
     queue_timeout_t *timeout;
     int wait_fd;
-} queue_wait_context_t;
+    bool linked;
+    uint64_t generation;
+    queue_wait_context_t *previous;
+    queue_wait_context_t *next;
+};
+
+/* Keep a wakeup readable until every interrupted descriptor waiter has left.
+ * Registration and removal happen under the same queue lock as publication. */
+static void
+queue_register_interrupt_waiter(queue_wait_context_t *context)
+{
+    if (!context->timeout->interruptible || context->signal != &context->queue->can_pop) return;
+    queue_t *queue = context->queue;
+    context->generation = queue->interrupt_generation;
+    context->previous = NULL;
+    context->next = queue->interrupt_waiters;
+    if (context->next) context->next->previous = context;
+    queue->interrupt_waiters = context;
+    context->linked = true;
+}
+
+static void
+queue_remove_interrupt_waiter(queue_wait_context_t *context)
+{
+    if (!context->linked) return;
+    queue_t *queue = context->queue;
+    if (context->previous) context->previous->next = context->next;
+    else queue->interrupt_waiters = context->next;
+    if (context->next) context->next->previous = context->previous;
+    if (context->generation != queue->interrupt_generation) queue->interrupt_pending--;
+    context->linked = false;
+}
 
 static VALUE
 queue_wait_body(VALUE opaque)
@@ -527,6 +582,7 @@ queue_wait_cleanup(VALUE opaque)
     queue_wait_context_t *context = (queue_wait_context_t *)opaque;
     if (context->wait_fd >= 0) close(context->wait_fd);
     queue_lock(context->queue);
+    queue_remove_interrupt_waiter(context);
     (*context->waiter_count)--;
     queue_update_readiness(context->queue);
     if (context->queue->closed && *context->waiter_count == 0) {
@@ -588,8 +644,16 @@ queue_wait(VALUE self, queue_t *queue, readiness_signal_t *signal, size_t *waite
         queue_unlock(queue);
         return false;
     }
+    /* A fresh wait must not repeatedly consume readiness reserved for older
+     * interrupted fibers on the same scheduler. Wait for their acknowledgments
+     * on a separate signal, without joining the interrupted generation. */
+    if (signal == &queue->can_pop && queue->interrupt_pending > 0) {
+        signal = &queue->interrupts_drained;
+        waiter_count = &queue->interrupt_drain_waiters;
+    }
     if (!queue->shared) queue->unshared_notifications_needed = true;
-    if (!queue->shared && (!queue->unshared_fiber_io || NIL_P(rb_fiber_scheduler_current()))) {
+    if (signal != &queue->interrupts_drained && !queue->shared &&
+        (!queue->unshared_fiber_io || NIL_P(rb_fiber_scheduler_current()))) {
         farce_unshared_wait_list_t *list = signal == &queue->can_pop ?
             &queue->unshared_pop_waiters : &queue->unshared_push_waiters;
         return farce_unshared_wait(list, self, timeout->finite, timeout->deadline);
@@ -611,6 +675,7 @@ queue_wait(VALUE self, queue_t *queue, readiness_signal_t *signal, size_t *waite
             .timeout = timeout,
             .wait_fd = -1,
         };
+        queue_register_interrupt_waiter(&context);
         (*waiter_count)++;
         queue_update_readiness(queue);
         queue_unlock(queue);
@@ -632,6 +697,7 @@ queue_wait(VALUE self, queue_t *queue, readiness_signal_t *signal, size_t *waite
         .timeout = timeout,
         .wait_fd = wait_fd,
     };
+    queue_register_interrupt_waiter(&context);
     (*waiter_count)++;
     queue_update_readiness(queue);
     queue_unlock(queue);
@@ -664,7 +730,54 @@ static VALUE
 queue_capacity(VALUE self)
 {
     queue_t *queue = get_queue(self);
-    return queue->bounded ? SIZET2NUM(queue->limit) : Qnil;
+    queue_lock(queue);
+    bool bounded = queue->bounded;
+    size_t limit = queue->limit;
+    queue_unlock(queue);
+    return bounded ? SIZET2NUM(limit) : Qnil;
+}
+
+static VALUE
+queue_set_capacity(VALUE self, VALUE value)
+{
+    size_t limit = 0;
+    if (!NIL_P(value)) {
+        long long converted = NUM2LL(rb_to_int(value));
+        if (converted <= 0) rb_raise(rb_eArgError, "capacity must be positive or nil");
+        if ((unsigned long long)converted > SIZE_MAX / sizeof(VALUE)) rb_raise(rb_eArgError, "capacity is too large");
+        limit = (size_t)converted;
+    }
+    queue_t *queue = get_queue(self);
+    queue_lock(queue);
+    queue->bounded = !NIL_P(value);
+    queue->limit = limit;
+    queue_update_readiness(queue);
+    queue_unlock(queue);
+    return value;
+}
+
+static VALUE
+queue_interrupt(VALUE self, VALUE token, VALUE generation_value)
+{
+    queue_t *queue = get_queue(self);
+    if (queue->shared) containers_check_shareable(token);
+    uint64_t generation = NUM2ULL(generation_value);
+    queue_lock(queue);
+    /* Concurrent writers can finish their notifications out of order. */
+    if (!NIL_P(queue->interrupt_token) && generation <= queue->interrupt_generation) {
+        queue_unlock(queue);
+        return self;
+    }
+    RB_OBJ_WRITE(self, &queue->interrupt_token, token);
+    queue->interrupt_generation = generation;
+    queue->interrupt_pending = 0;
+    for (queue_wait_context_t *waiter = queue->interrupt_waiters; waiter; waiter = waiter->next) {
+        if (waiter->generation != generation) queue->interrupt_pending++;
+    }
+    if (!queue->shared) farce_unshared_wait_notify_all(&queue->unshared_pop_waiters);
+    queue_update_readiness(queue);
+    queue_unlock(queue);
+    return self;
 }
 
 /* Called with queue->lock held. The queue is unchanged if allocation fails.
@@ -719,7 +832,7 @@ queue_num_waiting(VALUE self)
     queue_t *queue = get_queue(self);
     size_t num_waiting;
     queue_lock(queue);
-    num_waiting = queue->pop_waiters + queue->push_waiters +
+    num_waiting = queue->pop_waiters + queue->push_waiters + queue->interrupt_drain_waiters +
         queue->unshared_pop_waiters.count + queue->unshared_push_waiters.count;
     queue_unlock(queue);
     return SIZET2NUM(num_waiting);
@@ -848,6 +961,7 @@ queue_close(VALUE self)
         queue_update_readiness(queue);
         if (queue->pop_waiters == 0) readiness_close(&queue->can_pop);
         if (queue->push_waiters == 0) readiness_close(&queue->can_push);
+        if (queue->interrupt_drain_waiters == 0) readiness_close(&queue->interrupts_drained);
     }
     queue_unlock(queue);
     return self;
@@ -862,6 +976,7 @@ queue_release_wait_descriptors(VALUE self)
     queue_lock(queue);
     if (queue->pop_waiters == 0) readiness_close(&queue->can_pop);
     if (queue->push_waiters == 0) readiness_close(&queue->can_push);
+    if (queue->interrupt_drain_waiters == 0) readiness_close(&queue->interrupts_drained);
     queue_unlock(queue);
     return self;
 }
@@ -871,6 +986,10 @@ queue_pop_with_timeout(VALUE self, queue_t *queue, queue_timeout_t timeout)
 {
     for (;;) {
         queue_lock(queue);
+        if (timeout.interruptible && timeout.token != queue->interrupt_token) {
+            queue_unlock(queue);
+            return Qfalse;
+        }
         if (queue->closed) {
             queue_unlock(queue);
             raise_queue_closed();
@@ -902,6 +1021,18 @@ queue_pop(int argc, VALUE *argv, VALUE self)
     return queue_pop_with_timeout(self, queue, timeout);
 }
 
+/* Pool dispatch uses positional arguments to avoid another keyword hash. */
+static VALUE
+queue_pop_interruptible(VALUE self, VALUE token, VALUE timeout_value)
+{
+    queue_timeout_t timeout = parse_timeout(timeout_value);
+    timeout.interruptible = true;
+    timeout.token = token;
+    VALUE result = queue_pop_with_timeout(self, get_queue(self), timeout);
+    RB_GC_GUARD(token);
+    return result;
+}
+
 static VALUE
 queue_try_pop(VALUE self)
 {
@@ -1042,6 +1173,9 @@ containers_init_queue(VALUE namespace)
     rb_define_method(unshared, "fiber_wait", unshared_queue_fiber_wait, 0);
     rb_define_method(cQueue, "initialize", queue_initialize, -1);
     rb_define_method(cQueue, "capacity", queue_capacity, 0);
+    rb_define_method(cQueue, "capacity=", queue_set_capacity, 1);
+    rb_define_method(cQueue, "interrupt", queue_interrupt, 2);
+    rb_define_method(cQueue, "pop_interruptible", queue_pop_interruptible, 2);
     rb_define_method(cQueue, "size", queue_size, 0);
     rb_define_method(cQueue, "num_waiting", queue_num_waiting, 0);
     rb_define_method(cQueue, "clear", queue_clear, 0);

data/ext/farce/reactor.c

@@ -345,6 +345,9 @@ void fs_watch_io(fs_state *s, fs_wait *w, int fd, int events, int group, long in
     }
 }
 
+// Cancel the outstanding futex operation before its caller releases the word.
+static void fs_cancel_futex(VALUE self, fs_wait *w);
+
 // Finish a wait and remove its watches and ready-queue entry.
 // A pending receive must stop using the buffer before cleanup can continue.
 // Clear Ruby references and keep the fiber's slot available for its next wait.
@@ -352,6 +355,12 @@ VALUE fs_retire(VALUE self, VALUE token) {
     fs_state *s = fs_get(self); fs_wait *w = fs_lookup(s, token);
     if (!w) return Qnil;
     if (w->receive_pending) fs_cancel_receive(self, w);
+    if (w->futex_pending) {
+        // Logical cancellation must not discard the lookup required by the CQE.
+        // Suppress resumption first, then consume the original completion.
+        w->status = 2;
+        fs_cancel_futex(self, w);
+    }
     ready_remove(s, w);
     fs_watch *watch = w->watches;
     while (watch) {
@@ -381,6 +390,56 @@ VALUE fs_retire(VALUE self, VALUE token) {
     return Qnil;
 }
 
+// Select asynchronous futex parking only for an installed, live native ring.
+// External schedulers require a later integration instead of a duck-typed hook.
+bool containers_futex_scheduler_supported(VALUE scheduler) {
+#ifdef FARCE_HAVE_URING_FUTEX
+    if (NIL_P(scheduler) || !rb_typeddata_is_kind_of(scheduler, &fs_type)) return false;
+    fs_state *s = fs_get(scheduler);
+    return s->driver == FS_URING_DRIVER && s->ring_live && s->futex_supported &&
+        !s->closed && !s->stopping && s->owner == rb_thread_current() &&
+        s->active == rb_fiber_current() && rb_fiber_scheduler_get() == scheduler &&
+        containers_futex_available();
+#else
+    return false;
+#endif
+}
+
+typedef struct {
+    VALUE self, token, timeout;
+    containers_futex_t *word;
+} fs_futex_wait;
+
+// Submit and park using one suspension. The surrounding ensure retains the word
+// until the kernel request has completed, even if timer setup or parking raises.
+static VALUE futex_wait_body(VALUE data) {
+    fs_futex_wait *wait = (fs_futex_wait *)data;
+    fs_state *s = fs_get(wait->self);
+    fs_wait *w = fs_lookup(s, wait->token);
+    int error = fs_driver_futex(s, w, wait->word);
+    if (error) rb_syserr_fail(error, "scheduler futex submission");
+    return rb_funcall(wait->self, rb_intern("wait_with_timeout"), 3,
+        wait->token, wait->timeout, Qfalse);
+}
+
+static VALUE futex_wait_cleanup(VALUE data) {
+    fs_futex_wait *wait = (fs_futex_wait *)data;
+    return fs_retire(wait->self, wait->token);
+}
+
+bool containers_futex_scheduler_wait(VALUE scheduler, containers_futex_t *word, VALUE timeout) {
+    if (!containers_futex_scheduler_supported(scheduler)) return true;
+    fs_futex_wait wait = {scheduler, fs_arm(scheduler), timeout, word};
+    return RTEST(rb_ensure(futex_wait_body, (VALUE)&wait, futex_wait_cleanup, (VALUE)&wait));
+}
+
+// Expose the backend capability privately so native-path validation cannot pass
+// by silently exercising a descriptor fallback.
+static VALUE futex_supported(VALUE self) {
+    fs_state *s = fs_get(self);
+    return !s->closed && !s->stopping && s->futex_supported && containers_futex_available() ? Qtrue : Qfalse;
+}
+
 // 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.
@@ -600,6 +659,27 @@ static int snapshot_fallback(st_data_t key, st_data_t value, st_data_t arg) {
 // Wake-pipe events ask the dispatcher to return to Ruby policy code.
 static void accept_event(VALUE self, fs_event *e) {
     fs_state *s = fs_get(self);
+    if (e->generation & FS_FUTEX) {
+        fs_wait *w = fs_lookup(s, ULL2NUM(e->generation & ~FS_OPERATION));
+        if (!w) return;
+        w->futex_pending = 0;
+        int error = e->error < 0 ? -e->error : 0;
+        if (error == ENOSYS || error == EOPNOTSUPP) s->futex_supported = 0;
+        if (!w->status) {
+            if (error == ENOSYS || error == EOPNOTSUPP) {
+                // Retry with the now-disabled capability, rather than reporting
+                // a timeout to consumers that have not reached their deadline.
+                fs_resume(self, w->token, Qtrue, Qnil);
+            } else {
+                // Early notification is reported as EAGAIN. Other interruptions
+                // also return to the container's condition/deadline check.
+                if (error != EAGAIN && error != EINTR && error != ECANCELED)
+                    w->native_error = error;
+                fs_resume(self, w->token, Qtrue, Qnil);
+            }
+        }
+        return;
+    }
     if (e->generation & FS_RECEIVE) {
         fs_wait *w = fs_lookup(s, ULL2NUM(e->generation & ~FS_RECEIVE));
         if (!w) return;
@@ -660,36 +740,44 @@ static void poll_ready(VALUE self) {
     if (s->poll_error || s->selected_pending) s->policy_pending = 1;
 }
 
-// Cancel an io_uring receive and wait until the original operation has finished.
-// Keep the caller's buffer locked throughout, because a cancellation reply alone
-// does not prove the kernel has stopped writing to it.
-void fs_cancel_receive(VALUE self, fs_wait *w) {
+// Cancel an operation and consume its original CQE before releasing storage.
+// Cancellation acknowledgements use zero userdata, so a delayed acknowledgement
+// cannot refer to an operation record or a subsequently reused suspension.
+static void cancel_operation(VALUE self, fs_wait *w, uint64_t kind, int *pending) {
 #ifdef FARCE_URING
     fs_state *s = fs_get(self);
     struct io_uring_sqe *entry = io_uring_get_sqe(&s->ring);
     if (!entry) {
         int result;
         do { result = io_uring_submit(&s->ring); } while (result == -EINTR);
-        if (result < 0) rb_bug("cannot submit pending scheduler receive");
+        if (result < 0) rb_bug("cannot submit pending scheduler operation");
         entry = io_uring_get_sqe(&s->ring);
         if (!entry) rb_bug("cannot reserve scheduler cancellation");
     }
-    io_uring_prep_cancel64(entry, FS_RECEIVE | NUM2ULL(w->token), 0);
+    io_uring_prep_cancel64(entry, kind | NUM2ULL(w->token), 0);
     entry->user_data = 0;
-    // Wait for the original receive CQE, not just the cancellation CQE. No Ruby
-    // fiber runs here, and the caller's buffer remains locked throughout.
-    while (w->receive_pending) {
+    // Do not run fibers here. The caller's buffer or futex word stays alive
+    // until the original completion, rather than just the cancellation reply.
+    while (*pending) {
         int result = io_uring_submit_and_wait(&s->ring, 1);
-        if (result < 0 && result != -EINTR) rb_bug("cannot acknowledge scheduler receive cancellation");
+        if (result < 0 && result != -EINTR) rb_bug("cannot acknowledge scheduler cancellation");
         s->timeout = 0;
         fs_driver_poll(s);
-        if (s->poll_error && s->poll_error != EINTR) rb_bug("cannot drain scheduler receive cancellation");
+        if (s->poll_error && s->poll_error != EINTR) rb_bug("cannot drain scheduler cancellation");
         for (int i = 0; i < s->event_count; i++) accept_event(self, &s->events[i]);
         rearm_events(s);
     }
 #endif
 }
 
+void fs_cancel_receive(VALUE self, fs_wait *w) {
+    cancel_operation(self, w, FS_RECEIVE, &w->receive_pending);
+}
+
+static void fs_cancel_futex(VALUE self, fs_wait *w) {
+    cancel_operation(self, w, FS_FUTEX, &w->futex_pending);
+}
+
 // Call a helper for every active wait, skipping empty slots and idle fibers.
 static void each_wait(fs_state *s, int (*callback)(st_data_t, st_data_t, st_data_t), st_data_t arg) {
     for (uint32_t i = 0; i < s->slot_count; i++) {
@@ -836,6 +924,7 @@ void farce_init_fiber_scheduler(VALUE internal) {
     rb_define_private_method(klass, "retire_wait", fs_retire, 1);
     rb_define_private_method(klass, "register_select", register_select, 3);
     rb_define_private_method(klass, "ready?", ready, 0);
+    rb_define_private_method(klass, "futex_supported?", futex_supported, 0);
     rb_define_private_method(klass, "pending?", pending, 0);
     rb_define_private_method(klass, "pending_count", pending_count, 0);
     rb_define_private_method(klass, "wakeup", wakeup, 0);

data/ext/farce/reactor.h

@@ -1,6 +1,7 @@
 #ifndef FARCE_FIBER_REACTOR_H
 #define FARCE_FIBER_REACTOR_H
 #include "containers.h"
+#include "futex.h"
 #include <ruby/io.h>
 #include <ruby/io/buffer.h>
 #include <ruby/thread.h>
@@ -21,6 +22,8 @@
 #define FS_WRITE 4
 #define FS_EVENTS 1024
 #define FS_RECEIVE (UINT64_C(1) << 63)
+#define FS_FUTEX (UINT64_C(1) << 62)
+#define FS_OPERATION (FS_RECEIVE | FS_FUTEX)
 #define FS_SLOT_BITS 20
 #define FS_SLOT_MASK ((1U << FS_SLOT_BITS) - 1)
 
@@ -45,7 +48,7 @@ struct fs_reg {
 struct fs_wait {
     VALUE token, fiber, value, error, groups, ios;
     uint32_t slot;
-    int status, events, selected, queued, native_error, receive_pending;
+    int status, events, selected, queued, native_error, receive_pending, futex_pending;
     fs_wait *ready_next, *ready_prev;
     fs_watch *watches;
     fs_watch first_watch;
@@ -62,7 +65,7 @@ typedef struct {
     size_t pending;
     uint64_t serial, generation, suspensions;
     unsigned immediate;
-    int selected_pending, receive_disabled;
+    int selected_pending, receive_disabled, futex_supported;
     int driver, descriptor, wake[2], closed;
     pthread_mutex_t wake_mutex;
 #ifdef FARCE_URING
@@ -85,6 +88,7 @@ static inline fs_state *fs_get(VALUE self) {
 int fs_driver_init(fs_state *s, int driver);
 int fs_driver_update(fs_state *s, fs_reg *reg, int events);
 int fs_driver_receive(fs_state *s, fs_wait *w, int fd, void *buffer, size_t size);
+int fs_driver_futex(fs_state *s, fs_wait *w, containers_futex_t *word);
 void fs_cancel_receive(VALUE self, fs_wait *w);
 void fs_driver_close(fs_state *s);
 void *fs_driver_poll(void *data);

data/ext/farce/signal.c

@@ -1,21 +1,16 @@
 #include "containers.h"
-#include "ruby/io.h"
+#include "native_wait.h"
 
-#include <errno.h>
-#include <fcntl.h>
 #include <math.h>
 #include <stdint.h>
 #include <time.h>
-#include <unistd.h>
 
 static VALUE cSignal;
 
 typedef struct containers_signal_waiter containers_signal_waiter_t;
 
 struct containers_signal_waiter {
-    int read_fd;
-    int write_fd;
-    bool notified;
+    containers_waiter_t notification;
     containers_signal_waiter_t *next;
 };
 
@@ -66,34 +61,13 @@ containers_signal_parse_timeout(VALUE value)
     return timeout;
 }
 
-static void
-containers_signal_set_fd_flags(int fd)
-{
-#ifdef _WIN32
-    (void)fd;
-#else
-    int flags = fcntl(fd, F_GETFL, 0);
-    if (flags >= 0) (void)fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-    flags = fcntl(fd, F_GETFD, 0);
-    if (flags >= 0) (void)fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
-#endif
-}
-
-/* Called with signal->lock held. Each waiter has a separate descriptor, so a
- * single broadcast makes every scheduled Fiber or native thread runnable. */
+/* Called with signal->lock held. The notification remains latched while
+ * the waiting caller selects its parking backend outside the state mutex. */
 static void
 containers_signal_notify_waiters_locked(containers_signal_t *signal)
 {
-    unsigned char byte = 1;
     for (containers_signal_waiter_t *waiter = signal->waiters; waiter; waiter = waiter->next) {
-        if (waiter->notified) continue;
-        ssize_t result;
-        do {
-            result = write(waiter->write_fd, &byte, 1);
-        } while (result < 0 && errno == EINTR);
-        if (result == 1 || (result < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))) {
-            waiter->notified = true;
-        }
+        (void)containers_waiter_notify(&waiter->notification);
     }
 }
 
@@ -112,7 +86,7 @@ containers_signal_memsize(const void *pointer)
 }
 
 static const rb_data_type_t containers_signal_type = {
-    .wrap_struct_name = "Ractor::Containers::Signal",
+    .wrap_struct_name = "Farce::Internal::Signal",
     .function = {
         .dmark = NULL,
         .dfree = containers_signal_free,
@@ -184,26 +158,14 @@ containers_signal_new(void)
     return containers_signal_initialize(signal);
 }
 
-static bool
-containers_signal_wait_for_descriptor(int fd, containers_signal_timeout_t *timeout)
-{
-    VALUE wait_timeout = Qnil;
-    if (timeout->finite) {
-        double remaining = timeout->deadline - containers_signal_monotonic_now();
-        if (remaining <= 0) return false;
-        wait_timeout = DBL2NUM(remaining);
-    }
-
-    return containers_wait_for_readable(fd, wait_timeout);
-}
-
 static VALUE
 containers_signal_wait_body(VALUE opaque)
 {
     containers_signal_wait_context_t *context = (containers_signal_wait_context_t *)opaque;
-    return containers_signal_wait_for_descriptor(context->waiter.read_fd, context->timeout)
-        ? Qtrue
-        : Qfalse;
+    return containers_waiter_wait(
+        &context->waiter.notification, &context->signal->lock,
+        context->timeout->finite, context->timeout->deadline, NULL
+    ) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -220,8 +182,7 @@ containers_signal_wait_cleanup(VALUE opaque)
         }
     }
     pthread_mutex_unlock(&context->signal->lock);
-    close(context->waiter.read_fd);
-    close(context->waiter.write_fd);
+    containers_waiter_close(&context->waiter.notification);
     return Qnil;
 }
 
@@ -232,24 +193,12 @@ containers_signal_wait_once(
     containers_signal_timeout_t *timeout
 )
 {
-    int descriptors[2];
-    if (pipe(descriptors) != 0) {
-        pthread_mutex_unlock(&signal->lock);
-        rb_sys_fail("pipe");
-    }
-    containers_signal_set_fd_flags(descriptors[0]);
-    containers_signal_set_fd_flags(descriptors[1]);
-
     containers_signal_wait_context_t context = {
         .signal = signal,
-        .waiter = {
-            .read_fd = descriptors[0],
-            .write_fd = descriptors[1],
-            .notified = false,
-            .next = signal->waiters,
-        },
+        .waiter = {.next = signal->waiters},
         .timeout = timeout,
     };
+    containers_waiter_init(&context.waiter.notification);
     signal->waiters = &context.waiter;
     pthread_mutex_unlock(&signal->lock);
     return RTEST(rb_ensure(
@@ -330,6 +279,10 @@ containers_signal_wait(int argc, VALUE *argv, VALUE self)
             pthread_mutex_unlock(&signal->lock);
             return ULL2NUM(generation);
         }
+        if (timeout.finite && timeout.deadline <= containers_signal_monotonic_now()) {
+            pthread_mutex_unlock(&signal->lock);
+            return containers_signal_timeout_result();
+        }
         bool awakened = containers_signal_wait_once(signal, &timeout);
         pthread_mutex_lock(&signal->lock);
         if (!awakened && signal->generation == observed) {