farce 0.4.1-x86-linux-gnu → 0.6.0-x86-linux-gnu

data/ext/farce/atom.c

@@ -1,6 +1,7 @@
 #include "containers.h"
 #include "native_wait.h"
 #include "transaction.h"
+#include "weak_references.h"
 #include "ruby/fiber/scheduler.h"
 
 #include <errno.h>
@@ -12,11 +13,6 @@ static VALUE cAtom;
 #ifdef RC_HAVE_NATIVE_WEAK_REFERENCES
 static VALUE cWeakAtom;
 static VALUE cUnsharedWeakAtom;
-
-/* These functions are exported by Rubies with the probed typed-data weak
- * reference callback, but their declarations intentionally remain internal. */
-void rb_gc_declare_weak_references(VALUE object);
-bool rb_gc_handle_weak_references_alive_p(VALUE object);
 #endif
 
 typedef struct atom_waiter atom_waiter_t;
@@ -149,11 +145,11 @@ atom_compact(void *pointer)
 /* The VM invokes this after marking while mutators are stopped. Taking the atom
  * mutex here could deadlock if GC stopped a mutator while it owned the mutex. */
 static void
-atom_handle_weak_references(void *pointer)
+FARCE_WEAK_REFERENCES_CALLBACK(atom_handle_weak_references)
 {
     atom_t *atom = pointer;
     if (!atom->weak || NIL_P(atom->value)) return;
-    if (rb_gc_handle_weak_references_alive_p(atom->value)) return;
+    if (FARCE_WEAK_REFERENCE_ALIVE_P(atom->value)) return;
 
     atom->value = Qnil;
     atom_changed(atom);
@@ -500,6 +496,15 @@ static VALUE
 atom_get(int argc, VALUE *argv, VALUE self)
 {
     atom_t *atom = get_atom(self);
+    if (argc == 0) {
+        pthread_mutex_lock(&atom->lock);
+        if (!atom->updating) {
+            VALUE value = atom->value;
+            pthread_mutex_unlock(&atom->lock);
+            return value;
+        }
+        pthread_mutex_unlock(&atom->lock);
+    }
     atom_timeout_t timeout = atom_parse_timeout(atom_extract_timeout(argc, argv, "0:", NULL));
     atom_execution_context_t execution = atom_current_execution_context();
 
@@ -607,6 +612,17 @@ static VALUE
 atom_store_if_absent(int argc, VALUE *argv, VALUE self)
 {
     atom_t *atom = get_atom(self);
+    if (argc == 0) {
+        rb_check_frozen(self);
+        rb_need_block();
+        pthread_mutex_lock(&atom->lock);
+        if (!atom->updating && !NIL_P(atom->value)) {
+            VALUE value = atom->value;
+            pthread_mutex_unlock(&atom->lock);
+            return value;
+        }
+        pthread_mutex_unlock(&atom->lock);
+    }
     atom_operation_t operation = {
         .self = self,
         .atom = atom,

data/ext/farce/containers.h

@@ -36,6 +36,9 @@ containers_check_typed_frozen(VALUE self)
 
 void containers_check_shareable(VALUE value);
 bool containers_strict_bool(VALUE value, const char *name);
+VALUE containers_parse_constructor(
+    int argc, const VALUE *argv, const ID *keyword_ids, int keyword_count, VALUE *keyword_values
+);
 typedef void (*containers_native_reference_validator_t)(VALUE object);
 VALUE containers_publish_native_reference_free(VALUE self);
 VALUE containers_publish_native_with_references(

data/ext/farce/counter.c

@@ -338,8 +338,8 @@ counter_compare_and_set(VALUE self, VALUE expected_input, VALUE replacement_inpu
     return exchanged ? Qtrue : Qfalse;
 }
 
-/* The chainable operations are inherited directly by Farce::Counter. Keep
- * add/subtract as strict, value-returning primitives for internal callers. */
+/* Farce::Counter inherits these coercing operations directly. Internal
+ * add/subtract callers require strict Integer arguments. */
 static VALUE
 counter_increment(int argc, VALUE *argv, VALUE self)
 {
@@ -352,8 +352,7 @@ counter_increment(int argc, VALUE *argv, VALUE self)
         rb_check_frozen(self);
     }
     long long delta = NUM2LL(input);
-    (void)counter_change(counter, delta, false);
-    return self;
+    return counter_change(counter, delta, false);
 }
 
 static VALUE
@@ -368,8 +367,7 @@ counter_decrement(int argc, VALUE *argv, VALUE self)
         rb_check_frozen(self);
     }
     long long delta = NUM2LL(input);
-    (void)counter_change(counter, delta, true);
-    return self;
+    return counter_change(counter, delta, true);
 }
 
 void

data/ext/farce/depend

@@ -7,11 +7,13 @@ reactor.o: reactor.c reactor.h futex.h
 drivers.o: drivers.c reactor.h futex.h
 io.o: io.c reactor.h futex.h
 tree_map.o: tree_map.c containers.h native_wait.h futex.h
+trie.o: trie.c containers.h trie_search.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
 
-atom.o: atom.c containers.h transaction.h native_wait.h futex.h
+atom.o: atom.c containers.h transaction.h native_wait.h futex.h weak_references.h
+weak_map.o: weak_map.c containers.h weak_references.h
 map.o: map.c containers.h transaction.h native_wait.h futex.h
 vector.o: vector.c containers.h transaction.h native_wait.h futex.h
 signal.o: signal.c containers.h native_wait.h futex.h

data/ext/farce/extconf.rb

@@ -103,19 +103,21 @@ if epoll || kqueue
   end
 end
 
-weak_callback = try_compile(<<~SOURCE)
-  #include "ruby.h"
-
-  static void handle_weak_references(void *pointer) { (void)pointer; }
-  static const rb_data_type_t probe_type = {
-      .wrap_struct_name = "weak-reference-probe",
-      .function = {
-          .handle_weak_references = handle_weak_references,
-      },
-  };
-
-  int main(void) { return probe_type.function.handle_weak_references == 0; }
-SOURCE
+# The internal callback gained an object-space argument during Ruby 4.1
+# development. Check its exact type, since incompatible assignments may only warn.
+weak_callback_arguments = ["void *, void *", "void *"].find do |arguments|
+  try_compile(<<~SOURCE)
+    #include "ruby.h"
+
+    _Static_assert(
+        _Generic(((rb_data_type_t *)0)->function.handle_weak_references,
+            void (*)(#{arguments}): 1, default: 0),
+        "unsupported weak-reference callback"
+    );
+
+    int main(void) { return 0; }
+  SOURCE
+end
 
 weak_declare = have_func("rb_gc_declare_weak_references")
 weak_alive   = have_func("rb_gc_handle_weak_references_alive_p")
@@ -123,7 +125,10 @@ weak_alive   = have_func("rb_gc_handle_weak_references_alive_p")
 # Kazlib deliberately puts full-tree integrity walks behind assert(3).
 # Enable them only while debugging the priority queue.
 $defs << "-DNDEBUG" unless ENV["FARCE_PRIORITY_QUEUE_ASSERTIONS"] == "1"
-$defs << "-DRC_HAVE_NATIVE_WEAK_REFERENCES=1" if weak_callback && weak_declare && weak_alive
+if weak_callback_arguments && weak_declare && weak_alive
+  $defs << "-DRC_HAVE_NATIVE_WEAK_REFERENCES=1"
+  $defs << "-DFARCE_WEAK_REFERENCES_HAVE_OBJSPACE=1" if weak_callback_arguments == "void *, void *"
+end
 $defs << "-DFARCE_TRIE_FAILURE_INJECTION" if ENV["FARCE_TRIE_FAILURE_INJECTION"] == "1"
 $CFLAGS  = "#{$CFLAGS} -std=c11 -fvisibility=hidden -Wall -Wextra -Wno-unused-parameter -Wno-unused-function"
 $LDFLAGS = "#{$LDFLAGS} -pthread" unless /mswin|mingw/ =~ RUBY_PLATFORM

data/ext/farce/farce.c

@@ -43,6 +43,40 @@ containers_strict_bool(VALUE value, const char *name)
     rb_raise(rb_eArgError, "%s must be true or false", name);
 }
 
+VALUE
+containers_parse_constructor(
+    int argc, const VALUE *argv, const ID *keyword_ids, int keyword_count, VALUE *keyword_values
+)
+{
+    VALUE keywords = Qnil;
+    int positional_count = argc;
+    if (argc > 0 && rb_keyword_given_p()) keywords = argv[--positional_count];
+    rb_check_arity(positional_count, 0, 1);
+
+    int found = 0;
+    for (int index = 0; index < keyword_count; index++) {
+        VALUE value = NIL_P(keywords)
+            ? Qundef
+            : rb_hash_lookup2(keywords, ID2SYM(keyword_ids[index]), Qundef);
+        keyword_values[index] = value;
+        if (value != Qundef) found++;
+    }
+    if (!NIL_P(keywords) && RHASH_SIZE(keywords) != (size_t)found) {
+        /* Ruby's unknown-keyword error path deletes recognized keys, even
+         * when no output values are requested. Copy only for that error. */
+        rb_get_kwargs(rb_hash_dup(keywords), keyword_ids, 0, keyword_count, keyword_values);
+    }
+    return positional_count ? argv[0] : Qnil;
+}
+
+static int
+containers_find_public_ivar(ID name, VALUE value, st_data_t found)
+{
+    if (!rb_is_instance_id(name)) return ST_CONTINUE;
+    *(bool *)found = true;
+    return ST_STOP;
+}
+
 static void
 containers_check_native_publication_target(VALUE self)
 {
@@ -53,15 +87,15 @@ containers_check_native_publication_target(VALUE self)
         rb_raise(rb_eTypeError, "native publication requires a shareable typed-data descriptor");
     }
 
-    VALUE instance_variables = rb_obj_instance_variables(self);
-    if (RARRAY_LEN(instance_variables) != 0) {
+    bool has_public_ivar = false;
+    rb_ivar_foreach(self, containers_find_public_ivar, (st_data_t)&has_public_ivar);
+    if (has_public_ivar) {
         rb_raise(
             rb_eTypeError,
             "%s cannot be published with Ruby instance variables",
             rb_obj_classname(self)
         );
     }
-    RB_GC_GUARD(instance_variables);
 }
 
 VALUE
@@ -306,6 +340,14 @@ containers_raise_key_error(VALUE receiver, VALUE key)
     rb_exc_raise(exception);
 }
 
+static VALUE
+farce_value_changed(VALUE namespace, VALUE current, VALUE expected, VALUE identity)
+{
+    if (current == expected) return Qfalse;
+    if (RTEST(identity)) return identity;
+    return RTEST(rb_equal(current, expected)) ? Qfalse : Qtrue;
+}
+
 static VALUE
 farce_futex_supported(VALUE namespace)
 {
@@ -319,6 +361,63 @@ farce_load_native_fiber_scheduler(VALUE namespace)
     return Qnil;
 }
 
+#if RUBY_API_VERSION_CODE >= 40100
+static rb_alloc_func_t farce_object_allocator;
+static VALUE farce_shareable_inclusion;
+
+static VALUE
+farce_new_shareable(int argc, VALUE *argv, VALUE klass)
+{
+    /* Ordinary ivar writes then include the hidden ID in the class's size
+     * hint, keeping later instances embedded instead of spilling at publication.
+     * Leave the allocator unchanged: Ruby's copy path requires a root shape. */
+    VALUE object = rb_obj_alloc(klass);
+    if (RB_TYPE_P(object, T_OBJECT)) rb_obj_id(object);
+    rb_obj_call_init_kw(object, argc, argv, RB_PASS_CALLED_KEYWORDS);
+    return object;
+}
+
+static VALUE
+farce_prepare_shareable_class(VALUE namespace, VALUE base)
+{
+    if (RB_TYPE_P(base, T_CLASS) && !RB_FL_TEST_RAW(base, RUBY_FL_SINGLETON)) {
+        ID id_new = rb_intern("new");
+        if (rb_get_alloc_func(base) == farce_object_allocator &&
+            rb_method_basic_definition_p(rb_singleton_class(base), id_new)) {
+            VALUE constructor = rb_obj_method(base, ID2SYM(id_new));
+            if (rb_funcall(constructor, rb_intern("owner"), 0) == rb_cClass) {
+                rb_define_singleton_method(base, "new", farce_new_shareable, -1);
+            }
+        }
+    }
+    else if (RB_TYPE_P(base, T_MODULE)) {
+        rb_prepend_module(rb_singleton_class(base), farce_shareable_inclusion);
+    }
+    return base;
+}
+
+static VALUE
+farce_shareable_included(VALUE self, VALUE base)
+{
+    VALUE result = rb_call_super(1, &base);
+    farce_prepare_shareable_class(Qnil, base);
+    return result;
+}
+#endif
+
+static VALUE
+farce_publish_shareable(VALUE namespace, VALUE object)
+{
+#if RUBY_API_VERSION_CODE >= 40100
+    /* A frozen facade can bypass Ruby's object-ID preallocation during
+     * make_shareable. Reserve the ID before freezing so a later object_id
+     * cannot resize shared ivar storage while another Ractor reads it. */
+    rb_obj_id(object);
+#endif
+    rb_obj_freeze(object);
+    return rb_ractor_make_shareable(object);
+}
+
 #if RUBY_API_VERSION_CODE == 30400
 static VALUE
 farce_lock_native_thread(VALUE namespace)
@@ -336,6 +435,14 @@ Init_farce(void)
     VALUE mInternal = rb_const_get(mFarce, rb_intern("Internal"));
     VALUE singleton = rb_singleton_class(mInternal);
     eIsolationError = rb_const_get(rb_cRactor, rb_intern("IsolationError"));
+    rb_define_singleton_method(mInternal, "value_changed?", farce_value_changed, 3);
+#if RUBY_API_VERSION_CODE >= 40100
+    farce_object_allocator = rb_get_alloc_func(rb_cObject);
+    farce_shareable_inclusion = rb_define_module_under(mInternal, "ShareableConstruction");
+    rb_define_method(farce_shareable_inclusion, "included", farce_shareable_included, 1);
+    rb_define_singleton_method(mInternal, "prepare_shareable_class", farce_prepare_shareable_class, 1);
+#endif
+    rb_define_singleton_method(mInternal, "publish_shareable", farce_publish_shareable, 1);
 #if RUBY_API_VERSION_CODE == 30400
     rb_define_singleton_method(mInternal, "lock_native_thread", farce_lock_native_thread, 0);
 #endif

data/ext/farce/map.c

@@ -850,8 +850,6 @@ map_initialize_entry(VALUE key, VALUE value, VALUE opaque)
 static VALUE
 map_initialize(int argc, VALUE *argv, VALUE self)
 {
-    VALUE mapping = Qnil;
-    VALUE keywords = Qnil;
     ID keyword_ids[] = {
         rb_intern("compare_by_identity"),
         rb_intern("compare_keys_by_identity"),
@@ -860,8 +858,7 @@ map_initialize(int argc, VALUE *argv, VALUE self)
     VALUE keyword_values[3] = {Qundef, Qundef, Qundef};
     map_t *map;
 
-    rb_scan_args(argc, argv, "01:", &mapping, &keywords);
-    if (!NIL_P(keywords)) rb_get_kwargs(keywords, keyword_ids, 0, 3, keyword_values);
+    VALUE mapping = containers_parse_constructor(argc, argv, keyword_ids, 3, keyword_values);
     TypedData_Get_Struct(self, map_t, &map_type, map);
     if (map->initialized) rb_raise(rb_eRuntimeError, "Map is already initialized");
 
@@ -1417,9 +1414,15 @@ map_modify_body(VALUE opaque)
 }
 
 static VALUE
-map_modify(VALUE self, VALUE key)
+map_modify(int argc, VALUE *argv, VALUE self)
 {
     rb_check_frozen(self);
+    VALUE key;
+    VALUE keywords = Qnil;
+    VALUE keyword_values[1] = {Qundef};
+    ID keyword_ids[] = {rb_intern("timeout")};
+    rb_scan_args(argc, argv, "1:", &key, &keywords);
+    if (!NIL_P(keywords)) rb_get_kwargs(keywords, keyword_ids, 0, 1, keyword_values);
     rb_need_block();
     map_t *map = get_map(self);
     key = map_prepare_key(map, key);
@@ -1432,7 +1435,12 @@ map_modify(VALUE self, VALUE key)
     };
     operation.hash = map_key_hash(map, key);
     rb_check_frozen(self);
-    map_lock_for_key(map, key, operation.hash, &operation.execution);
+    map_timeout_t timeout = map_parse_timeout(
+        keyword_values[0] == Qundef ? Qnil : keyword_values[0]
+    );
+    if (!map_lock_for_key_with_timeout(
+        map, key, operation.hash, &timeout, &operation.execution
+    )) return Qfalse;
     bool found;
     size_t index = map_find_slot(map, key, operation.hash, &found, &operation.execution);
     if (RB_OBJ_FROZEN(self)) {
@@ -2151,7 +2159,7 @@ map_define_methods(VALUE klass)
     rb_define_method(klass, "store", map_store_with_timeout, -1);
     rb_define_method(klass, "swap", map_swap, -1);
     rb_define_method(klass, "update", map_update, -1);
-    rb_define_method(klass, "modify", map_modify, 1);
+    rb_define_method(klass, "modify", map_modify, -1);
     rb_define_method(klass, "wait_until_changed", map_wait_until_changed, -1);
     rb_define_method(klass, "wait_until_non_nil", map_wait_until_non_nil, -1);
     rb_define_method(klass, "store_if_absent", map_store_if_absent, -1);

data/ext/farce/priority_queue.c

@@ -1964,11 +1964,55 @@ priority_queue_oldest_age(VALUE self)
     return priority_queue_call(self, queue, priority_queue_oldest_age_body, (VALUE)&operation);
 }
 
+static VALUE
+priority_queue_capacity_body(VALUE opaque)
+{
+    priority_queue_self_operation_t *operation = (priority_queue_self_operation_t *)opaque;
+    return operation->queue->bounded ? SIZET2NUM(operation->queue->capacity) : Qnil;
+}
+
 static VALUE
 priority_queue_capacity(VALUE self)
 {
     priority_queue_t *queue = priority_queue_get(self);
-    return queue->bounded ? SIZET2NUM(queue->capacity) : Qnil;
+    priority_queue_self_operation_t operation = {.queue = queue, .self = self};
+    if (priority_queue_can_run_direct(queue)) return priority_queue_capacity_body((VALUE)&operation);
+    return priority_queue_call(self, queue, priority_queue_capacity_body, (VALUE)&operation);
+}
+
+typedef struct {
+    priority_queue_t *queue;
+    VALUE value;
+    size_t capacity;
+    bool bounded;
+} priority_queue_resize_t;
+
+static VALUE
+priority_queue_set_capacity_body(VALUE opaque)
+{
+    priority_queue_resize_t *resize = (priority_queue_resize_t *)opaque;
+    priority_queue_notify_before_commit(resize->queue);
+    resize->queue->capacity = resize->capacity;
+    resize->queue->bounded = resize->bounded;
+    return resize->value;
+}
+
+static VALUE
+priority_queue_set_capacity(VALUE self, VALUE value)
+{
+    priority_queue_t *queue = priority_queue_get(self);
+    priority_queue_resize_t resize = {.queue = queue, .value = value, .capacity = 0, .bounded = !NIL_P(value)};
+    if (resize.bounded) {
+        resize.value = rb_to_int(value);
+        long long capacity = NUM2LL(resize.value);
+        if (capacity <= 0) rb_raise(rb_eArgError, "capacity must be positive or nil");
+        if ((unsigned long long)capacity > (unsigned long long)SIZE_MAX) {
+            rb_raise(rb_eArgError, "capacity is too large");
+        }
+        resize.capacity = (size_t)capacity;
+    }
+    if (priority_queue_can_run_direct(queue)) return priority_queue_set_capacity_body((VALUE)&resize);
+    return priority_queue_call(self, queue, priority_queue_set_capacity_body, (VALUE)&resize);
 }
 
 static void
@@ -1999,6 +2043,7 @@ priority_queue_define_methods(VALUE klass)
     rb_define_method(klass, "oldest_enqueued_at", priority_queue_oldest_enqueued_at, 0);
     rb_define_method(klass, "oldest_age", priority_queue_oldest_age, 0);
     rb_define_method(klass, "capacity", priority_queue_capacity, 0);
+    rb_define_method(klass, "capacity=", priority_queue_set_capacity, 1);
     rb_define_method(klass, "freeze", priority_queue_freeze, 0);
     rb_define_method(klass, "frozen?", priority_queue_frozen_p, 0);
 }