ractorize 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f6214e369ed8e100b4af65d8cebeeadbfc5ec288b5c93d896f3feb277944fb
-  data.tar.gz: 463beced042a7da641a824450a00447ba359e942a4a42a1e99723250611a808d
+  metadata.gz: f7827fd6bd911724e81479f2966f75aafb825c1320fb870531b08db1079b5b9c
+  data.tar.gz: bf7da9b30088e3554637b646ef4bb5ceab085d076f3e0097c68f236d647b3baf
 SHA512:
-  metadata.gz: 1e79f4cd57dc32ef2f113620fabc60df2b0811f1e68b7975e3c3109fc210fa2ef24c8b439b3e0664b8619401ee07191ce66a7de7dafc6c606c05426c6fcee088
-  data.tar.gz: 2927ab40a74c984c46110b3ace84158621dddceb2d45b5125d42f4dcdc9aadd846f364a712329d48054fb645e918abd64d760a6ee21026309c7414211b600647
+  metadata.gz: e7858c116a76c408a6c341ee8007a91a50e4caae089978564d2704535845248e14272c18909bd8f4e5458e6dbe97262afb2acc088fd79412f5231ff1f56d3de1
+  data.tar.gz: 0e3b0165b66489c83b3dc7ebe37873ad6600e4fb9239eeaa326440d700112bf13255a67532f84fdfd15c3d37afcb93285742a4a50e5eef0993231bab1c5976ff

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.0.10] - 2026-06-30
+
+- Handle thunks being cloned
+
+## [0.0.9] - 2026-06-29
+
+- Fix bug that results from moving Time, which is neither shareable nor movable!
+- Handle deadlocks that seem to arise from re-entrant #inspect calls
+
 ## [0.0.8] - 2026-06-24
 
 - Add GarbageCollector to close abandoned RactorizedObject ractors and Thunk ractors

data/src/ractorize/garbage_collection/tracker.rb

@@ -2,11 +2,13 @@ module Ractorize
   module GarbageCollection
     class Tracker
       attr_accessor :ractorized_object_id_to_ractor,
-                    :thunk_id_to_ractor
+                    :thunk_id_to_ractor,
+                    :ractor_to_thunk_ids
 
       def initialize
         self.ractorized_object_id_to_ractor = ObjectSpace::WeakMap.new
         self.thunk_id_to_ractor = ObjectSpace::WeakMap.new
+        self.ractor_to_thunk_ids = ObjectSpace::WeakKeyMap.new
       end
 
       def track_ractorized_object(ractorized_object)
@@ -24,9 +26,32 @@ module Ractorize
         thunk_id_to_ractor[thunk_id] = ractor
       end
 
+      def thunk_cloned(old_thunk_id, new_thunk_id, thunk_ractor)
+        thunk_ids = ractor_to_thunk_ids[thunk_ractor]
+
+        if thunk_ids
+          thunk_ids << new_thunk_id
+        else
+          ractor_to_thunk_ids[thunk_ractor] = [old_thunk_id, new_thunk_id]
+        end
+
+        thunk_id_to_ractor[new_thunk_id] = thunk_ractor
+      end
+
       def cleanup_after_thunk(thunk_id)
         ractor = thunk_id_to_ractor.delete(thunk_id)
-        ractor&.<<(:__close__)
+
+        return unless ractor
+
+        thunk_ids = ractor_to_thunk_ids[ractor]
+
+        if thunk_ids
+          thunk_ids.delete(thunk_id)
+
+          return unless thunk_ids.empty?
+        end
+
+        ractor << :__close__
       rescue Ractor::ClosedError
         # do nothing
       end

data/src/ractorize/garbage_collection/tracking_ractor.rb

