farce 0.4.0 → 0.4.1

data/ext/farce/lock.c

@@ -1,19 +1,13 @@
 #include "containers.h"
+#include "native_wait.h"
 #include "ruby/fiber/scheduler.h"
-#include "ruby/io.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <unistd.h>
 
 static VALUE cLock;
 
 typedef struct containers_lock_waiter containers_lock_waiter_t;
 
 struct containers_lock_waiter {
-    int read_fd;
-    int write_fd;
-    bool notified;
+    containers_waiter_t notification;
     containers_lock_waiter_t *next;
 };
 
@@ -29,7 +23,6 @@ typedef struct {
 typedef struct {
     containers_lock_t *lock;
     containers_lock_waiter_t waiter;
-    bool completed;
 } containers_lock_wait_context_t;
 
 typedef struct {
@@ -51,35 +44,14 @@ typedef struct {
     VALUE opaque;
 } containers_lock_call_context_t;
 
-static void
-containers_lock_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 lock->guard held. Mutex wakeups only need to make one waiter
- * runnable; the selected waiter remains linked until its ensure cleanup. */
+/* Called with lock->guard held. The selected waiter remains linked until
+ * ensure cleanup, and its notification latches before backend selection. */
 static void
 containers_lock_notify_one_locked(containers_lock_t *lock)
 {
-    unsigned char byte = 1;
     for (containers_lock_waiter_t *waiter = lock->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;
-            return;
-        }
+        if (waiter->notification.notified) continue;
+        if (containers_waiter_notify(&waiter->notification)) return;
     }
 }
 
@@ -104,7 +76,7 @@ RUBY_REFERENCES(containers_lock_references) = {
 };
 
 static const rb_data_type_t containers_lock_type = {
-    .wrap_struct_name = "Ractor::Containers::Lock",
+    .wrap_struct_name = "Farce::Internal::Lock",
     .function = {
         .dmark = RUBY_REFS_LIST_PTR(containers_lock_references),
         .dfree = containers_lock_free,
@@ -188,19 +160,13 @@ containers_lock_initialize_copy(VALUE self, VALUE other)
     return containers_publish_native_with_references(self, containers_lock_validate_references);
 }
 
-static bool
-containers_lock_wait_for_descriptor(int fd)
-{
-    return containers_wait_for_readable(fd, Qnil);
-}
-
 static VALUE
 containers_lock_wait_body(VALUE opaque)
 {
     containers_lock_wait_context_t *context = (containers_lock_wait_context_t *)opaque;
-    bool awakened = containers_lock_wait_for_descriptor(context->waiter.read_fd);
-    context->completed = true;
-    return awakened ? Qtrue : Qfalse;
+    return containers_waiter_wait(
+        &context->waiter.notification, &context->lock->guard, false, 0, NULL
+    ) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -221,12 +187,13 @@ containers_lock_wait_cleanup(VALUE opaque)
         }
         previous = *link;
     }
-    if (!context->completed && context->waiter.notified && NIL_P(context->lock->owner)) {
+    /* A wake does not reserve ownership. Pass the baton even on a normal
+     * return, since cancellation can arrive before the caller claims the lock. */
+    if (context->waiter.notification.notified && NIL_P(context->lock->owner)) {
         containers_lock_notify_one_locked(context->lock);
     }
     pthread_mutex_unlock(&context->lock->guard);
-    close(context->waiter.read_fd);
-    close(context->waiter.write_fd);
+    containers_waiter_close(&context->waiter.notification);
     return Qnil;
 }
 
@@ -234,24 +201,11 @@ containers_lock_wait_cleanup(VALUE opaque)
 static void
 containers_lock_wait_once(containers_lock_t *lock)
 {
-    int descriptors[2];
-    if (pipe(descriptors) != 0) {
-        pthread_mutex_unlock(&lock->guard);
-        rb_sys_fail("pipe");
-    }
-    containers_lock_set_fd_flags(descriptors[0]);
-    containers_lock_set_fd_flags(descriptors[1]);
-
     containers_lock_wait_context_t context = {
         .lock = lock,
-        .waiter = {
-            .read_fd = descriptors[0],
-            .write_fd = descriptors[1],
-            .notified = false,
-            .next = NULL,
-        },
-        .completed = false,
+        .waiter = {.next = NULL},
     };
+    containers_waiter_init(&context.waiter.notification);
     if (lock->last_waiter) lock->last_waiter->next = &context.waiter;
     else lock->waiters = &context.waiter;
     lock->last_waiter = &context.waiter;

data/ext/farce/map.c

@@ -1,16 +1,14 @@
 #include "containers.h"
+#include "native_wait.h"
 #include "transaction.h"
 #include "ruby/fiber/scheduler.h"
-#include "ruby/io.h"
 
 #include <errno.h>
-#include <fcntl.h>
 #include <math.h>
 #include <stdint.h>
 #include <stdatomic.h>
 #include <stdlib.h>
 #include <time.h>
-#include <unistd.h>
 
 #define MAP_INITIAL_CAPACITY 16
 
@@ -42,9 +40,7 @@ typedef struct {
 } map_slot_t;
 
 typedef struct map_waiter {
-    int read_fd;
-    int write_fd;
-    bool notified;
+    containers_waiter_t notification;
     struct map_waiter *next;
 } map_waiter_t;
 
@@ -141,46 +137,12 @@ map_parse_timeout(VALUE timeout)
     return parsed;
 }
 
-static void
-map_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
-}
-
-static void
-map_waiter_initialize(map_waiter_t *waiter)
-{
-    int descriptors[2];
-    if (pipe(descriptors) != 0) rb_sys_fail("pipe");
-    waiter->read_fd = descriptors[0];
-    waiter->write_fd = descriptors[1];
-    waiter->notified = false;
-    waiter->next = NULL;
-    map_set_fd_flags(waiter->read_fd);
-    map_set_fd_flags(waiter->write_fd);
-}
-
 static void
 map_notify_waiters_locked(map_t *map)
 {
-    unsigned char byte = 1;
     map->generation++;
     for (map_waiter_t *waiter = map->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);
     }
 }
 
