atomic-ruby 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecc5a5a825a6636db5718458318ba2650c05edb9a5a1198947f82e94596a974e
-  data.tar.gz: 7a08fbdf2e3362e03450ccb5d2342055c8e50832afae4bc709c5e1c5e187f88b
+  metadata.gz: 6bef30ee19f89bf213e837f5ee565b4e0b2f926c422dd7204270f349a331142c
+  data.tar.gz: b19ac4ac6c8f363c891aae5c7ef4b4c39c80b420673f71890fe8c4f1974dee89
 SHA512:
-  metadata.gz: f52cfbc19feaac870429dc893cbbf3541120e9beeaf20723d9f705b6a74835891473a299b682531d593e5adb1d2b3b75a0eed365b29e3490c1b921ea59aa4714
-  data.tar.gz: f797297e13eb693db8759e2bef195ed57288530dd05c8188b67dc1c9df1378476ed4e252b48385a2d951350e6e0f94f6b7aa3a2680d40885759d50fbdcdac1e9
+  metadata.gz: 8afd84e8e6cc724949c88c6485bd51e8d3ba86e56852ad742136613ce2f4a36468de88b7c011a2061218ff7edb189a8e8a13f3049741d5a020862c8cc9760e7d
+  data.tar.gz: d5727d75e5b3c6f4cce6c7dd394b1fd7d64d48f3940124a27f2725e1947c6aac375604fb98364a24aa6bbcb50670680b3b755c566f5092829b21eff7bef98d10

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [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

data/README.md

@@ -99,17 +99,6 @@ p latch.count #=> 0
 
 > [!NOTE]
 > `Atom`, `AtomicBoolean`, and `AtomicCountDownLatch` are Ractor-safe in Ruby 3.5+.
->
-> When storing procs in atoms, 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
 
@@ -221,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
@@ -231,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>
@@ -312,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>
@@ -390,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.1
+atomic-ruby version:     0.9.0
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.139026 seconds
-Atomic Ruby Atomic Thread Pool: 4.833597 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

@@ -17,8 +17,7 @@ module AtomicRuby
       @size = size
       @name = name
 
-      @queue = Queue.new
-      @state = Atom.new(shutdown: false)
+      @state = Atom.new(queue: [], shutdown: false)
       @started_threads = Atom.new(0)
       @threads = []
 
@@ -27,8 +26,11 @@ module AtomicRuby
 
     def <<(work)
       state = @state.swap do |current_state|
-        @queue.push(work) unless current_state[:shutdown]
-        current_state
+        if current_state[:shutdown]
+          current_state
+        else
+          current_state.merge(queue: [*current_state[:queue], work])
+        end
       end
       raise EnqueuedWorkAfterShutdownError if state[:shutdown]
     end
@@ -36,10 +38,12 @@ module AtomicRuby
     def length
       @threads.select(&:alive?).length
     end
+    alias size length
 
     def queue_length
-      @queue.size
+      @state.value[:queue].length
     end
+    alias queue_size queue_length
 
     def shutdown
       already_shutdown = false
@@ -53,7 +57,7 @@ module AtomicRuby
       end
       return if already_shutdown
 
-      Thread.pass until @queue.empty?
+      Thread.pass until @state.value[:queue].empty?
 
       @threads.each(&:join)
     end
@@ -74,12 +78,15 @@ module AtomicRuby
             should_shutdown = false
 
             @state.swap do |current_state|
-              if current_state[:shutdown] && @queue.empty?
+              if current_state[:shutdown] && current_state[:queue].empty?
                 should_shutdown = true
+                current_state
+              elsif current_state[:queue].empty?
+                current_state
               else
-                work = @queue.pop(timeout: 0)
+                work = current_state[:queue].first
+                current_state.merge(queue: current_state[:queue].drop(1))
               end
-              current_state
             end
 
             if should_shutdown

data/lib/atomic-ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtomicRuby
-  VERSION = "0.8.1"
+  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.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Joshua Young