@@ -0,0 +1,40 @@
+require_relative "../base_ractor"
+require_relative "tracker"
+
+module Ractorize
+  module GarbageCollection
+    class TrackingRactor < BaseRactor
+      class << self
+        def new
+          super(name: "GarbageCollection::TrackingRactor") do
+            tracker = Tracker.new
+
+            loop do
+              # SimpleCov branch coverage doesn't like that we aren't testing not matching anything
+              # but this does result in an error unlike case/when so no point in checking that.
+              # :nocov:
+              case receive
+                # :nocov:
+              in :track_ractorized_object, ractorized_object
+                tracker.track_ractorized_object(ractorized_object)
+              in :cleanup_after_ractorized_object, ractorized_object_id
+                tracker.cleanup_after_ractorized_object(ractorized_object_id)
+              in :track_thunk, thunk_id, thunk_ractor
+                tracker.track_thunk(thunk_id, thunk_ractor)
+              in :thunk_cloned, old_thunk_id, new_thunk_id, thunk_ractor
+                tracker.thunk_cloned(old_thunk_id, new_thunk_id, thunk_ractor)
+              in :cleanup_after_thunk, thunk_id
+                tracker.cleanup_after_thunk(thunk_id)
+              end
+            rescue TrackingRactor::ClosedError
+              # do nothing
+            end
+          end
+        end
+      end
+    end
+
+    TRACKING_RACTOR = TrackingRactor.new
+    private_constant :TRACKING_RACTOR
+  end
+end

data/src/ractorize/garbage_collection.rb

@@ -1,7 +1,5 @@
 module Ractorize
   module GarbageCollection
-    class TrackingRactor < BaseRactor; end
-
     class << self
       def track_ractorized_object(ractorized_object)
         # We have to define the finalizer here, not in the tracker, because it's not frozen yet
@@ -16,7 +14,7 @@ module Ractorize
       end
 
       def track_thunk(thunk)
-        # We have to define the finalizer here, not in the tracker, because it's not frozen yet
+        # We have to define the finalizer here, not in the tracker, because it's not shareable
         ObjectSpace.define_finalizer(thunk, &finalize_thunk_proc)
 
         begin
@@ -26,6 +24,24 @@ module Ractorize
         end
       end
 
+      def thunk_cloned(old_thunk, new_thunk)
+        ractor = old_thunk.__thunk_ractor__
+
+        # We have to define the finalizer here, not in the tracker, because it's not shareable
+        # ObjectSpace.define_finalizer(new_thunk, &finalize_thunk_proc)
+
+        begin
+          TRACKING_RACTOR << [
+            :thunk_cloned,
+            old_thunk.__object_id__,
+            new_thunk.__object_id__,
+            ractor
+          ].freeze
+        rescue TrackingRactor::ClosedError
+          # do nothing
+        end
+      end
+
       def cleanup_after_ractorized_object(ractorized_object_id)
         TRACKING_RACTOR << [:cleanup_after_ractorized_object, ractorized_object_id].freeze
       rescue Ractor::ClosedError
@@ -52,30 +68,5 @@ module Ractorize
         end
       end
     end
-
-    TRACKING_RACTOR = TrackingRactor.new do
-      tracker = Tracker.new
-
-      loop do
-        # SimpleCov branch coverage doesn't like that we aren't testing not matching anything
-        # but this does result in an error unlike case/when so no point in checking that.
-        # :nocov:
-        case receive
-          # :nocov:
-        in :track_ractorized_object, ractorized_object
-          tracker.track_ractorized_object(ractorized_object)
-        in :cleanup_after_ractorized_object, ractorized_object_id
-          tracker.cleanup_after_ractorized_object(ractorized_object_id)
-        in :track_thunk, thunk_id, thunk_ractor
-          tracker.track_thunk(thunk_id, thunk_ractor)
-        in :cleanup_after_thunk, thunk_id
-          tracker.cleanup_after_thunk(thunk_id)
-        end
-      rescue TrackingRactor::ClosedError
-        # do nothing
-      end
-    end
-
-    private_constant :TRACKING_RACTOR
   end
 end

data/src/ractorize/ractorized_object/ractorized_ractor.rb

