farce 0.5.0-aarch64-linux-gnu → 0.6.0-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29c08153d7bd4d5a305e7e70f260fef0cba2e5dfa7f1e8dc99af163dcfd5baf3
-  data.tar.gz: 107b066e56e91ec2f7964c2df67674e8828bdf48cceede77ba5a3685c58f4251
+  metadata.gz: 5e2c2a98a1e2d92757f55523e856de7f0d8e0cb0c2387101a2f020d1aacba7e6
+  data.tar.gz: 1e1f813f06c4d852affb7d2651405905adcb9446252609efb39a6debfc33f7f3
 SHA512:
-  metadata.gz: b142d0d80c4767b6806333dd4d77bd7c278fbb85e43a8ffb6a6cbf55e6806ab6b175662a9e51f65ad85aa004c9419d05d0cf102adb0ca1ad49772c5efa4f7812
-  data.tar.gz: 5d1b89f719415cf79788306f5ec62fdf493a88f474d4e43a5fe7e5ec936998dcf89ce982b4846e2c6b056994206ef6b8475419ffa4d380c76bbcc1478549e478
+  metadata.gz: a66f1a280334d4cb989df1bbeb8ec2e5823a4783b3ba88c47cdd9f576576d466231aa9c1d13faa8c5f758c358ec15874b6761e80e67e0bf850b36cd3e1af696e
+  data.tar.gz: e16ea65e445755b5849350870c4e995d5cec0ab2ce0943da6bd9343f12e5b36c27a0357c895ebd249e5c8138f9d3ad9e71a459163ed23131701555e7057bbbdb

data/CHANGELOG.md

@@ -6,6 +6,7 @@ Farce follows [Semantic Versioning 2.0](http://semver.org/). Any public method o
 
  Version                        | Date       | Important Changes
 --------------------------------|------------|--------------------------------------
+ [0.6.0](#farce-060-2026-11-04) | 2026-11-04 | Performance improvements, better counters, and `WeakCache`
  [0.5.0](#farce-050-2026-10-21) | 2026-10-21 | Publishers, memoization, pool and queue resizing, and better concurrent-ruby compatibility
  [0.4.1](#farce-041-2026-10-18) | 2026-10-18 | Include improved io_uring support in prebuilt Linux binaries
  [0.4.0](#farce-040-2026-10-16) | 2026-10-16 | Introduce `Farce::Backports`
@@ -15,6 +16,23 @@ Farce follows [Semantic Versioning 2.0](http://semver.org/). Any public method o
 
 ## Release History
 
+### Farce 0.6.0 (2026-11-04)
+
+#### Breaking Changes
+
+* `Counter` and `Local::Counter` arithmetic methods (`increment`, `add`, `decrement`, `subtract`, and `remove`) now return the integer produced by the atomic update instead of the counter. Use `number = counter.increment` to allocate sequence numbers without a separate read. Calls can no longer be chained.
+
+#### New Features
+
+* `Farce.dedup` can now deduplicate `Regexp`, `Range`, `Data`, and `SortedSet` instances.
+* `Farce::Walker` (and thus `Farce.freeze_graph`) correctly walk `Struct` and `Range` instances now.
+* Add `Farce::Strict::WeakCache`. It offers a subset of the API of `Farce::Strict::WeakValueMap`, but without its performance penalty on CRuby 3.x and 4.0 (on other Rubies, including CRuby 4.1, it's just a tiny wrapper around the well-performing `WeakValueMap`).
+
+#### Performance improvements
+
+* Faster construction of Map and Vector instances.
+* Speed up atoms and memoization.
+
 ### Farce 0.5.0 (2026-10-21)
 
 #### New Features

data/docs/modes.md

@@ -390,7 +390,7 @@ The same choices appear in several Farce APIs. Containers normally default to `:
 | `Farce::Exchanger` | `new`, `exchange` | The value offered to a partner. |
 | `Farce::WeakAtom` | `new`, `store`, `update`, and other replacement operations | Weakly held values. Supports only `:raise`, `:make_shareable`, and `:dedup`. Defaults to `:raise`. |
 | `Farce::Atom` | `new`, `store`, `swap`, `update`, and other replacement operations | The stored value. |
-| `Farce::Memoize` | `memoize`, `[]` | Memoized results with `scope: :global` (the default). With `weak: true`, supports only `:raise`, `:make_shareable`, and `:dedup`, and defaults to `:raise`. Other scopes ignore the mode. |
+| `Farce::Memoize` | `memoize`, `[]` | Memoized results with `scope: :global` (the default). `:strict` caches shareable results directly, including with `weak: true`. Weak memoization also accepts `:raise` (the default), `:make_shareable`, and `:dedup`. Other scopes ignore the mode. |
 | `Farce::Lazy`, `Farce::LazyRef` | `new` | The result computed once by the factory. |
 | `Farce::Task` | `new`, `schedule`, `try_schedule`, `in_parallel`, `on_main`, `add_argument` | Arguments and the successful result. `add_argument` overrides the mode for one argument. Scheduling can select local mode automatically. |
 | `Farce::Publisher`, `Farce::Unshared::Publisher`, `Farce::Local::Publisher` | `subscribe` with a block | Callback arguments and queued payloads. Defaults to `:smart` for `Publisher` and `:local` for its Unshared and Local variants. |

data/docs/utilities.md

@@ -59,6 +59,7 @@ Other classes Farce provides include:
 * `ThreadExecutor`: A [task executor](scheduling.md#scheduling-code) creating a new thread for each unit of work. Used on TruffleRuby.
 * `Walker`: A tool for walking a Ruby object tree.
 * `WeakValue`: A value object version of [`WeakRef`](shims.md#weakref). Allows handling references more explicitly, without automatic method delegation.
+* `Strict::WeakCache`: Ractor-shared weak maps are slow on CRuby before 4.1. `WeakCache` provides a faster alternative if entries aren't frequently garbage collected, but it does not allow deleting or replacing entries manually.
 
 In addition, Farce includes a range of error classes not listed here. Check the [API documentation](https://rkh.github.io/farce/) or [code base](https://github.com/rkh/farce/blob/main/lib/farce/error.rb) for these.
 

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
@@ -327,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)
@@ -345,6 +436,13 @@ Init_farce(void)
     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");