@@ -260,7 +222,7 @@ map_memsize(const void *pointer)
 }
 
 static const rb_data_type_t map_type = {
-    .wrap_struct_name = "Ractor::Containers::Map",
+    .wrap_struct_name = "Farce::Internal::Map",
     .function = {
         .dmark = map_mark,
         .dfree = map_free,
@@ -430,13 +392,10 @@ static VALUE
 map_wait_body(VALUE opaque)
 {
     map_wait_context_t *context = (map_wait_context_t *)opaque;
-    VALUE wait_timeout = Qnil;
-    if (context->timeout->finite) {
-        double remaining = context->timeout->deadline - map_monotonic_now();
-        if (remaining <= 0) return Qfalse;
-        wait_timeout = DBL2NUM(remaining);
-    }
-    return containers_wait_for_readable(context->waiter->read_fd, wait_timeout) ? Qtrue : Qfalse;
+    return containers_waiter_wait(
+        &context->waiter->notification, &context->map->lock,
+        context->timeout->finite, context->timeout->deadline, NULL
+    ) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -451,8 +410,7 @@ map_wait_cleanup(VALUE opaque)
         pthread_mutex_unlock(&context->map->lock);
         context->registered = false;
     }
-    close(context->waiter->read_fd);
-    close(context->waiter->write_fd);
+    containers_waiter_close(&context->waiter->notification);
     return Qnil;
 }
 
@@ -460,13 +418,11 @@ static bool
 map_wait_once(map_t *map, uint64_t generation, map_timeout_t *timeout)
 {
     map_waiter_t waiter;
-    map_waiter_initialize(&waiter);
+    containers_waiter_init(&waiter.notification);
 
     pthread_mutex_lock(&map->lock);
     if (map->generation != generation) {
         pthread_mutex_unlock(&map->lock);
-        close(waiter.read_fd);
-        close(waiter.write_fd);
         return true;
     }
     waiter.next = map->waiters;

data/ext/farce/native_wait.c

@@ -0,0 +1,139 @@
+#include "native_wait.h"
+#include "ruby/fiber/scheduler.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <time.h>
+#include <unistd.h>
+
+static double
+waiter_monotonic_now(void)
+{
+    struct timespec now;
+#ifdef CLOCK_MONOTONIC
+    if (clock_gettime(CLOCK_MONOTONIC, &now) == 0) {
+        return (double)now.tv_sec + (double)now.tv_nsec / 1000000000.0;
+    }
+#endif
+    struct timeval fallback;
+    gettimeofday(&fallback, NULL);
+    return (double)fallback.tv_sec + (double)fallback.tv_usec / 1000000.0;
+}
+
+static void
+waiter_set_fd_flags(int fd)
+{
+#ifndef _WIN32
+    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
+}
+
+void
+containers_waiter_init(containers_waiter_t *waiter)
+{
+    containers_futex_init(&waiter->futex);
+    waiter->read_fd = waiter->write_fd = -1;
+    waiter->mode = CONTAINERS_WAITER_PENDING;
+    waiter->notified = false;
+}
+
+bool
+containers_waiter_notify(containers_waiter_t *waiter)
+{
+    if (waiter->notified) return true;
+    if (waiter->mode == CONTAINERS_WAITER_FUTEX) {
+        waiter->notified = true;
+        containers_futex_notify(&waiter->futex);
+        return true;
+    }
+
+    /* A pending waiter has not selected its backend yet. Latch its wake so
+     * setup can return immediately or a future kernel wait sees a mismatch. */
+    atomic_store_explicit(&waiter->futex.value, 1, memory_order_release);
+    if (waiter->mode == CONTAINERS_WAITER_PENDING) {
+        waiter->notified = true;
+        return true;
+    }
+
+    unsigned char byte = 1;
+    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;
+    }
+    return waiter->notified;
+}
+
+bool
+containers_waiter_wait(
+    containers_waiter_t *waiter,
+    pthread_mutex_t *guard,
+    bool finite,
+    double deadline,
+    int *pipe_error
+)
+{
+    if (pipe_error) *pipe_error = 0;
+    if (atomic_load_explicit(&waiter->futex.value, memory_order_acquire) == 1) return true;
+    if (finite && deadline <= waiter_monotonic_now()) return false;
+
+    /* Selection can enter Ruby or probe the kernel. The registration stays
+     * pending, with no native container mutex held, throughout this work. */
+    VALUE scheduler = rb_fiber_scheduler_current();
+    /* Blocking futex waits failed the cross-core thread handoff performance
+     * gate. Keep Ruby's managed IO path for threads and use futexes only when
+     * the owning event loop can complete them asynchronously. */
+    bool use_futex = !NIL_P(scheduler) && containers_futex_scheduler_supported(scheduler);
+
+    int descriptors[2] = {-1, -1};
+    if (!use_futex) {
+        if (pipe(descriptors) != 0) {
+            int error = errno;
+            if (atomic_load_explicit(&waiter->futex.value, memory_order_acquire) == 1) return true;
+            if (pipe_error) {
+                *pipe_error = error;
+                return false;
+            }
+            rb_syserr_fail(error, "pipe");
+        }
+        waiter_set_fd_flags(descriptors[0]);
+        waiter_set_fd_flags(descriptors[1]);
+    }
+
+    /* No Ruby calls occur between creating descriptors and recording ownership.
+     * A notifier either latches a pending wake or observes the complete backend. */
+    if (guard) pthread_mutex_lock(guard);
+    waiter->read_fd = descriptors[0];
+    waiter->write_fd = descriptors[1];
+    waiter->mode = use_futex ? CONTAINERS_WAITER_FUTEX : CONTAINERS_WAITER_IO;
+    bool notified = waiter->notified;
+    if (guard) pthread_mutex_unlock(guard);
+    if (notified) return true;
+
+    VALUE timeout = Qnil;
+    if (finite) {
+        double remaining = deadline - waiter_monotonic_now();
+        if (remaining <= 0) {
+            return atomic_load_explicit(&waiter->futex.value, memory_order_acquire) == 1;
+        }
+        timeout = DBL2NUM(remaining);
+    }
+
+    if (use_futex) {
+        return containers_futex_scheduler_wait(scheduler, &waiter->futex, timeout);
+    }
+    return containers_wait_for_readable(waiter->read_fd, timeout);
+}
+
+void
+containers_waiter_close(containers_waiter_t *waiter)
+{
+    if (waiter->read_fd >= 0) close(waiter->read_fd);
+    if (waiter->write_fd >= 0) close(waiter->write_fd);
+    waiter->read_fd = waiter->write_fd = -1;
+}

data/ext/farce/native_wait.h

@@ -0,0 +1,37 @@
+#ifndef FARCE_NATIVE_WAIT_H
+#define FARCE_NATIVE_WAIT_H
+
+#include "containers.h"
+#include "futex.h"
+
+typedef enum {
+    CONTAINERS_WAITER_PENDING,
+    CONTAINERS_WAITER_FUTEX,
+    CONTAINERS_WAITER_IO
+} containers_waiter_mode_t;
+
+typedef struct {
+    containers_futex_t futex;
+    int read_fd, write_fd;
+    containers_waiter_mode_t mode;
+    bool notified;
+} containers_waiter_t;
+
+/* Initialize before linking under the container's guard. Notification is
+ * native-only and uses that same guard. A NULL guard denotes owner-local state. */
+void containers_waiter_init(containers_waiter_t *waiter);
+bool containers_waiter_notify(containers_waiter_t *waiter);
+/* Run outside the guard and inside the caller's cleanup ensure. The absolute
+ * monotonic deadline includes backend setup. Optional pipe_error lets callers
+ * retain their own descriptor-pressure recovery; other errors raise normally. */
+bool containers_waiter_wait(
+    containers_waiter_t *waiter,
+    pthread_mutex_t *guard,
+    bool finite,
+    double deadline,
+    int *pipe_error
+);
+/* Unlink under the guard first. Waiting has already drained native requests. */
+void containers_waiter_close(containers_waiter_t *waiter);
+
+#endif

data/ext/farce/priority_queue.c

@@ -1,4 +1,5 @@
 #include "containers.h"
+#include "native_wait.h"
 #include "unshared_wait.h"
 #include <ruby/atomic.h>
 #include <ruby/fiber/scheduler.h>
@@ -348,9 +349,7 @@ priority_queue_bucket_unlink(
 }
 
 typedef struct priority_queue_lock_waiter {
-    int read_fd;
-    int write_fd;
-    bool notified;
+    containers_waiter_t notification;
     struct priority_queue_lock_waiter *next;
 } priority_queue_lock_waiter_t;
 
@@ -753,19 +752,6 @@ priority_queue_get(VALUE self)
     return queue;
 }
 