@@ -0,0 +1,133 @@
+require_relative "../base_ractor"
+
+module Ractorize
+  class RactorizedObject < BasicObject
+    class RactorizedRactor < ::BaseRactor
+      class << self
+        def new(name: nil)
+          super do
+            mode = receive
+
+            object = case mode
+                     when :class
+                       klass, args, opts, block = receive
+                       target_class = klass
+                       klass.new(*args.freeze, **opts.freeze, &block)
+                     when :object
+                       o = receive
+                       target_class = o.class
+                       o
+                     when :class_arg_by_arg
+                       klass = receive
+                       target_class = klass
+
+                       args, opts, block = Ractorize.extract_args(self)
+
+                       klass.new(*args.freeze, **opts.freeze, &block)
+                     else
+                       # :nocov:
+                       raise "Invalid mode #{mode}"
+                       # :nocov:
+                     end
+
+            loop do
+              # rubocop:disable Lint/UselessAssignment
+              value = method_name = method_args = opts = return_port = thunk_ractor = block_given = nil
+              # rubocop:enable Lint/UselessAssignment
+              method_name, method_args, opts, return_port, thunk_ractor, block_given = receive
+
+              case method_name
+              when :__close__
+                begin
+                  # Time is not movable but also not shareable!
+                  move = !Ractor.shareable?(object) && !(Time === object)
+                  thunk_ractor&.send([:success, object].freeze, move:)
+                rescue RactorizedRactor::ClosedError
+                  # do nothing
+                end
+
+                object = nil
+                close
+                break
+              when :__target_object_id__
+                return_port = method_args
+
+                target_object_id = ::Object.instance_method(:object_id).bind_call(object)
+                return_port << target_object_id
+              else
+                if method_name == :__invoke_arg_by_arg__
+                  args_port = Ractorize::RactorizedObject::RactorizedRactor::Port.new
+                  return_port << args_port
+
+                  method_name = args_port.receive
+                  method_args, opts = Ractorize.extract_args(args_port)
+                end
+
+                if block_given
+                  block_result_port = Ractorize::RactorizedObject::RactorizedRactor::Port.new
+
+                  value = object.__send__(method_name, *method_args, **opts) do |*args, **opts, &b|
+                    Ractorize.prepare_args(target_class, args, opts, skip_move: true)
+
+                    return_port << [:yield, [args.dup.freeze, opts.dup.freeze, b].freeze, block_result_port].freeze
+
+                    outcome_type, return_value = block_result_port.receive
+
+                    case outcome_type
+                    when :normal
+                      return_value
+                    when :break
+                      # TODO: handle error situation
+                      break
+                    else
+                      # :nocov:
+                      raise "Not sure how to handle outcome_type #{outcome_type}"
+                      # :nocov:
+                    end
+                  end
+
+                  return_port << [:return, value].freeze
+                else
+                  value = object.__send__(method_name, *method_args, **opts)
+                  value = value.__value__ while Ractorize::Thunk === value
+
+                  begin
+                    if thunk_ractor
+                      thunk_ractor.send([:success, value].freeze)
+                    else
+                      return_port << value
+                    end
+                  rescue IOError => e
+                    # Unclear why this sometimes manifests as this error instead of ClosedError but
+                    # need to handle them both.
+                    # :nocov:
+                    raise unless e.message == "closed stream"
+                    # :nocov:
+                  rescue Ractor::ClosedError
+                    # Whoa... this error inherits from StopIteration and will kill the loop!!!
+                    # Nothing really to do here but keep the loop going and handle other
+                    # method calls to the ractorized object from other ractors.
+                  end
+                end
+              end
+
+              nil
+            end
+
+            nil
+          # object
+          rescue => e
+            # :nocov:
+            puts
+            puts "an unhandled error!!! #{e.class} #{e.message} #{e}"
+            puts e.backtrace
+            puts
+
+            raise
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/src/ractorize/ractorized_object.rb

@@ -3,8 +3,6 @@ require_relative "thunk"
 
 module Ractorize
   class RactorizedObject < BasicObject
-    class RactorizedRactor < ::BaseRactor; end
-
     class << self
       def method_should_use_thunk?(method_symbol)
         method_symbol != :== && method_symbol != :! && method_symbol != :!= &&
