atomic-ruby 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e35d6cd7774994256c00cbf310fa5511aaafac0c55e4b0919102f22b444961d
-  data.tar.gz: 763d472bdc50d97522f9a9f630f6d51f2db4832f9d507ca27d0f6dbae761ca54
+  metadata.gz: 6bef30ee19f89bf213e837f5ee565b4e0b2f926c422dd7204270f349a331142c
+  data.tar.gz: b19ac4ac6c8f363c891aae5c7ef4b4c39c80b420673f71890fe8c4f1974dee89
 SHA512:
-  metadata.gz: a39511160e42082e08f9d435a29ffe658325d0e93fa10818a6f60b5f54882bf698ce2d2dcd655a6cbde19bea9cd7ebc2ede86fd8ff5e70e95bb94750400a7f36
-  data.tar.gz: 89800c8d9fe359a497be8a71c463e3d22ef1585752d3320c85aeae0051634b41f70c78ace27502b452231b088de4a8e359ac7ab5be8ffa71836cdf564c9c2240
+  metadata.gz: 8afd84e8e6cc724949c88c6485bd51e8d3ba86e56852ad742136613ce2f4a36468de88b7c011a2061218ff7edb189a8e8a13f3049741d5a020862c8cc9760e7d
+  data.tar.gz: d5727d75e5b3c6f4cce6c7dd394b1fd7d64d48f3940124a27f2725e1947c6aac375604fb98364a24aa6bbcb50670680b3b755c566f5092829b21eff7bef98d10

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.9.0] - 2025-11-05
+
+- Switch `AtomicThreadPool` back to atomics now that Ractor safety is lazy
+- Don't enforce Ractor safety unless crossing Ractor boundaries
+- Add `AtomicThreadPool#size` and `AtomicThreadPool#queue_size` aliases
+
+## [0.8.1] - 2025-11-01
+
+- Don't require `AtomicThreadPool#<<` to be given a shareable proc
+
 ## [0.8.0] - 2025-11-01
 
 - Fix Ractor safety (requires Ruby 3.5+)

data/README.md

@@ -99,18 +99,6 @@ p latch.count #=> 0
 
 > [!NOTE]
 > `Atom`, `AtomicBoolean`, and `AtomicCountDownLatch` are Ractor-safe in Ruby 3.5+.
->
-> When storing procs in atoms (including queueing them with `AtomicThreadPool#<<`), create them
-> using `Ractor.shareable_proc`, as `Ractor.make_shareable` cannot convert regular procs to
-> shareable ones when the proc's context is not shareable.
->
-> ```ruby
-> # This will raise an error in Ruby 3.5+ (proc created in non-shareable context)
-> atom = Atom.new(proc { puts "hello" })
->
-> # Use this instead
-> atom = Atom.new(Ractor.shareable_proc { puts "hello" })
-> ```
 
 ## Benchmarks
 
@@ -222,9 +210,9 @@ puts "Atomic Ruby Atomic Bank Account:     #{results[2].real.round(6)} seconds"
 ```
 > bundle exec rake compile && bundle exec ruby examples/atom_benchmark.rb
 
-ruby version:            ruby 3.5.0dev (2025-10-31T18:08:15Z master 980e18496e) +YJIT +PRISM [arm64-darwin25]
+ruby version:            ruby 3.5.0dev (2025-11-05T10:35:48Z master 946d2d036f) +YJIT +PRISM [arm64-darwin25]
 concurrent-ruby version: 1.3.5
-atomic-ruby version:     0.8.0
+atomic-ruby version:     0.9.0
 
 Balances:
 Synchronized Bank Account Balance:           975
@@ -232,9 +220,9 @@ Concurrent Ruby Atomic Bank Account Balance: 975
 Atomic Ruby Atomic Bank Account Balance:     975
 
 Benchmark Results:
-Synchronized Bank Account:           5.105459 seconds
-Concurrent Ruby Atomic Bank Account: 5.101044 seconds
-Atomic Ruby Atomic Bank Account:     5.091892 seconds
+Synchronized Bank Account:           5.104234 seconds
+Concurrent Ruby Atomic Bank Account: 5.113334 seconds
+Atomic Ruby Atomic Bank Account:     5.097197 seconds
 ```
 
 </details>