-static void
-priority_queue_lock_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 queue->lock held. A logical unlock only needs to make one
  * waiter runnable. The selected waiter remains linked until ensure cleanup. */
 static void
@@ -777,20 +763,9 @@ priority_queue_lock_notify_one_locked(priority_queue_t *queue)
          * next waiter. Reentrant operations can register for a later unlock. */
         farce_unshared_wait_notify_all(&queue->unshared_lock_waiters);
     }
-    unsigned char byte = 1;
-    priority_queue_lock_waiter_t *waiter;
-
-    for (waiter = queue->waiters; waiter; waiter = waiter->next) {
-        ssize_t result;
-        if (waiter->notified) continue;
-        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;
-            return;
-        }
+    for (priority_queue_lock_waiter_t *waiter = queue->waiters; waiter; waiter = waiter->next) {
+        if (waiter->notification.notified) continue;
+        if (containers_waiter_notify(&waiter->notification)) return;
     }
 }
 
@@ -799,18 +774,16 @@ typedef struct {
     priority_queue_lock_waiter_t waiter;
 } priority_queue_lock_wait_context_t;
 
-static bool
-priority_queue_lock_wait_for_descriptor(int fd)
-{
-    return containers_wait_for_readable(fd, Qnil);
-}
-
 static VALUE
 priority_queue_lock_wait_body(VALUE opaque)
 {
     priority_queue_lock_wait_context_t *context =
         (priority_queue_lock_wait_context_t *)opaque;
-    bool awakened = priority_queue_lock_wait_for_descriptor(context->waiter.read_fd);
+    bool awakened = containers_waiter_wait(
+        &context->waiter.notification,
+        context->queue->shared ? &context->queue->lock : NULL,
+        false, 0, NULL
+    );
     return awakened ? Qtrue : Qfalse;
 }
 
