ractorize 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02d57de76c96c80c8fa5d7a49dcc54a12e9c7f849ff8951faba91806ff5dadbb
-  data.tar.gz: e6ae43cf484790673a4010505622b7255a09b7a5d04f358a2b5a8bec0ab6b917
+  metadata.gz: 52f6214e369ed8e100b4af65d8cebeeadbfc5ec288b5c93d896f3feb277944fb
+  data.tar.gz: 463beced042a7da641a824450a00447ba359e942a4a42a1e99723250611a808d
 SHA512:
-  metadata.gz: 5034e676239f3e6ccd3ea1aa83a0923c0b439800127fd1a3444c08ce93de706f48b05f87e68d697cddb6612d42d7ca057b1b29adef5954ca5b51575cd1320050
-  data.tar.gz: 461059bac8aeea154ec67ed22ed530ac7f8921902bef688d7a5d21927e67adaaab582e2bc528b7a556b4c1fb733a37b9a9202bf261eb6d048125761d516a720f
+  metadata.gz: 1e79f4cd57dc32ef2f113620fabc60df2b0811f1e68b7975e3c3109fc210fa2ef24c8b439b3e0664b8619401ee07191ce66a7de7dafc6c606c05426c6fcee088
+  data.tar.gz: 2927ab40a74c984c46110b3ace84158621dddceb2d45b5125d42f4dcdc9aadd846f364a712329d48054fb645e918abd64d760a6ee21026309c7414211b600647

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.0.8] - 2026-06-24
+
+- Add GarbageCollector to close abandoned RactorizedObject ractors and Thunk ractors
+- Switch thunks to work off of Ractor instead of Ractor::Port due to port/ractor leaks
+- Block on #hash and delegate to super in #==/#!=
+- Significant test suite improvements:
+  - Remove awkward RACTORIZE_PROC tests and instead use the shmactor gem to get to 100% branch coverage
+  - Parallelize the build and run a shmactor build to get full coverage of ractor procs
+  - Check for leaked ractors/ports after test suite and fail the build on any memory leaks
+
 ## [0.0.7] - 2026-06-06
 
 - Closed Ractor::Ports sometimes give IOError instead of Ractor::ClosedError so handle both

data/src/ractorize/base_ractor.rb

@@ -0,0 +1,2 @@
+# We do it this way to allow easily swapping out with Shmactor
+BaseRactor ||= Ractor # rubocop:disable Lint/OrAssignmentToConstant

data/src/ractorize/garbage_collection/tracker.rb

@@ -0,0 +1,35 @@
+module Ractorize
+  module GarbageCollection
+    class Tracker
+      attr_accessor :ractorized_object_id_to_ractor,
+                    :thunk_id_to_ractor
+
+      def initialize
+        self.ractorized_object_id_to_ractor = ObjectSpace::WeakMap.new
+        self.thunk_id_to_ractor = ObjectSpace::WeakMap.new
+      end
+
+      def track_ractorized_object(ractorized_object)
+        ractorized_object_id_to_ractor[ractorized_object.__object_id__] = ractorized_object.__ractor__
+      end
+
+      def cleanup_after_ractorized_object(ractorized_object_id)
+        ractor = ractorized_object_id_to_ractor.delete(ractorized_object_id)
+        ractor&.<<(:__close__)
+      rescue Ractor::ClosedError
+        # do nothing
+      end
+
+      def track_thunk(thunk_id, ractor)
+        thunk_id_to_ractor[thunk_id] = ractor
+      end
+
+      def cleanup_after_thunk(thunk_id)
+        ractor = thunk_id_to_ractor.delete(thunk_id)
+        ractor&.<<(:__close__)
+      rescue Ractor::ClosedError
+        # do nothing
+      end
+    end
+  end
+end

data/src/ractorize/garbage_collection.rb