@@ -313,29 +301,29 @@ end
 ```
 > bundle exec rake compile && bundle exec ruby examples/atomic_boolean_benchmark.rb
 
-ruby version:            ruby 3.5.0dev (2025-10-31T18:08:15Z master 980e18496e) +YJIT +PRISM [arm64-darwin25]
+ruby version:            ruby 3.5.0dev (2025-11-05T10:35:48Z master 946d2d036f) +YJIT +PRISM [arm64-darwin25]
 concurrent-ruby version: 1.3.5
-atomic-ruby version:     0.8.0
+atomic-ruby version:     0.9.0
 
 Warming up --------------------------------------
 Synchronized Boolean Toggle
-                       154.000 i/100ms
+                       158.000 i/100ms
 Concurrent Ruby Atomic Boolean Toggle
-                       127.000 i/100ms
+                       113.000 i/100ms
 Atomic Ruby Atomic Boolean Toggle
-                       139.000 i/100ms
+                       122.000 i/100ms
 Calculating -------------------------------------
 Synchronized Boolean Toggle
-                          1.458k (± 7.3%) i/s  (685.85 μs/i) -      7.392k in   5.102733s
+                          1.521k (± 2.1%) i/s  (657.49 μs/i) -      7.742k in   5.092579s
 Concurrent Ruby Atomic Boolean Toggle
-                          1.129k (± 9.7%) i/s  (886.10 μs/i) -      5.588k in   5.001783s
+                          1.141k (± 1.6%) i/s  (876.12 μs/i) -      5.763k in   5.050298s
 Atomic Ruby Atomic Boolean Toggle
-                          1.476k (± 6.0%) i/s  (677.44 μs/i) -      7.367k in   5.017482s
+                          1.243k (± 1.3%) i/s  (804.64 μs/i) -      6.222k in   5.007246s
 
 Comparison:
-Atomic Ruby Atomic Boolean Toggle:         1476.1 i/s
-Synchronized Boolean Toggle:               1458.1 i/s - same-ish: difference falls within error
-Concurrent Ruby Atomic Boolean Toggle:     1128.5 i/s - 1.31x  slower
+Synchronized Boolean Toggle:               1520.9 i/s
+Atomic Ruby Atomic Boolean Toggle:         1242.8 i/s - 1.22x  slower
+Concurrent Ruby Atomic Boolean Toggle:     1141.4 i/s - 1.33x  slower
 ```
 
 </details>
@@ -353,14 +341,6 @@ require "benchmark"
 require "concurrent-ruby"
 require_relative "../lib/atomic-ruby"
 
-def shareable_proc(&block)
-  if AtomicRuby::RACTOR_SAFE
-    Ractor.shareable_proc(&block)
-  else
-    block
-  end
-end
-
 results = []
 
 2.times do |idx|
@@ -371,11 +351,11 @@ results = []
     end
 
     100.times do
-      pool << shareable_proc { sleep(0.2) }
+      pool << proc { sleep(0.2) }
     end
 
     100.times do
-      pool << shareable_proc { 1_000_000.times.map(&:itself).sum }
+      pool << proc { 1_000_000.times.map(&:itself).sum }
     end
 
     pool.shutdown
@@ -399,13 +379,13 @@ puts "Atomic Ruby Atomic Thread Pool: #{results[1].real.round(6)} seconds"
 ```
 > bundle exec rake compile && bundle exec ruby examples/atomic_thread_pool_benchmark.rb
 
-ruby version:            ruby 3.5.0dev (2025-10-31T18:08:15Z master 980e18496e) +YJIT +PRISM [arm64-darwin25]
+ruby version:            ruby 3.5.0dev (2025-11-05T10:35:48Z master 946d2d036f) +YJIT +PRISM [arm64-darwin25]
 concurrent-ruby version: 1.3.5
-atomic-ruby version:     0.8.0
+atomic-ruby version:     0.9.0
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.13772 seconds
-Atomic Ruby Atomic Thread Pool: 4.893086 seconds
+Concurrent Ruby Thread Pool:    5.169928 seconds
+Atomic Ruby Atomic Thread Pool: 4.831942 seconds
 ```
 
 </details>

data/ext/atomic_ruby/atomic_ruby.c