@@ -835,10 +808,10 @@ priority_queue_lock_wait_cleanup(VALUE opaque)
     }
     /* A notification only makes this waiter runnable; it does not reserve
      * ownership. Pass the baton whenever a notified waiter leaves while the
-     * queue is still ownerless. This covers both interruption inside rb_io_wait
+     * queue is still ownerless. This covers both interruption while waiting
      * and cancellation after a normal wake but before the acquisition loop can
      * claim ownership, so later waiters cannot be stranded. */
-    if (context->waiter.notified &&
+    if (context->waiter.notification.notified &&
         NIL_P(context->queue->owner_fiber) &&
         !priority_queue_publication_busy(
             RUBY_ATOMIC_LOAD(context->queue->publication_state)
@@ -846,8 +819,7 @@ priority_queue_lock_wait_cleanup(VALUE opaque)
         priority_queue_lock_notify_one_locked(context->queue);
     }
     priority_queue_mutex_unlock(context->queue);
-    close(context->waiter.read_fd);
-    close(context->waiter.write_fd);
+    containers_waiter_close(&context->waiter.notification);
     return Qnil;
 }
 
@@ -859,25 +831,11 @@ priority_queue_lock_wait_once(priority_queue_t *queue)
         (void)farce_unshared_wait(&queue->unshared_lock_waiters, queue->unshared_self, false, 0);
         return;
     }
-    int descriptors[2];
-    priority_queue_lock_wait_context_t context;
-
-    if (pipe(descriptors) != 0) {
-        priority_queue_mutex_unlock(queue);
-        rb_sys_fail("pipe");
-    }
-    priority_queue_lock_set_fd_flags(descriptors[0]);
-    priority_queue_lock_set_fd_flags(descriptors[1]);
-
-    context = (priority_queue_lock_wait_context_t){
+    priority_queue_lock_wait_context_t context = {
         .queue = queue,
-        .waiter = {
-            .read_fd = descriptors[0],
-            .write_fd = descriptors[1],
-            .notified = false,
-            .next = NULL,
-        },
+        .waiter = {.next = NULL},
     };
+    containers_waiter_init(&context.waiter.notification);
     if (queue->last_waiter) queue->last_waiter->next = &context.waiter;
     else queue->waiters = &context.waiter;
     queue->last_waiter = &context.waiter;

data/ext/farce/queue.c

@@ -224,7 +224,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,