@@ -16,14 +14,14 @@ module Ractorize
     attr_reader :__object_id__, :__ractor__
 
     def initialize(mode, *args, **opts, &block)
-      @__ractor__ = RactorizedRactor.new(name: "#{args.first}<#{args.first.object_id}>", &RACTOR_PROC)
+      @__ractor__ = RactorizedRactor.new(name: "#{args.first}<#{args.first.object_id}>".freeze)
 
       case mode
       when :object
         @__ractor__ << :object
 
         outside_object = args.first
-
+        @__target_object_id__ = ::Object.instance_method(:object_id).bind_call(outside_object)
         @__target_class__ = outside_object.class
 
         if ::Ractor.shareable?(outside_object)
@@ -64,6 +62,10 @@ module Ractorize
           @__ractor__ << :class
           @__ractor__ << [klass, args.freeze, opts.dup.freeze, block].freeze
         end
+
+        return_port = ::Ractor::Port.new
+        @__ractor__ << [:__target_object_id__, return_port].freeze
+        @__target_object_id__ = return_port.receive
       else
         # :nocov:
         ::Kernel.raise "Invalid mode #{mode}"
@@ -192,11 +194,11 @@ module Ractorize
     # def equal?(other) = method_missing(:equal?, other) || super
     def to_s = inspect
 
+    # delegating this to the target object increases risk of a deadlock since
+    # sometimes #inspect calls #inspect on other objects and can lead to reentry and thus deadlock
     def inspect
       object_id = ::Object.instance_method(:object_id).bind(self).call
-      moved_object_inspect = method_missing(:inspect)
-
-      "RactorizedObject<#{object_id}>[#{moved_object_inspect}]".freeze
+      "RactorizedObject<#{object_id}>[#{@__target_class__}<#{@__target_object_id__}>]}"
     end
   end
 end

data/src/ractorize/thunk.rb

@@ -10,13 +10,20 @@ module Ractorize
       ::Ractorize::GarbageCollection.track_thunk(self)
     end
 
-    def initialize_clone(...)
-      # :nocov:
-      raise "CAREFUL! THUNK CLONED!!"
-      # :nocov:
-      # is this actually necessary?? Seems so?
+    def initialize_clone(original_thunk)
+      if __resolved__? && original_thunk.__resolved__?
+        # Seems this could happen if we had a frozen thunk whose @__value__ is not shareable
+        # Since the thunk's ractor is already gone nothing to worry about
+        return
+      end
+
+      self.__object_id__ = ::Object.instance_method(:object_id).bind_call(self)
+
+      ::Ractorize::GarbageCollection.thunk_cloned(original_thunk, self)
     end
 
+    def __resolved__? = defined?(@__value__)
+
     def method_missing(...)
       __value__.__send__(...)
     end

data/src/ractorize.rb

@@ -4,6 +4,22 @@ require_relative "ractorize/ractorized_class"
 
 module Ractorize
   class << self
+    def ractorize_object(object)
+      RactorizedObject.new(:object, object)
+    end
+
+    def ractorize_class(klass)
+      RactorizedClass[klass]
+    end
+
+    def [](object)
+      if object.is_a?(Class)
+        ractorize_class(object)
+      else
+        ractorize_object(object)
+      end
+    end
+
     # TODO: figure out a way to magically get a ractor-shareable proc from a non-ractor-shareable proc
     def auto_freeze(target, class_or_proc = nil)
       @auto_freeze = @auto_freeze ? @auto_freeze.dup : []
@@ -214,139 +230,4 @@ module Ractorize
       nil
     end
   end
