farce 0 → 0.1.0

data/ext/farce/containers.h

@@ -0,0 +1,77 @@
+#ifndef RACTOR_CONTAINERS_H
+#define RACTOR_CONTAINERS_H
+
+#include "ruby.h"
+#include "ruby/ractor.h"
+#include "ruby/thread.h"
+
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+#ifndef _WIN32
+#include <sys/time.h>
+#endif
+
+/* Use only after validating self as native TypedData. */
+static inline void
+containers_check_typed_frozen(VALUE self)
+{
+    if (RB_UNLIKELY(RB_OBJ_FROZEN_RAW(self))) rb_error_frozen_object(self);
+}
+
+void containers_check_shareable(VALUE value);
+bool containers_strict_bool(VALUE value, const char *name);
+typedef void (*containers_native_reference_validator_t)(VALUE object);
+VALUE containers_publish_native_reference_free(VALUE self);
+VALUE containers_publish_native_with_references(
+    VALUE self,
+    containers_native_reference_validator_t validate_references
+);
+RBIMPL_ATTR_NORETURN()
+VALUE containers_raise_unfreezable(VALUE self);
+VALUE containers_normalize_string_key(VALUE key);
+bool containers_wait_for_readable(int fd, VALUE timeout);
+void containers_wait_without_descriptor(
+    int error, const char *operation, bool *collected, VALUE timeout
+);
+#ifdef _WIN32
+void containers_wait_safepoint(void);
+#endif
+RBIMPL_ATTR_NORETURN()
+void containers_raise_key_error(VALUE receiver, VALUE key);
+
+void containers_init_atom(VALUE namespace);
+void containers_init_counter(VALUE namespace);
+void containers_init_exchanger(VALUE namespace);
+void containers_init_flag(VALUE namespace);
+void containers_init_lock(VALUE namespace);
+typedef VALUE (*containers_lock_operation_t)(VALUE opaque);
+VALUE containers_lock_new(void);
+VALUE containers_lock_synchronize_call(
+    VALUE lock,
+    containers_lock_operation_t operation,
+    VALUE opaque
+);
+void containers_init_lru_maps(VALUE namespace);
+void containers_init_map(VALUE namespace);
+void containers_init_priority_queue(VALUE namespace);
+void containers_init_darwin(VALUE namespace);
+void containers_init_queue(VALUE namespace);
+void containers_init_signal(VALUE namespace);
+VALUE containers_signal_new(void);
+VALUE containers_signal_broadcast(VALUE self);
+
+typedef struct containers_unshared_signal containers_unshared_signal_t;
+containers_unshared_signal_t *containers_unshared_signal_get_if_exact(VALUE signal);
+bool containers_unshared_fiber_io(VALUE mode);
+bool containers_unshared_signal_uses_fiber_io(VALUE signal);
+bool containers_unshared_signal_has_waiters(containers_unshared_signal_t *signal);
+void containers_unshared_signal_notify(containers_unshared_signal_t *signal);
+void containers_init_unshared_signal(VALUE namespace);
+void containers_init_unshareable(VALUE namespace);
+void containers_init_vector(VALUE namespace);
+void containers_init_weak_maps(VALUE namespace);
+void containers_init_tree_maps(VALUE namespace);
+void containers_init_trie(VALUE namespace);
+
+#endif

data/ext/farce/counter.c