@@ -2,11 +2,17 @@
 
 typedef struct {
   volatile VALUE value;
+#ifdef ATOMIC_RUBY_RACTOR_SAFE
+  VALUE initialized_ractor;
+#endif
 } atomic_ruby_atom_t;
 
 static void atomic_ruby_atom_mark(void *ptr) {
   atomic_ruby_atom_t *atomic_ruby_atom = (atomic_ruby_atom_t *)ptr;
   rb_gc_mark_movable(atomic_ruby_atom->value);
+#ifdef ATOMIC_RUBY_RACTOR_SAFE
+  rb_gc_mark_movable(atomic_ruby_atom->initialized_ractor);
+#endif
 }
 
 static void atomic_ruby_atom_free(void *ptr) {
@@ -21,6 +27,9 @@ static size_t atomic_ruby_atom_memsize(const void *ptr) {
 static void atomic_ruby_atom_compact(void *ptr) {
   atomic_ruby_atom_t *atomic_ruby_atom = (atomic_ruby_atom_t *)ptr;
   atomic_ruby_atom->value = rb_gc_location(atomic_ruby_atom->value);
+#ifdef ATOMIC_RUBY_RACTOR_SAFE
+  atomic_ruby_atom->initialized_ractor = rb_gc_location(atomic_ruby_atom->initialized_ractor);
+#endif
 }
 
 static const rb_data_type_t atomic_ruby_atom_type = {
@@ -38,35 +47,54 @@ static const rb_data_type_t atomic_ruby_atom_type = {
 #endif
 };
 
+#ifdef ATOMIC_RUBY_RACTOR_SAFE
+static void ensure_value_shareable(VALUE self, atomic_ruby_atom_t *atom, VALUE value) {
+  bool check_shareable = NIL_P(atom->initialized_ractor);
+
+  if (!check_shareable) {
+    VALUE current_ractor = rb_funcall(rb_cRactor, rb_intern("current"), 0);
+    if (current_ractor != atom->initialized_ractor) {
+      check_shareable = true;
+      RB_OBJ_WRITE(self, &atom->initialized_ractor, Qnil);
+    }
+  }
+
+  if (check_shareable && !rb_ractor_shareable_p(value)) {
+    rb_raise(rb_eArgError, "value must be a shareable object when used across ractors");
+  }
+}
+#endif
+
 static VALUE rb_cAtom_allocate(VALUE klass) {
   atomic_ruby_atom_t *atomic_ruby_atom;
   VALUE obj = TypedData_Make_Struct(klass, atomic_ruby_atom_t, &atomic_ruby_atom_type, atomic_ruby_atom);
   RB_OBJ_WRITE(obj, &atomic_ruby_atom->value, Qnil);
-  return obj;
-}
-
 #ifdef ATOMIC_RUBY_RACTOR_SAFE
-static void check_value_shareable(VALUE value) {
-  if (!rb_ractor_shareable_p(value)) {
-    rb_raise(rb_eArgError, "value must be a shareable object");
-  }
-}
+  VALUE current_ractor = rb_funcall(rb_cRactor, rb_intern("current"), 0);
+  RB_OBJ_WRITE(obj, &atomic_ruby_atom->initialized_ractor, current_ractor);
 #endif
+  return obj;
+}
 
 static VALUE rb_cAtom_initialize(VALUE self, VALUE value) {
   atomic_ruby_atom_t *atomic_ruby_atom;
   TypedData_Get_Struct(self, atomic_ruby_atom_t, &atomic_ruby_atom_type, atomic_ruby_atom);
+  RB_OBJ_WRITE(self, &atomic_ruby_atom->value, value);
 #ifdef ATOMIC_RUBY_RACTOR_SAFE
-  check_value_shareable(value);
+  rb_obj_freeze(self);
+  FL_SET_RAW(self, RUBY_FL_SHAREABLE);
 #endif
-  RB_OBJ_WRITE(self, &atomic_ruby_atom->value, value);
   return self;
 }
 
 static VALUE rb_cAtom_value(VALUE self) {
   atomic_ruby_atom_t *atomic_ruby_atom;
   TypedData_Get_Struct(self, atomic_ruby_atom_t, &atomic_ruby_atom_type, atomic_ruby_atom);
-  return (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_atom->value);
+  VALUE value = (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_atom->value);
+#ifdef ATOMIC_RUBY_RACTOR_SAFE
+  ensure_value_shareable(self, atomic_ruby_atom, value);
+#endif
+  return value;
 }
 
 static VALUE rb_cAtom_swap(VALUE self) {
@@ -78,7 +106,7 @@ static VALUE rb_cAtom_swap(VALUE self) {
     expected_old_value = atomic_ruby_atom->value;
     new_value = rb_yield(expected_old_value);
 #ifdef ATOMIC_RUBY_RACTOR_SAFE
-    check_value_shareable(new_value);
+    ensure_value_shareable(self, atomic_ruby_atom, new_value);
 #endif
   } while (RUBY_ATOMIC_VALUE_CAS(atomic_ruby_atom->value, expected_old_value, new_value) != expected_old_value);
   RB_OBJ_WRITTEN(self, expected_old_value, new_value);
@@ -86,6 +114,14 @@ static VALUE rb_cAtom_swap(VALUE self) {
   return new_value;
 }
 
+#ifdef ATOMIC_RUBY_RACTOR_SAFE
+static VALUE rb_cAtom_initialized_ractor(VALUE self) {
+  atomic_ruby_atom_t *atomic_ruby_atom;
+  TypedData_Get_Struct(self, atomic_ruby_atom_t, &atomic_ruby_atom_type, atomic_ruby_atom);
+  return atomic_ruby_atom->initialized_ractor;
+}
+#endif
+
 RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
 #ifdef ATOMIC_RUBY_RACTOR_SAFE
   rb_ext_ractor_safe(true);
@@ -100,6 +136,7 @@ RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
   rb_define_method(rb_cAtom, "_swap", rb_cAtom_swap, 0);
 
 #ifdef ATOMIC_RUBY_RACTOR_SAFE
+  rb_define_method(rb_cAtom, "_initialized_ractor", rb_cAtom_initialized_ractor, 0);
   rb_define_const(rb_mAtomicRuby, "RACTOR_SAFE", Qtrue);
 #else
   rb_define_const(rb_mAtomicRuby, "RACTOR_SAFE", Qfalse);

data/ext/atomic_ruby/atomic_ruby.h

@@ -3,11 +3,11 @@
 
 #include "ruby.h"
 #include "ruby/atomic.h"
-#include "ruby/ractor.h"
 #include "ruby/version.h"
 
 #if RUBY_API_VERSION_CODE >= 30500
 #define ATOMIC_RUBY_RACTOR_SAFE 1
+#include "ruby/ractor.h"
 #endif
 
 #endif /* ATOMIC_RUBY_ATOM_H */

data/ext/atomic_ruby/extconf.rb

@@ -2,9 +2,6 @@
 
 require "mkmf"
 
-# Makes all symbols private by default to avoid unintended conflict
-# with other gems. To explicitly export symbols you can use RUBY_FUNC_EXPORTED
-# selectively, or entirely remove this flag.
 append_cflags("-fvisibility=hidden")
 
 create_makefile("atomic_ruby/atomic_ruby")

data/lib/atomic-ruby/atom.rb

@@ -5,9 +5,7 @@ require "atomic_ruby/atomic_ruby"
 module AtomicRuby
   class Atom
     def initialize(value)
-      _initialize(make_shareable(value))
-
-      freeze if RACTOR_SAFE
+      _initialize(value)
     end
 
     def value
@@ -16,14 +14,15 @@ module AtomicRuby
 
     def swap(&block)
       _swap do |old_value|
-        make_shareable(block.call(old_value))
+        make_shareable_if_needed(block.call(old_value))
       end
     end
 
     private
 
-    def make_shareable(value)
-      if RACTOR_SAFE
+    def make_shareable_if_needed(value)
+      if RACTOR_SAFE &&
+         (_initialized_ractor.nil? || Ractor.current != _initialized_ractor)
         Ractor.make_shareable(value)
       else
         value

data/lib/atomic-ruby/atomic_thread_pool.rb

@@ -38,10 +38,12 @@ module AtomicRuby
     def length
       @threads.select(&:alive?).length
     end
+    alias size length
 
     def queue_length
       @state.value[:queue].length
     end
+    alias queue_size queue_length
 
     def shutdown
       already_shutdown = false

data/lib/atomic-ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtomicRuby
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Joshua Young