farce 0.3.0-x86_64-linux-gnu → 0.4.1-x86_64-linux-gnu

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) {

data/ext/farce/tree_map.c

@@ -1,4 +1,5 @@
 #include "containers.h"
+#include "native_wait.h"
 #include "transaction.h"
 #include <ruby/atomic.h>
 #include <ruby/fiber/scheduler.h>
@@ -558,9 +559,7 @@ tc_map_store_unlocked(VALUE self, tc_map *map, VALUE key, VALUE value,
 typedef struct tc_core_map_waiter tc_core_map_waiter;
 
 struct tc_core_map_waiter {
-    int read_fd;
-    int write_fd;
-    bool notified;
+    containers_waiter_t notification;
     tc_core_map_waiter *next;
 };
 
@@ -787,40 +786,14 @@ typedef struct {
     tc_core_map_waiter waiter;
 } tc_core_map_fiber_wait;
 
-static void
-tc_core_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
-}
-
 /* Called with core->lock held. The waiter remains linked until its ensure
  * cleanup so an interrupt cannot leave a dangling stack pointer behind. */
 static void
 tc_core_map_notify_one_locked(tc_core_map *core)
 {
-    unsigned char byte = 1;
-
-    for (tc_core_map_waiter *waiter = core->waiters;
-         waiter != NULL;
-         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 (tc_core_map_waiter *waiter = core->waiters; waiter; waiter = waiter->next) {
+        if (waiter->notification.notified) continue;
+        if (containers_waiter_notify(&waiter->notification)) return;
     }
 }
 
@@ -828,7 +801,9 @@ static VALUE
 tc_core_map_fiber_wait_body(VALUE opaque)
 {
     tc_core_map_fiber_wait *wait = (tc_core_map_fiber_wait *)opaque;
-    return containers_wait_for_readable(wait->waiter.read_fd, Qnil) ? Qtrue : Qfalse;
+    return containers_waiter_wait(
+        &wait->waiter.notification, &wait->core->lock, false, 0, NULL
+    ) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -851,9 +826,9 @@ tc_core_map_fiber_wait_cleanup(VALUE opaque)
     }
     /* Notification makes a waiter runnable, but does not reserve ownership.
      * Always pass the baton if a notified waiter leaves while ownerless,
-     * including cancellation after rb_io_wait returned but before the lock
+     * including cancellation after a wait returned but before the lock
      * acquisition loop claimed ownership. */
-    if (wait->waiter.notified &&
+    if (wait->waiter.notification.notified &&
         NIL_P(wait->core->owner_fiber) &&
         !tc_core_map_publication_busy(
             RUBY_ATOMIC_LOAD(wait->core->publication_state)
@@ -862,8 +837,7 @@ tc_core_map_fiber_wait_cleanup(VALUE opaque)
     }
     pthread_mutex_unlock(&wait->core->lock);
 
-    close(wait->waiter.read_fd);
-    close(wait->waiter.write_fd);
+    containers_waiter_close(&wait->waiter.notification);
     return Qnil;
 }
 
@@ -871,24 +845,11 @@ tc_core_map_fiber_wait_cleanup(VALUE opaque)
 static void
 tc_core_map_wait_once(tc_core_map *core)
 {
-    int descriptors[2];
-
-    if (pipe(descriptors) != 0) {
-        pthread_mutex_unlock(&core->lock);
-        rb_sys_fail("pipe");
-    }
-    tc_core_map_set_fd_flags(descriptors[0]);
-    tc_core_map_set_fd_flags(descriptors[1]);
-
     tc_core_map_fiber_wait wait = {
         .core = core,
-        .waiter = {
-            .read_fd = descriptors[0],
-            .write_fd = descriptors[1],
-            .notified = false,
-            .next = NULL,
-        },
+        .waiter = {.next = NULL},
     };
+    containers_waiter_init(&wait.waiter.notification);
 
     if (core->last_waiter != NULL) core->last_waiter->next = &wait.waiter;
     else core->waiters = &wait.waiter;
@@ -904,8 +865,8 @@ tc_core_map_wait_once(tc_core_map *core)
 }
 
 /* CRuby needs logical Fiber ownership rather than pthread ownership: multiple
- * scheduled Fibers can contend on the same native thread. Descriptor waits
- * let rb_io_wait park only the current Fiber while its owner resumes. */
+ * scheduled Fibers can contend on the same native thread. Native notifications
+ * park only the current Fiber while its owner resumes. */
 static void
 tc_core_map_lock(VALUE self, tc_core_map *core)
 {

data/ext/farce/unshareable.c

@@ -40,7 +40,7 @@ containers_marker_size(const void *pointer)
 }
 
 static const rb_data_type_t containers_pin_marker_type = {
-    .wrap_struct_name = "Ractor::Containers pin marker",
+    .wrap_struct_name = "Farce pin marker",
     .function = {
         .dmark = containers_marker_mark,
         .dfree = RUBY_TYPED_DEFAULT_FREE,

data/ext/farce/unsupported.c

@@ -1,6 +1,18 @@
-#include "ruby.h"
+#include "futex.h"
 
 void farce_init_fiber_scheduler(VALUE internal) {
     (void)internal;
     rb_raise(rb_eLoadError, "native Farce fiber scheduling requires epoll or kqueue; use the select implementation");
 }
+
+bool containers_futex_scheduler_supported(VALUE scheduler) {
+    (void)scheduler;
+    return false;
+}
+
+bool containers_futex_scheduler_wait(VALUE scheduler, containers_futex_t *word, VALUE timeout) {
+    (void)scheduler;
+    (void)word;
+    (void)timeout;
+    return true;
+}

data/ext/farce/vector.c

@@ -1,15 +1,13 @@
 #include "containers.h"
+#include "native_wait.h"
 #include "transaction.h"
-#include "ruby/io.h"
 #include "ruby/fiber/scheduler.h"
 
 #include <errno.h>
-#include <fcntl.h>
 #include <math.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <time.h>
-#include <unistd.h>
 
 #define VECTOR_INITIAL_CAPACITY 16
 static VALUE cVector;
@@ -19,9 +17,7 @@ static VALUE vector_transaction_marker;
 typedef struct vector_waiter vector_waiter_t;
 
 struct vector_waiter {
-    int read_fd;
-    int write_fd;
-    bool notified;
+    containers_waiter_t notification;
     vector_waiter_t *next;
 };
 
@@ -85,7 +81,7 @@ vector_memsize(const void *pointer)
 }
 
 static const rb_data_type_t vector_type = {
-    .wrap_struct_name = "Ractor::Containers::Vector",
+    .wrap_struct_name = "Farce::Internal::Vector",
     .function = {
         .dmark = vector_mark,
         .dfree = vector_free,
@@ -214,35 +210,14 @@ vector_timeout_keyword(VALUE keywords)
     return timeout;
 }
 
-static void
-vector_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 vector->lock held. Each waiter has an independent pipe, so a
- * transition wakes every waiting thread or scheduled fiber. */
+/* Called with vector->lock held. A transition wakes every registered
+ * thread or fiber without sharing a consumable notification. */
 static void
 vector_notify_waiters_locked(vector_t *vector)
 {
-    unsigned char byte = 1;
     vector->generation++;
     for (vector_waiter_t *waiter = vector->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);
     }
 }
 
@@ -259,23 +234,14 @@ typedef struct {
     vector_timeout_t *timeout;
 } vector_wait_context_t;
 
-static bool
-vector_wait_for_descriptor(int fd, vector_timeout_t *timeout)
-{
-    VALUE wait_timeout = Qnil;
-    if (timeout->finite) {
-        double remaining = timeout->deadline - vector_monotonic_now();
-        if (remaining <= 0) return false;
-        wait_timeout = DBL2NUM(remaining);
-    }
-    return containers_wait_for_readable(fd, wait_timeout);
-}
-
 static VALUE
 vector_wait_body(VALUE opaque)
 {
     vector_wait_context_t *context = (vector_wait_context_t *)opaque;
-    return vector_wait_for_descriptor(context->waiter.read_fd, context->timeout) ? Qtrue : Qfalse;
+    return containers_waiter_wait(
+        &context->waiter.notification, &context->vector->lock,
+        context->timeout->finite, context->timeout->deadline, NULL
+    ) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -292,8 +258,7 @@ vector_wait_cleanup(VALUE opaque)
         }
     }
     pthread_mutex_unlock(&context->vector->lock);
-    close(context->waiter.read_fd);
-    close(context->waiter.write_fd);
+    containers_waiter_close(&context->waiter.notification);
     return Qnil;
 }
 
@@ -303,24 +268,12 @@ vector_wait_cleanup(VALUE opaque)
 static bool
 vector_wait_once(vector_t *vector, vector_timeout_t *timeout)
 {
-    int descriptors[2];
-    if (pipe(descriptors) != 0) {
-        pthread_mutex_unlock(&vector->lock);
-        rb_sys_fail("pipe");
-    }
-    vector_set_fd_flags(descriptors[0]);
-    vector_set_fd_flags(descriptors[1]);
-
     vector_wait_context_t context = {
         .vector = vector,
-        .waiter = {
-            .read_fd = descriptors[0],
-            .write_fd = descriptors[1],
-            .notified = false,
-            .next = vector->waiters,
-        },
+        .waiter = {.next = vector->waiters},
         .timeout = timeout,
     };
+    containers_waiter_init(&context.waiter.notification);
     vector->waiters = &context.waiter;
     pthread_mutex_unlock(&vector->lock);
     return RTEST(rb_ensure(vector_wait_body, (VALUE)&context, vector_wait_cleanup, (VALUE)&context));

data/ext/farce/weak_map.c

@@ -250,7 +250,7 @@ weak_map_memsize(const void *pointer)
 }
 
 static const rb_data_type_t weak_map_type = {
-    .wrap_struct_name = "Ractor::Containers::WeakMap",
+    .wrap_struct_name = "Farce::Internal::WeakMap",
     .function = {
         .dmark = weak_map_mark,
         .dfree = weak_map_free,

data/lib/farce/abstract/flag.rb

@@ -59,6 +59,12 @@ module Farce
       include Internal::ValueSerialization
       include Internal::Inspect
 
+      # @return [Boolean] whether the flag is set
+      def set? = value
+
+      # @return [Boolean] whether the flag is unset
+      def unset? = !value
+
       # Wait until the flag becomes true.
       # @param timeout [Numeric, nil] the total seconds available
       # @yield called when the timeout expires