@@ -0,0 +1,399 @@
+#include "containers.h"
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdatomic.h>
+
+_Static_assert(sizeof(long long) == sizeof(int64_t), "Counter requires a 64-bit long long");
+_Static_assert(LLONG_MIN == INT64_MIN, "Counter requires a signed 64-bit long long");
+_Static_assert(LLONG_MAX == INT64_MAX, "Counter requires a signed 64-bit long long");
+
+#if ATOMIC_LLONG_LOCK_FREE == 2
+#define CONTAINERS_COUNTER_LOCK_FREE 1
+#else
+#define CONTAINERS_COUNTER_LOCK_FREE 0
+#endif
+
+static VALUE cCounter;
+
+typedef struct {
+#if CONTAINERS_COUNTER_LOCK_FREE
+    _Atomic long long value;
+#else
+    pthread_mutex_t lock;
+    long long value;
+#endif
+    VALUE signal;
+    long long initial;
+    bool initialized;
+} counter_t;
+
+/* On platforms with always-lock-free 64-bit atomics, counter operations only
+ * linearize this numeric value. Relaxed ordering does not publish or
+ * synchronize accesses to any other shared state. Platforms without that
+ * guarantee use a mutex so 32-bit cross builds do not depend on libatomic. */
+
+static void
+counter_free(void *pointer)
+{
+#if !CONTAINERS_COUNTER_LOCK_FREE
+    counter_t *counter = pointer;
+    if (counter) pthread_mutex_destroy(&counter->lock);
+#endif
+    ruby_xfree(pointer);
+}
+
+static size_t
+counter_memsize(const void *pointer)
+{
+    return pointer ? sizeof(counter_t) : 0;
+}
+
+static void
+counter_mark(void *pointer)
+{
+    counter_t *counter = pointer;
+    rb_gc_mark_movable(counter->signal);
+}
+
+static void
+counter_compact(void *pointer)
+{
+    counter_t *counter = pointer;
+    counter->signal = rb_gc_location(counter->signal);
+}
+
+static const rb_data_type_t counter_type = {
+    .wrap_struct_name = "Ractor::Containers::Counter",
+    .function = {
+        .dmark = counter_mark,
+        .dcompact = counter_compact,
+        .dfree = counter_free,
+        .dsize = counter_memsize,
+    },
+    .flags = RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+static VALUE
+counter_allocate(VALUE klass)
+{
+    counter_t *counter;
+    VALUE object = TypedData_Make_Struct(klass, counter_t, &counter_type, counter);
+#if CONTAINERS_COUNTER_LOCK_FREE
+    atomic_init(&counter->value, 0);
+#else
+    pthread_mutex_init(&counter->lock, NULL);
+    counter->value = 0;
+#endif
+    counter->signal = Qnil;
+    counter->initialized = false;
+    return object;
+}
+
+static counter_t *
+get_counter(VALUE self)
+{
+    counter_t *counter;
+    TypedData_Get_Struct(self, counter_t, &counter_type, counter);
+    if (!counter->initialized) rb_raise(rb_eRuntimeError, "uninitialized Counter");
+    return counter;
+}
+
+static void
+counter_validate_references(VALUE self)
+{
+    containers_check_shareable(get_counter(self)->signal);
+}
+
+static VALUE
+counter_change_signal(VALUE self)
+{
+    return get_counter(self)->signal;
+}
+
+static long long
+counter_integer(VALUE value, const char *name)
+{
+    if (!RB_INTEGER_TYPE_P(value)) rb_raise(rb_eTypeError, "%s must be an Integer", name);
+    return NUM2LL(value);
+}
+
+static VALUE
+counter_initialize(int argc, VALUE *argv, VALUE self)
+{
+    counter_t *counter;
+
+    rb_check_arity(argc, 0, 1);
+    VALUE initial = argc == 0 ? INT2FIX(0) : argv[0];
+    TypedData_Get_Struct(self, counter_t, &counter_type, counter);
+    if (counter->initialized) rb_raise(rb_eRuntimeError, "Counter is already initialized");
+    rb_check_frozen(self);
+
+    long long value = counter_integer(initial, "initial value");
+    rb_check_frozen(self);
+#if CONTAINERS_COUNTER_LOCK_FREE
+    atomic_store_explicit(&counter->value, value, memory_order_relaxed);
+#else
+    counter->value = value;
+#endif
+    counter->signal = containers_signal_new();
+    counter->initial = value;
+    counter->initialized = true;
+    return containers_publish_native_with_references(self, counter_validate_references);
+}
+
+static VALUE
+counter_value(VALUE self)
+{
+    counter_t *counter = get_counter(self);
+#if CONTAINERS_COUNTER_LOCK_FREE
+    long long value = atomic_load_explicit(&counter->value, memory_order_relaxed);
+#else
+    pthread_mutex_lock(&counter->lock);
+    long long value = counter->value;
+    pthread_mutex_unlock(&counter->lock);
+#endif
+    return LL2NUM(value);
+}
+
+static VALUE
+counter_initial(VALUE self)
+{
+    return LL2NUM(get_counter(self)->initial);
+}
+
+static VALUE
+counter_initialize_copy(VALUE self, VALUE other)
+{
+    if (self == other) return self;
+    rb_check_frozen(self);
+    counter_t *copy;
+    TypedData_Get_Struct(self, counter_t, &counter_type, copy);
+    if (copy->initialized) rb_raise(rb_eRuntimeError, "copy is already initialized");
+    counter_t *source = get_counter(other);
+#if CONTAINERS_COUNTER_LOCK_FREE
+    long long value = atomic_load_explicit(&source->value, memory_order_relaxed);
+#else
+    pthread_mutex_lock(&source->lock);
+    long long value = source->value;
+    pthread_mutex_unlock(&source->lock);
+#endif
+#if CONTAINERS_COUNTER_LOCK_FREE
+    atomic_store_explicit(&copy->value, value, memory_order_relaxed);
+#else
+    copy->value = value;
+#endif
+    copy->signal = containers_signal_new();
+    copy->initial = source->initial;
+    copy->initialized = true;
+    return containers_publish_native_with_references(self, counter_validate_references);
+}
+
+static VALUE
+counter_store(VALUE self, VALUE input)
+{
+    counter_t *counter = get_counter(self);
+    rb_check_frozen(self);
+    long long value = counter_integer(input, "value");
+#if CONTAINERS_COUNTER_LOCK_FREE
+    atomic_store_explicit(&counter->value, value, memory_order_relaxed);
+#else
+    pthread_mutex_lock(&counter->lock);
+    counter->value = value;
+    pthread_mutex_unlock(&counter->lock);
+#endif
+    containers_signal_broadcast(counter->signal);
+    return input;
+}
+
+static VALUE
+counter_swap(VALUE self, VALUE input)
+{
+    counter_t *counter = get_counter(self);
+    rb_check_frozen(self);
+    long long replacement = counter_integer(input, "value");
+#if CONTAINERS_COUNTER_LOCK_FREE
+    long long current = atomic_load_explicit(&counter->value, memory_order_relaxed);
+
+    for (;;) {
+        VALUE result = LL2NUM(current);
+        if (atomic_compare_exchange_weak_explicit(
+                &counter->value,
+                &current,
+                replacement,
+                memory_order_relaxed,
+                memory_order_relaxed
+            )) {
+            containers_signal_broadcast(counter->signal);
+            return result;
+        }
+    }
+#else
+    pthread_mutex_lock(&counter->lock);
+    long long current = counter->value;
+    counter->value = replacement;
+    pthread_mutex_unlock(&counter->lock);
+    containers_signal_broadcast(counter->signal);
+    return LL2NUM(current);
+#endif
+}
+
+static bool
+counter_add_overflows(long long current, long long delta)
+{
+    return (delta > 0 && current > LLONG_MAX - delta) ||
+        (delta < 0 && current < LLONG_MIN - delta);
+}
+
+static bool
+counter_subtract_overflows(long long current, long long delta)
+{
+    return (delta > 0 && current < LLONG_MIN + delta) ||
+        (delta < 0 && current > LLONG_MAX + delta);
+}
+
+static VALUE
+counter_change(counter_t *counter, long long delta, bool subtract)
+{
+#if CONTAINERS_COUNTER_LOCK_FREE
+    long long current = atomic_load_explicit(&counter->value, memory_order_relaxed);
+
+    for (;;) {
+        bool overflows = subtract
+            ? counter_subtract_overflows(current, delta)
+            : counter_add_overflows(current, delta);
+        if (overflows) rb_raise(rb_eRangeError, "counter value is outside the signed 64-bit range");
+
+        long long replacement = subtract ? current - delta : current + delta;
+        VALUE result = LL2NUM(replacement);
+        if (atomic_compare_exchange_weak_explicit(
+                &counter->value,
+                &current,
+                replacement,
+                memory_order_relaxed,
+                memory_order_relaxed
+            )) {
+            containers_signal_broadcast(counter->signal);
+            return result;
+        }
+    }
+#else
+    pthread_mutex_lock(&counter->lock);
+    long long current = counter->value;
+    bool overflows = subtract
+        ? counter_subtract_overflows(current, delta)
+        : counter_add_overflows(current, delta);
+    if (overflows) {
+        pthread_mutex_unlock(&counter->lock);
+        rb_raise(rb_eRangeError, "counter value is outside the signed 64-bit range");
+    }
+
+    long long replacement = subtract ? current - delta : current + delta;
+    counter->value = replacement;
+    pthread_mutex_unlock(&counter->lock);
+    containers_signal_broadcast(counter->signal);
+    return LL2NUM(replacement);
+#endif
+}
+
+static VALUE
+counter_add(int argc, VALUE *argv, VALUE self)
+{
+    rb_check_arity(argc, 0, 1);
+    counter_t *counter = get_counter(self);
+    rb_check_frozen(self);
+    VALUE input = argc == 0 ? INT2FIX(1) : argv[0];
+    long long delta = counter_integer(input, "delta");
+    return counter_change(counter, delta, false);
+}
+
+static VALUE
+counter_subtract(int argc, VALUE *argv, VALUE self)
+{
+    rb_check_arity(argc, 0, 1);
+    counter_t *counter = get_counter(self);
+    rb_check_frozen(self);
+    VALUE input = argc == 0 ? INT2FIX(1) : argv[0];
+    long long delta = counter_integer(input, "delta");
+    return counter_change(counter, delta, true);
+}
+
+static VALUE
+counter_compare_and_set(VALUE self, VALUE expected_input, VALUE replacement_input)
+{
+    counter_t *counter = get_counter(self);
+    rb_check_frozen(self);
+    long long expected = counter_integer(expected_input, "expected value");
+    long long replacement = counter_integer(replacement_input, "replacement value");
+#if CONTAINERS_COUNTER_LOCK_FREE
+    bool exchanged = atomic_compare_exchange_strong_explicit(
+        &counter->value,
+        &expected,
+        replacement,
+        memory_order_relaxed,
+        memory_order_relaxed
+    );
+#else
+    pthread_mutex_lock(&counter->lock);
+    bool exchanged = counter->value == expected;
+    if (exchanged) counter->value = replacement;
+    pthread_mutex_unlock(&counter->lock);
+#endif
+    if (exchanged) containers_signal_broadcast(counter->signal);
+    return exchanged ? Qtrue : Qfalse;
+}
+
+/* The chainable operations are inherited directly by Farce::Counter. Keep
+ * add/subtract as strict, value-returning primitives for internal callers. */
+static VALUE
+counter_increment(int argc, VALUE *argv, VALUE self)
+{
+    rb_check_arity(argc, 0, 1);
+    counter_t *counter = get_counter(self);
+    rb_check_frozen(self);
+    VALUE input = argc == 0 ? INT2FIX(1) : argv[0];
+    if (!RB_INTEGER_TYPE_P(input)) {
+        input = rb_Integer(input);
+        rb_check_frozen(self);
+    }
+    long long delta = NUM2LL(input);
+    (void)counter_change(counter, delta, false);
+    return self;
+}
+
+static VALUE
+counter_decrement(int argc, VALUE *argv, VALUE self)
+{
+    rb_check_arity(argc, 0, 1);
+    counter_t *counter = get_counter(self);
+    rb_check_frozen(self);
+    VALUE input = argc == 0 ? INT2FIX(1) : argv[0];
+    if (!RB_INTEGER_TYPE_P(input)) {
+        input = rb_Integer(input);
+        rb_check_frozen(self);
+    }
+    long long delta = NUM2LL(input);
+    (void)counter_change(counter, delta, true);
+    return self;
+}
+
+void
+containers_init_counter(VALUE namespace)
+{
+    cCounter = rb_define_class_under(namespace, "Counter", rb_cNumeric);
+    rb_define_alloc_func(cCounter, counter_allocate);
+    rb_define_method(cCounter, "initialize", counter_initialize, -1);
+    rb_define_private_method(cCounter, "initialize_copy", counter_initialize_copy, 1);
+    rb_define_method(cCounter, "value", counter_value, 0);
+    rb_define_alias(cCounter, "get", "value");
+    rb_define_method(cCounter, "change_signal", counter_change_signal, 0);
+    rb_define_method(cCounter, "initial", counter_initial, 0);
+    rb_define_method(cCounter, "store", counter_store, 1);
+    rb_define_alias(cCounter, "value=", "store");
+    rb_define_method(cCounter, "swap", counter_swap, 1);
+    rb_define_method(cCounter, "add", counter_add, -1);
+    rb_define_method(cCounter, "increment", counter_increment, -1);
+    rb_define_method(cCounter, "subtract", counter_subtract, -1);
+    rb_define_method(cCounter, "decrement", counter_decrement, -1);
+    rb_define_method(cCounter, "compare_and_set", counter_compare_and_set, 2);
+}

data/ext/farce/darwin.c

@@ -0,0 +1,100 @@
+#include "containers.h"
+
+#if defined(HAVE_PTHREAD_QOS_H) && \
+    defined(HAVE_PTHREAD_SET_QOS_CLASS_SELF_NP) && \
+    defined(HAVE_PTHREAD_GET_QOS_CLASS_NP)
+#include <pthread/qos.h>
+#if defined(HAVE_SYS_SYSCTL_H) && defined(HAVE_SYSCTLBYNAME)
+#include <errno.h>
+#include <sys/sysctl.h>
+#endif
+
+static VALUE
+darwin_set_qos_class(VALUE self, VALUE qos_class, VALUE relative_priority)
+{
+    int error = pthread_set_qos_class_self_np(
+        (qos_class_t)NUM2UINT(qos_class),
+        NUM2INT(relative_priority)
+    );
+    if (error) rb_syserr_fail(error, "pthread_set_qos_class_self_np");
+    return Qnil;
+}
+
+static VALUE
+darwin_get_qos_class(VALUE self)
+{
+    qos_class_t qos_class;
+    int relative_priority;
+    int error = pthread_get_qos_class_np(pthread_self(), &qos_class, &relative_priority);
+    if (error) rb_syserr_fail(error, "pthread_get_qos_class_np");
+    return rb_assoc_new(UINT2NUM(qos_class), INT2NUM(relative_priority));
+}
+
+#ifdef HAVE_QOS_CLASS_MAIN
+static VALUE
+darwin_main_qos_class(VALUE self)
+{
+    return UINT2NUM(qos_class_main());
+}
+#endif
+
+#if defined(HAVE_SYS_SYSCTL_H) && defined(HAVE_SYSCTLBYNAME)
+static VALUE
+darwin_read_cpu_count(const char *name, bool optional)
+{
+    int count;
+    size_t size = sizeof(count);
+    if (sysctlbyname(name, &count, &size, NULL, 0) == -1) {
+        if (optional && errno == ENOENT) return Qnil;
+        rb_sys_fail(name);
+    }
+    return INT2NUM(count);
+}
+
+static VALUE
+darwin_performance_cpu_count(VALUE self)
+{
+    return darwin_read_cpu_count("hw.perflevel0.logicalcpu", true);
+}
+
+static VALUE
+darwin_efficiency_cpu_count(VALUE self)
+{
+    return darwin_read_cpu_count("hw.perflevel1.logicalcpu", true);
+}
+
+static VALUE
+darwin_cpu_count(VALUE self)
+{
+    return darwin_read_cpu_count("hw.logicalcpu", false);
+}
+#endif
+#endif
+
+void
+containers_init_darwin(VALUE namespace)
+{
+#if defined(HAVE_PTHREAD_QOS_H) && \
+    defined(HAVE_PTHREAD_SET_QOS_CLASS_SELF_NP) && \
+    defined(HAVE_PTHREAD_GET_QOS_CLASS_NP)
+    VALUE darwin = rb_define_module_under(namespace, "Darwin");
+    rb_define_singleton_method(darwin, "set_qos_class", darwin_set_qos_class, 2);
+    rb_define_singleton_method(darwin, "get_qos_class", darwin_get_qos_class, 0);
+#ifdef HAVE_QOS_CLASS_MAIN
+    rb_define_singleton_method(darwin, "main_qos_class", darwin_main_qos_class, 0);
+#endif
+#if defined(HAVE_SYS_SYSCTL_H) && defined(HAVE_SYSCTLBYNAME)
+    rb_define_singleton_method(darwin, "performance_cpu_count", darwin_performance_cpu_count, 0);
+    rb_define_singleton_method(darwin, "efficiency_cpu_count", darwin_efficiency_cpu_count, 0);
+    rb_define_singleton_method(darwin, "cpu_count", darwin_cpu_count, 0);
+#endif
+
+    rb_define_const(darwin, "MIN_RELATIVE_PRIORITY", INT2NUM(QOS_MIN_RELATIVE_PRIORITY));
+    rb_define_const(darwin, "USER_INTERACTIVE", UINT2NUM(QOS_CLASS_USER_INTERACTIVE));
+    rb_define_const(darwin, "USER_INITIATED", UINT2NUM(QOS_CLASS_USER_INITIATED));
+    rb_define_const(darwin, "DEFAULT", UINT2NUM(QOS_CLASS_DEFAULT));
+    rb_define_const(darwin, "UTILITY", UINT2NUM(QOS_CLASS_UTILITY));
+    rb_define_const(darwin, "BACKGROUND", UINT2NUM(QOS_CLASS_BACKGROUND));
+    rb_define_const(darwin, "UNSPECIFIED", UINT2NUM(QOS_CLASS_UNSPECIFIED));
+#endif
+}

data/ext/farce/depend

@@ -0,0 +1,12 @@
+bounded_map.o: bounded_map.c containers.h
+dict.o: dict.c dict.h
+farce.o: farce.c containers.h shareable.h
+lock.o: lock.c containers.h
+priority_queue.o: priority_queue.c containers.h dict.h unshared_wait.h
+reactor.o: reactor.c reactor.h
+drivers.o: drivers.c reactor.h
+io.o: io.c reactor.h
+tree_map.o: tree_map.c containers.h
+
+queue.o: queue.c containers.h unshared_wait.h
+unshared_signal.o: unshared_signal.c containers.h unshared_wait.h unshared_io_pool.h