@@ -0,0 +1,81 @@
+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
+        ObjectSpace.define_finalizer(ractorized_object, &finalize_proc)
+        Object.instance_method(:freeze).bind_call(ractorized_object)
+
+        begin
+          TRACKING_RACTOR << [:track_ractorized_object, ractorized_object].freeze
+        rescue TrackingRactor::ClosedError
+          # do nothing
+        end
+      end
+
+      def track_thunk(thunk)
+        # We have to define the finalizer here, not in the tracker, because it's not frozen yet
+        ObjectSpace.define_finalizer(thunk, &finalize_thunk_proc)
+
+        begin
+          TRACKING_RACTOR << [:track_thunk, thunk.__object_id__, thunk.__thunk_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
+        # do nothing
+      end
+
+      def cleanup_after_thunk(thunk_id)
+        TRACKING_RACTOR << [:cleanup_after_thunk, thunk_id].freeze
+      rescue Ractor::ClosedError
+        # do nothing
+      end
+
+      private
+
+      def finalize_proc
+        proc do |ractorized_object_id|
+          ::Ractorize::GarbageCollection.cleanup_after_ractorized_object(ractorized_object_id)
+        end
+      end
+
+      def finalize_thunk_proc
+        proc do |thunk_id|
+          ::Ractorize::GarbageCollection.cleanup_after_thunk(thunk_id)
+        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.rb

@@ -3,22 +3,34 @@ 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 != :!= &&
+          method_symbol != :inspect && method_symbol != :to_s &&
+          !method_symbol.end_with?("?") && method_symbol != :hash
+      end
+    end
+
+    attr_reader :__object_id__, :__ractor__
+
     def initialize(mode, *args, **opts, &block)
-      @ractor = ::Ractor.new(name: "#{args.first}<#{args.first.object_id}>", &RACTOR_PROC)
+      @__ractor__ = RactorizedRactor.new(name: "#{args.first}<#{args.first.object_id}>", &RACTOR_PROC)
 
       case mode
       when :object
-        @ractor << :object
+        @__ractor__ << :object
 
         outside_object = args.first
 
         @__target_class__ = outside_object.class
 
         if ::Ractor.shareable?(outside_object)
-          @ractor << outside_object
+          @__ractor__ << outside_object
         else
           ::Ractorize.resolve_all_thunks(outside_object)
-          @ractor.send(outside_object, move: true)
+          @__ractor__.send(outside_object, move: true)
         end
       when :class
         klass, *args = args
@@ -28,29 +40,29 @@ module Ractorize
         to_move = ::Ractorize.prepare_args(@__target_class__, args, opts)
 
         if to_move&.any?
-          @ractor << :class_arg_by_arg
-          @ractor << klass
+          @__ractor__ << :class_arg_by_arg
+          @__ractor__ << klass
 
           args.each do |arg|
-            @ractor << :arg
-            @ractor.send(arg, move: to_move.include?(arg))
+            @__ractor__ << :arg
+            @__ractor__.send(arg, move: to_move.include?(arg))
           end
 
           opts.each_pair do |name, value|
-            @ractor << :kwarg
-            @ractor << name
-            @ractor.send(value, move: to_move.include?(value))
+            @__ractor__ << :kwarg
+            @__ractor__ << name
+            @__ractor__.send(value, move: to_move.include?(value))
           end
 
           if block
-            @ractor << :block
-            @ractor << block
+            @__ractor__ << :block
+            @__ractor__ << block
           end
 
-          @ractor << :done
+          @__ractor__ << :done
         else
-          @ractor << :class
-          @ractor << [klass, args.freeze, opts.dup.freeze, block].freeze
+          @__ractor__ << :class
+          @__ractor__ << [klass, args.freeze, opts.dup.freeze, block].freeze
         end
       else
         # :nocov:
@@ -58,30 +70,35 @@ module Ractorize
         # :nocov:
       end
 
-      ::Object.instance_method(:freeze).bind(self).call
+      @__object_id__ = ::Object.instance_method(:object_id).bind_call(self)
+
+      ::Ractorize::GarbageCollection.track_ractorized_object(self)
     end
 
     def __close__ = method_missing(:__close__)
 
     def __join__
       __close__
-      @ractor.join
+      @__ractor__.join
       self
     end
 
     def method_missing(method_name, *args, **opts, &block)
-      if @ractor.default_port.closed?
+      if @__ractor__.default_port.closed?
         ::Kernel.raise ::Ractor::ClosedError,
                        "You already closed this Ractorized instance of #{@__target_class__}!\n" \
                        "No more methods can be sent to it but you sent #{method_name}"
       end
 
-      return_port = ::Ractor::Port.new
+      return_port = ::Ractorize::RactorizedObject::RactorizedRactor::Port.new
+      thunk_ractor = if !block && RactorizedObject.method_should_use_thunk?(method_name)
+                       ::Ractorize::Thunk::ThunkRactor.new
+                     end
 
       to_move = ::Ractorize.prepare_args(@__target_class__, args, opts)
 
       if to_move&.any?
-        @ractor << [:__invoke_arg_by_arg__, [].freeze, {}.freeze, return_port, !!block]
+        @__ractor__ << [:__invoke_arg_by_arg__, [].freeze, {}.freeze, return_port, thunk_ractor, !!block]
 
         args_port = return_port.receive
         args_port << method_name
@@ -99,7 +116,7 @@ module Ractorize
 
         args_port << :done
       else
-        @ractor << [method_name, args.dup.freeze, opts.dup.freeze, return_port, !!block].freeze
+        @__ractor__ << [method_name, args.dup.freeze, opts.dup.freeze, return_port, thunk_ractor, !!block].freeze
       end
 
       if block
@@ -121,28 +138,38 @@ module Ractorize
             # TODO: yielded_block likely won't work when actually used
             # so we should probably instead just raise an exception
             # TODO: handle break and also raise in the block
-            block_result = block.call(*yielded_args.freeze, **yielded_opts.freeze, &yielded_block)
-
-            block_result = block_result.__value__ while ::Ractorize::Thunk === block_result
-
-            block_result_port << [:normal, block_result].freeze
+            begin
+              broke = true
+              block_result = block.call(*yielded_args.freeze, **yielded_opts.freeze, &yielded_block)
+              broke = false
+            ensure
+              block_result = block_result.__value__ while ::Ractorize::Thunk === block_result
+
+              block_result_port << if broke
+                                     # TODO: handle error situation
+                                     :break
+                                   else
+                                     [:normal, block_result].freeze
+                                   end
+            end
           end
         end
 
         value
       # Let's assume the user would rather block on all predicate methods than
       # incorrectly get a non-truthy value (thunk is always truthy even if it evaluates as nil/false)
-      elsif method_name == :== || method_name == :! || method_name == :!= ||
-            method_name == :inspect || method_name == :to_s || method_name.end_with?("?")
+      elsif thunk_ractor
+        return_port.close
+        Thunk.new(thunk_ractor)
+      else
         value = return_port.receive
+        return_port.close
 
         # :nocov:
         ::Kernel.raise ::Ractorize::Thunk::EscapingRactorError if ::Ractorize::Thunk === value
         # :nocov:
 
         value
-      else
-        Thunk.new(return_port)
       end
     end
 
@@ -159,11 +186,10 @@ module Ractorize
       method_missing(:respond_to?, method_name, include_all)
     end
 
-    def ==(other) = method_missing(:==, other)
-    def !=(other) = method_missing(:==, other)
+    def ==(other) = method_missing(:==, other) || super
+    def !=(other) = method_missing(:==, other) || super
     def ! = method_missing(:!)
-    def equal?(other) = method_missing(:equal?, other)
-
+    # def equal?(other) = method_missing(:equal?, other) || super
     def to_s = inspect
 
     def inspect

data/src/ractorize/thunk/thunk_ractor.rb

@@ -0,0 +1,23 @@
+require_relative "../base_ractor"
+
+module Ractorize
+  class Thunk < BasicObject
+    class ThunkRactor < ::BaseRactor
+      class << self
+        def new
+          super do
+            # SimpleCov seems to want us to handle the case where nothing matches but that would be an error
+            # :nocov:
+            case receive
+            # :nocov:
+            in :__close__
+              # do nothing
+            in :success, value
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/src/ractorize/thunk.rb

@@ -2,14 +2,18 @@ module Ractorize
   class Thunk < BasicObject
     class EscapingRactorError < ::StandardError; end
 
-    attr_accessor :__return_value_port__, :__ractor__
+    attr_accessor :__thunk_ractor__, :__object_id__
 
-    def initialize(return_value_port)
-      self.__ractor__ = ::Ractor.current
-      self.__return_value_port__ = return_value_port
+    def initialize(return_value_portlike)
+      self.__thunk_ractor__ = return_value_portlike
+      self.__object_id__ = ::Object.instance_method(:object_id).bind_call(self)
+      ::Ractorize::GarbageCollection.track_thunk(self)
     end
 
     def initialize_clone(...)
+      # :nocov:
+      raise "CAREFUL! THUNK CLONED!!"
+      # :nocov:
       # is this actually necessary?? Seems so?
     end
 
@@ -24,24 +28,11 @@ module Ractorize
     def __value__
       return @__value__ if defined?(@__value__)
 
-      value = if ::Ractor.current == __ractor__
-                __return_value_port__.receive
-              else
-                # :nocov:
-                ::Kernel.raise EscapingRactorError,
-                               "Somehow this thunk was passed between ractors but wasn't resolved first."
-                # :nocov:
-              end
-
-      # :nocov:
-      ::Kernel.raise EscapingRactorError if ::Ractorize::Thunk === value
-      # :nocov:
-
-      @__value__ = value
-
-      ::Object.instance_method(:freeze).bind(self).call
+      @__value__ = __thunk_ractor__.join.value
+      self.__thunk_ractor__ = nil
+      ::Object.instance_method(:freeze).bind_call(self)
 
-      value
+      @__value__
     end
 
     def ! = !__value__

data/src/ractorize.rb

@@ -64,6 +64,7 @@ module Ractorize
     # Not sure why that is but we need to handle that case.
     def resolve_all_thunks(structure)
       each_thunk(structure, &:__value__)
+      nil
     end
 
     def to_move(target_class, args)
@@ -147,28 +148,8 @@ module Ractorize
       to_move(target_class, args)
     end
 
-    def each_thunk(structure, seen = Set.new, &block)
-      return block.call(structure) if Thunk === structure
-      return if seen.include?(structure)
-
-      seen << structure
-
-      case structure
-      when Array
-        structure.each { each_thunk(it, seen, &block) }
-      when Hash
-        each_thunk(structure.keys, seen, &block)
-        each_thunk(structure.values, seen, &block)
-      when Struct
-        each_thunk(structure.values, seen, &block)
-      else
-        ivarsget = ::Object.instance_method(:instance_variables)
-        iget = ::Object.instance_method(:instance_variable_get)
-
-        ivarsget.bind(structure).call.each do |var|
-          each_thunk(iget.bind(structure).call(var), seen, &block)
-        end
-      end
+    def each_thunk(structure, seen = Set.new, &)
+      each_instance_of(Thunk, structure, seen, 0, &)
     end
 
     def extract_args(port_like)
@@ -200,11 +181,43 @@ module Ractorize
 
       [args, opts, block]
     end
+
+    private
+
+    def each_instance_of(klass, structure, seen = Set.new, depth = 0, &block)
+      depth += 1
+      if klass === structure
+        block.call(structure)
+      end
+      return if seen.include?(structure)
+
+      seen << structure
+
+      case structure
+      when Array
+        structure.each { each_instance_of(klass, it, seen, depth, &block) }
+      when Hash
+        each_instance_of(klass, structure.keys, seen, depth, &block)
+        each_instance_of(klass, structure.values, seen, depth, &block)
+      when Struct
+        each_instance_of(klass, structure.values, seen, depth, &block)
+      else
+        ivarsget = ::Object.instance_method(:instance_variables)
+        iget = ::Object.instance_method(:instance_variable_get)
+
+        ivarsget.bind(structure).call.each do |var|
+          value = iget.bind(structure).call(var)
+          each_instance_of(klass, value, seen, depth, &block)
+        end
+      end
+
+      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 = proc do
+  RACTOR_PROC = Ractor.shareable_proc do
     mode = receive
 
     object = case mode
@@ -230,16 +243,25 @@ module Ractorize
              end
 
     loop do
-      method_name, method_args, opts, return_port, block_given = receive
+      # 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__
-        return_port.<<(object, move: true)
+        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 = Ractor::Port.new
+          args_port = Ractorize::RactorizedObject::RactorizedRactor::Port.new
           return_port << args_port
 
           method_name = args_port.receive
@@ -247,7 +269,7 @@ module Ractorize
         end
 
         if block_given
-          block_result_port = Ractor::Port.new
+          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)
@@ -260,7 +282,8 @@ module Ractorize
             when :normal
               return_value
             when :break
-              break return_value
+              # TODO: handle error situation
+              break
             else
               # :nocov:
               raise "Not sure how to handle outcome_type #{outcome_type}"
@@ -274,7 +297,11 @@ module Ractorize
           value = value.__value__ while Ractorize::Thunk === value
 
           begin
-            return_port.send(value)
+            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.
@@ -288,9 +315,12 @@ module Ractorize
           end
         end
       end
+
+      nil
     end
 
-    object
+    nil
+    # object
   rescue => e
     # :nocov:
     puts

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ractorize
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Miles Georgi
@@ -21,9 +21,13 @@ files:
 - README.md
 - lib/ractorize.rb
 - src/ractorize.rb
+- src/ractorize/base_ractor.rb
+- src/ractorize/garbage_collection.rb
+- src/ractorize/garbage_collection/tracker.rb
 - src/ractorize/ractorized_class.rb
 - src/ractorize/ractorized_object.rb
 - src/ractorize/thunk.rb
+- src/ractorize/thunk/thunk_ractor.rb
 homepage: https://github.com/ractor-shack/ractorize
 licenses:
 - MPL-2.0