-
-  # Putting this in a constant so we can get test coverage on it since not sure how to get coverage
-  # on something inside a ractor.
-  RACTOR_PROC = Ractor.shareable_proc do
-    mode = receive
-
-    object = case mode
-             when :class
-               klass, args, opts, block = receive
-               target_class = klass
-               klass.new(*args.freeze, **opts.freeze, &block)
-             when :object
-               o = receive
-               target_class = o.class
-               o
-             when :class_arg_by_arg
-               klass = receive
-               target_class = klass
-
-               args, opts, block = Ractorize.extract_args(self)
-
-               klass.new(*args.freeze, **opts.freeze, &block)
-             else
-               # :nocov:
-               raise "Invalid mode #{mode}"
-               # :nocov:
-             end
-
-    loop do
-      # rubocop:disable Lint/UselessAssignment
-      value = method_name = method_args = opts = return_port = thunk_ractor = block_given = nil
-      # rubocop:enable Lint/UselessAssignment
-      method_name, method_args, opts, return_port, thunk_ractor, block_given = receive
-
-      case method_name
-      when :__close__
-        begin
-          thunk_ractor&.send([:success, object].freeze, move: true)
-        rescue RactorizedRactor::ClosedError
-          # do nothing
-        end
-
-        object = nil
-        close
-        break
-      else
-        if method_name == :__invoke_arg_by_arg__
-          args_port = Ractorize::RactorizedObject::RactorizedRactor::Port.new
-          return_port << args_port
-
-          method_name = args_port.receive
-          method_args, opts = Ractorize.extract_args(args_port)
-        end
-
-        if block_given
-          block_result_port = Ractorize::RactorizedObject::RactorizedRactor::Port.new
-
-          value = object.__send__(method_name, *method_args, **opts) do |*args, **opts, &b|
-            Ractorize.prepare_args(target_class, args, opts, skip_move: true)
-
-            return_port << [:yield, [args.dup.freeze, opts.dup.freeze, b].freeze, block_result_port].freeze
-
-            outcome_type, return_value = block_result_port.receive
-
-            case outcome_type
-            when :normal
-              return_value
-            when :break
-              # TODO: handle error situation
-              break
-            else
-              # :nocov:
-              raise "Not sure how to handle outcome_type #{outcome_type}"
-              # :nocov:
-            end
-          end
-
-          return_port << [:return, value].freeze
-        else
-          value = object.__send__(method_name, *method_args, **opts)
-          value = value.__value__ while Ractorize::Thunk === value
-
-          begin
-            if thunk_ractor
-              thunk_ractor.send([:success, value].freeze)
-            else
-              return_port << value
-            end
-          rescue IOError => e
-            # Unclear why this sometimes manifests as this error instead of ClosedError but
-            # need to handle them both.
-            # :nocov:
-            raise unless e.message == "closed stream"
-            # :nocov:
-          rescue Ractor::ClosedError
-            # Whoa... this error inherits from StopIteration and will kill the loop!!!
-            # Nothing really to do here but keep the loop going and handle other
-            # method calls to the ractorized object from other ractors.
-          end
-        end
-      end
-
-      nil
-    end
-
-    nil
-    # object
-  rescue => e
-    # :nocov:
-    puts
-    puts "an unhandled error!!! #{e.class} #{e.message} #{e}"
-    puts e.backtrace
-    puts
-
-    raise
-    # :nocov:
-  end
-
-  class << self
-    def ractorize_object(object)
-      RactorizedObject.new(:object, object)
-    end
-
-    def ractorize_class(klass)
-      RactorizedClass[klass]
-    end
-
-    def [](object)
-      if object.is_a?(Class)
-        ractorize_class(object)
-      else
-        ractorize_object(object)
-      end
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ractorize
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.10
 platform: ruby
 authors:
 - Miles Georgi
@@ -24,8 +24,10 @@ files:
 - src/ractorize/base_ractor.rb
 - src/ractorize/garbage_collection.rb
 - src/ractorize/garbage_collection/tracker.rb
+- src/ractorize/garbage_collection/tracking_ractor.rb
 - src/ractorize/ractorized_class.rb
 - src/ractorize/ractorized_object.rb
+- src/ractorize/ractorized_object/ractorized_ractor.rb
 - src/ractorize/thunk.rb
 - src/ractorize/thunk/thunk_ractor.rb
 homepage: https://github.com/ractor-shack/ractorize