farce 0.2.0-x86_64-linux-gnu → 0.4.0-x86_64-linux-gnu

data/lib/farce/local/pool.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Local
+    # A shareable handle with an independent thread pool in each scope.
+    #
+    # Each pool uses the scaling settings and fiber scheduler configured at
+    # construction. Tasks always keep their block and argument references. Only
+    # local and smart modes are accepted when `auto_local` is false. A scheduler
+    # constructor must be convertible to a shareable proc for use in each Ractor.
+    # {#close} drains only the current scope's pool. {#close_all} drains every pool
+    # across all scopes and Ractors, and prevents new pools from starting.
+    #
+    # @example Keep task state within each Ractor
+    #   pool    = Farce::Local::Pool.new(max_size: 2)
+    #   results = Farce::Unshared::Queue.new
+    #   pool.schedule { results.push(:done) }
+    #   results.pop # => :done
+    #   pool.close_all
+    class Pool < Abstract::Pool
+      include Shareable::Unfreezable
+      include Scoped
+      include Internal::LocalExecutorMethods
+
+      # (see Farce::Abstract::Pool#initialize)
+      # @!macro scopes
+      # @param scope [Symbol] The scope of the pool. Defaults to `:ractor`.
+      def initialize(min_size: 0, max_size: 4, max_inflight: 64,
+                     grow_after: 0.005, shrink_after: 30, capacity: 1024, scope: :ractor,
+                     backend: Internal::FROZEN_CONFIG.io_backend, &constructor)
+        initialize_configuration(min_size:, max_size:, max_inflight:, grow_after:, shrink_after:, backend:)
+        @constructor = prepare_constructor(constructor || Internal::FROZEN_CONFIG.fiber_scheduler_constructor)
+        @pools       = Strict::Map.new
+        @closed_all  = Internal::Flag.new(false)
+        @initialization_key = Object.new.freeze
+        super(scope:, min_size: @min_size, max_size: @max_size, max_inflight: @max_inflight,
+              grow_after: @grow_after, shrink_after: @shrink_after, capacity:, backend:)
+      end
+
+      # Stop accepting work in this scope and drain its queued tasks.
+      # @return [self]
+      def close
+        pool = @closed_all.value ? Internal::Storage[self, scope:] : scoped_value
+        pool&.close
+        self
+      end
+
+      # Stop accepting work in every scope and Ractor and request draining.
+      # Future scopes also reject submissions. Does not wait for running tasks.
+      # @return [self]
+      def close_all
+        return self unless @closed_all.compare_and_set(false, true)
+        @pools.each_pair do |pool, queue|
+          queue.push([pool, :close].freeze, clock: 0)
+        rescue ClosedQueueError
+          # The owning Ractor may already have shut down its supervisor.
+          nil
+        end
+        close
+      end
+
+      # @return [Integer] Running and starting workers in this scope.
+      def size = current_pool&.size || 0
+
+      # @return [Symbol] The current scope's pool state.
+      def state = current_pool&.state || :closed
+
+      # @return [Exception, nil] The first worker error in this scope.
+      def error = current_pool&.error
+
+      # @return [Boolean] Whether this scope rejects new tasks.
+      def closed? = @closed_all.value || super
+
+      Internal.delegate(self, :scoped_value, :drained?, :admission_generation, :wait_for_admission,
+        :admission_changed, :task_taken, :retire_worker, :worker_stopped, :scale_if_needed)
+
+      private
+
+      def enqueue_task(non_block, ...)
+        raise PoolClosedError, "cannot schedule task on a closed pool" if @closed_all.value
+        pool = scoped_value
+        submitted = non_block ? pool.try_schedule(...) : pool.schedule(...)
+        submitted && self
+      end
+
+      def current_pool
+        @closed_all.value ? Internal::Storage[self, scope:] : scoped_value
+      end
+
+      # Worker setup can yield. Initialize once when fibers share a scope.
+      def scoped_value
+        storage = Internal::Storage.scope(scope)
+        pool    = storage[self]
+        return pool if pool
+
+        initializers = Internal::Storage.store_if_absent(@initialization_key) { Internal::Storage::ThreadSafe.new }
+        initializers.store_if_absent(storage) { Internal::LeaseInitialization.new }.fetch { super }
+      end
+
+      def new_scoped_value(**)
+        pool              = Unshared::Pool.new(**, &@constructor)
+        queue, reference  = Internal::ThreadPoolSupervisor.current.close_handle(pool)
+        @pools[reference] = queue
+        pool.close if @closed_all.value
+        pool
+      end
+    end
+  end
+end

data/lib/farce/local/scheduler.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Local
+    # A shareable handle with an independent task scheduler in each scope.
+    #
+    # {.new} leaves each scheduler unstarted. Launch it with {#launch_thread}, or
+    # install it with `Fiber.set_scheduler`. {.create} starts a worker thread in
+    # each scope when that scope is first used. The default scope is `:ractor`.
+    #
+    # Tasks retain their blocks and argument references. {#execute} runs directly
+    # in the calling fiber. A fiber scheduler
+    # constructor must be convertible to a shareable proc for use in each Ractor.
+    # {#close} closes the current scope. {#close_all} closes all scopes and prevents
+    # new schedulers from starting. {.current} returns an {Unshared::Scheduler}.
+    #
+    # @example Start one worker in each Ractor
+    #   scheduler = Farce::Local::Scheduler.create
+    #   results = Farce::Unshared::Queue.new
+    #   scheduler.schedule { results.push(:done) }
+    #   results.pop # => :done
+    #   scheduler.close_all
+    class Scheduler < Abstract::Scheduler
+      include Shareable::Unfreezable
+      include Scoped
+      include Internal::LocalExecutorMethods
+
+      # Returns the current thread's unshared scheduler, or nil when none is installed.
+      # @param (see Abstract::Scheduler.current)
+      # @return [Unshared::Scheduler, nil]
+      def self.current(**) = Unshared::Scheduler.current(**)
+
+      # Starts a worker in this scope and retains the launch settings for other scopes.
+      # Additional options and the block are forwarded to {#initialize}.
+      # @param executor [Class, nil] Thread or a custom executor that stays in each Ractor.
+      # @param name [String, nil] Optional worker name.
+      # @param priority [Integer, nil] Optional worker thread priority.
+      # @yieldreturn [Object] Fiber scheduler to install in each worker.
+      # @return [Scheduler]
+      def self.create(executor = Thread, name: nil, priority: nil, **, &)
+        raise ArgumentError, "Local schedulers cannot launch Ractor workers" if executor && executor <= Ractor
+        worker = [executor || Thread, name && -String(name), priority && Integer(priority)].freeze
+        new(**, worker:, &)
+      end
+
+      # Creates a handle whose scoped schedulers remain unstarted.
+      # The constructor block builds the fiber scheduler when a scope is launched or installed.
+      # @!macro scopes
+      # @overload initialize(capacity: 1024, backend: Farce.config.io_backend, scope: :ractor, &constructor)
+      #   @param capacity [Integer, nil] Pending-task capacity, or nil for an unbounded queue in each scope.
+      #   @param backend [Symbol] IO backend for the built-in scheduler.
+      #   @param scope [Symbol] The scheduler scope. Defaults to :ractor.
+      #   @yieldreturn [Object] Fiber scheduler to install in each scope.
+      def initialize(capacity: 1024, backend: Internal::FROZEN_CONFIG.io_backend, scope: :ractor,
+                     worker: nil, &constructor)
+        @constructor        = prepare_constructor(constructor || Internal::FROZEN_CONFIG.fiber_scheduler_constructor)
+        @backend            = backend
+        @worker             = worker
+        @schedulers         = Strict::Map.new
+        @closed_all         = Internal::Flag.new(false)
+        @initialization_key = Object.new.freeze
+        @registration_key   = Object.new.freeze
+        super(scope:, capacity: capacity && Integer(capacity), backend:)
+      end
+
+      # Enqueue a task in the current scope, preserving its block and arguments.
+      # `mode` is ignored when `auto_local` is true. Otherwise, only local and smart modes are accepted.
+      # @overload schedule(*args, mode: :smart, auto_local: true)
+      #   @param (see Farce::Abstract::Executor#schedule)
+      #   @return [self]
+      def schedule(...) = enqueue_task(false, ...)
+
+      # (see Abstract::Scheduler#try_schedule)
+      def try_schedule(...) = enqueue_task(true, ...)
+
+      # Starts a worker for the current scope. Other scopes retain their creation behavior.
+      # @param executor [Class, nil] Thread or a custom executor that stays in this Ractor.
+      # @param name [String, nil] Optional worker name.
+      # @param priority [Integer, nil] Optional worker thread priority.
+      # @return [Thread, Object] The worker.
+      # @raise [ArgumentError] If a Ractor executor is supplied.
+      def launch(executor = Thread, name: nil, priority: nil)
+        raise ArgumentError, "Local schedulers cannot launch Ractor workers" if executor && executor <= Ractor
+        raise "Scheduler may not be reused" if @closed_all.value
+        active_scoped_value.launch(executor, name:, priority:)
+      end
+
+      # Closes the current scope and rejects new submissions there.
+      # @return [self]
+      def close
+        current_scheduler&.close
+        self
+      end
+
+      # Requests shutdown in every scope and Ractor and rejects future scopes.
+      # Does not wait for queued or running tasks to finish.
+      # @return [self]
+      def close_all
+        return self unless @closed_all.compare_and_set(false, true)
+        @schedulers.each_pair do |scheduler, queue|
+          queue.push([scheduler, :close].freeze, clock: 0)
+        rescue ClosedQueueError
+          # The owning Ractor may already have shut down its supervisor.
+          nil
+        end
+        close
+      end
+
+      # @return [Symbol] The current scope's scheduler state.
+      def state = current_scheduler&.state || :closed
+
+      # @return [Exception, nil] The current scope's scheduler error.
+      def error = current_scheduler&.error
+
+      # @return [Boolean] Whether the current scope rejects new tasks.
+      def closed? = @closed_all.value || scoped_value.closed?
+
+      # @return [Boolean] Whether the current scope is dispatching tasks.
+      def alive? = current_scheduler&.alive? || false
+
+      # @return [Ractor] The current scope's owning Ractor.
+      def owner = Ractor.current
+
+      # @param value [Ractor] The current Ractor.
+      # @raise [ArgumentError] If another owner is supplied.
+      def owner=(value)
+        raise ArgumentError, "owner must be the current Ractor" unless value == Ractor.current
+      end
+
+      # @return [Boolean] Whether a fiber scheduler constructor was supplied.
+      def wraps_external? = !@constructor.nil?
+
+      # @return [Object, nil] The fiber scheduler in the current scope, when supplied by a constructor.
+      def external_scheduler = current_scheduler&.external_scheduler
+
+      # @api private
+      def inspect_with(inspector)
+        inspector.object_group(self) do
+          inspector.attribute(:scope, scope)
+          inspector.attribute(:state, state)
+          inspector.attribute(:backend, @backend)
+          yield if block_given?
+        end
+      end
+
+      private
+
+      def enqueue_task(non_block, *, mode: :smart, auto_local: true, &block)
+        raise SchedulerClosedError, "cannot schedule task on a closed scheduler" if @closed_all.value
+        scheduler = scoped_value
+        raise SchedulerClosedError, "cannot schedule task on a closed scheduler" if scheduler.closed?
+        raise LocalJumpError, "Cannot schedule without a block" unless block
+
+        validate_local_mode(mode, auto_local)
+        register_scheduler(scheduler)
+
+        submitted =
+          if non_block
+            scheduler.try_schedule(*, mode:, auto_local:, &block)
+          else
+            scheduler.schedule(*, mode:, auto_local:, &block)
+          end
+
+        submitted && self
+      end
+
+      def current_scheduler
+        return scoped_value unless @closed_all.value
+        scheduler = Internal::Storage[self, scope:]
+        scheduler&.close
+        scheduler
+      end
+
+      # Worker setup can yield. Initialize once when fibers share a scope.
+      def scoped_value
+        storage = Internal::Storage.scope(scope)
+        scheduler = storage[self]
+        return scheduler if scheduler
+
+        initializers = Internal::Storage.store_if_absent(@initialization_key) { Internal::Storage::ThreadSafe.new }
+        initializers.store_if_absent(storage) { Internal::LeaseInitialization.new }.fetch { super }
+      end
+
+      def active_scoped_value
+        scheduler = scoped_value
+        register_scheduler(scheduler)
+        scheduler
+      end
+
+      def register_scheduler(scheduler)
+        registrations = Internal::Storage.store_if_absent(@registration_key) { Internal::Storage::ThreadSafe.new }
+        registrations.store_if_absent(scheduler) do
+          queue, reference = Internal::ThreadPoolSupervisor.current.close_handle(scheduler)
+          @schedulers[reference] = queue
+          true
+        end
+        scheduler.close if @closed_all.value
+      end
+
+      def new_scoped_value(**)
+        scheduler = Unshared::Scheduler.new(**, &@constructor)
+        if @worker && !@closed_all.value
+          register_scheduler(scheduler)
+          executor, name, priority = @worker
+          scheduler.launch(executor, name:, priority:) unless @closed_all.value
+        end
+        scheduler.close if @closed_all.value
+        scheduler
+      end
+
+      def set_scheduler!(...)
+        raise "Scheduler may not be reused" if @closed_all.value
+        active_scoped_value.set_scheduler!(...)
+      end
+    end
+  end
+end

data/lib/farce/null_port.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # Special, write-only port that discards all messages.
+  # If the Ruby environment supports ports, this will be a real Port object.
+  # It can therefore be passed to any API expecting a `Ractor::Port`, including C code.
+  # Cannot be read from, but does not accumulate messages in memory.
+  # @return [Ractor::Port] Write-only port
+  NULL_PORT = Internal::NullPort.new
+end

data/lib/farce/pool.rb

@@ -36,297 +36,9 @@ module Farce
   #
   #   # Schedule some work
   #   pool.schedule { MyClass.do_something }
-  class Pool < Farce::Abstract::Scheduler
-    include Internal::MarshalSupport::Reject
+  class Pool < Farce::Abstract::Pool
     include Shareable::Unfreezable
-    include Internal::Inspect
 
-    # @return [Float] Maximum queue wait before adding a worker.
-    attr_reader :grow_after
-
-    # @return [Integer, nil] Soft task limit for each worker.
-    attr_reader :max_inflight
-
-    # @return [Integer] Maximum worker count.
-    attr_reader :max_size
-
-    # @return [Integer] Minimum worker count.
-    attr_reader :min_size
-
-    # @return [Float, nil] Idle time before an extra worker retires.
-    attr_reader :shrink_after
-
-    # Create and start an elastic pool using the configured fiber scheduler.
-    # An explicit constructor block overrides the configured default.
-    #
-    # `max_inflight` is a soft limit. A worker may exceed it when its scheduler
-    # has no runnable fibers or when the pool has reached `max_size`.
-    #
-    # @param min_size [Integer] Workers started immediately and retained while open.
-    # @param max_size [Integer] Maximum workers allowed.
-    # @param max_inflight [Integer, nil] Soft task limit for each worker.
-    # @param grow_after [Numeric] Queue wait before adding another worker.
-    # @param shrink_after [Numeric, nil] Idle time before an extra worker retires.
-    # @param capacity [Integer, nil] Pending-task capacity.
-    # @param backend [Symbol] IO backend for the built-in scheduler.
-    # @yieldreturn [Object] Fiber scheduler constructed in each worker.
-    def initialize(min_size: 0, max_size: 4, max_inflight: 64,
-                   grow_after: 0.005, shrink_after: 30, capacity: 1024,
-                   backend: Internal::FROZEN_CONFIG.io_backend, &constructor)
-      constructor ||= Internal::FROZEN_CONFIG.fiber_scheduler_constructor
-      @min_size     = Integer(min_size)
-      @max_size     = Integer(max_size)
-      @max_inflight = max_inflight && Integer(max_inflight)
-      @grow_after   = duration(grow_after, :grow_after)
-      @shrink_after = duration(shrink_after, :shrink_after, nil_allowed: true)
-      validate_sizes
-
-      @backend      = backend
-      @constructor  = constructor
-      @constructor  = Ractor.shareable_proc(&constructor) if constructor && !Ractor.shareable?(constructor)
-      @queue        = Internal::Queue.new(capacity: capacity && Integer(capacity), track_age: true)
-      @state        = Internal::Atom.new(:running)
-      @error        = Internal::Atom.new
-      @worker_count = Internal::Atom.new(0)
-      @pressure     = Internal::Atom.new
-      @admission    = Internal::Signal.new
-      super()
-      begin
-        @min_size.times { start_worker }
-      rescue Exception # rubocop:disable Lint/RescueException
-        close
-        raise
-      end
-    end
-
-    # Enqueue a task for any worker in the pool.
-    #
-    # Pools have no single owner, so `auto_local` does not select local transfer.
-    # Explicit local transfer is rejected because another Ractor may run the task.
-    #
-    # @!macro modes
-    # @param args [Array<Object>] Positional arguments passed to the task block.
-    # @param mode [Symbol] Argument transfer mode.
-    # @param auto_local [Boolean] Accepted for compatibility with {Scheduler#schedule}.
-    # @yield [*args] Task to execute.
-    # @return [Pool] self.
-    # @raise [PoolClosedError] If the pool is closing or closed.
-    def schedule(*args, mode: :smart, auto_local: true, &block) # rubocop:disable Lint/UnusedMethodArgument
-      raise PoolClosedError, "cannot schedule task on a closed pool" if closed?
-      raise ArgumentError, "local transfer is not supported by a pool" if mode == :local
-
-      task = Internal::ScheduledTask.new(args, block, mode)
-      @queue.push(task)
-      arm_scaler
-      self
-    rescue ClosedQueueError
-      raise unless closed?
-      raise PoolClosedError, "cannot schedule task on a closed pool"
-    end
-
-    # Stop accepting tasks and drain queued work.
-    #
-    # @return [Pool] self.
-    def close
-      return self if closed?
-      @state.compare_and_set(:running, :closing)
-      @queue.seal
-      admission_changed
-      if size.zero?
-        @queue.closed? ? finish_close : start_worker(drain: true)
-      end
-      self
-    end
-
-    # Return the first worker error, if any.
-    def error
-      value = @error.value
-      value.is_a?(Envelope) ? value.value : value
-    end
-
-    # Return the current number of running and starting workers.
-    def size = @worker_count.value
-
-    # Return the current pool state.
-    def state = @state.value
-
-    # Return whether the pool rejects new tasks.
-    def closed? = state != :running
-
-    # Return whether the pool is draining queued work.
-    def closing? = state == :closing
-
-    # Return whether closing workers have drained all admitted submissions.
-    # @api private
-    def drained? = closing? && @queue.closed?
-
-    # Return whether all configured workers have been started.
-    def at_max_size? = size >= @max_size
-
-    # Return the generation used by workers waiting for admission.
-    # @api private
-    def admission_generation = @admission.generation
-
-    # Wait for worker capacity or a pool state change.
-    # @api private
-    def wait_for_admission(generation) = @admission.wait(generation)
-
-    # Wake workers waiting at their soft admission limit.
-    # @api private
-    def admission_changed = @admission.broadcast
-
-    # Record that a task left the shared queue.
-    # @api private
-    def task_taken
-      return if @pressure.value.nil? || at_max_size?
-      return unless queue_empty?
-      @pressure.value = nil
-      arm_scaler if @queue.size.positive?
-    end
-
-    # Reserve a worker retirement above the minimum size.
-    # @api private
-    def retire_worker
-      retired = false
-      @worker_count.update do |count|
-        if state == :running && count > @min_size && queue_empty?
-          retired = true
-          count - 1
-        else
-          count
-        end
-      end
-      retired
-    end
-
-    # Remove a stopped worker and preserve its failure.
-    # @api private
-    def worker_stopped(error, replace: true)
-      @worker_count.update { |count| count - 1 }
-      @error.compare_and_set(nil, Envelope.new(error)) if error
-      if closing?
-        if size.zero?
-          error && !drained? ? start_worker(drain: true) : finish_close
-        end
-      elsif state == :running && replace
-        begin
-          start_worker while size < @min_size
-        rescue Exception # rubocop:disable Lint/RescueException
-          nil
-        end
-        arm_scaler if @queue.size.positive?
-      end
-      admission_changed
-    end
-
-    # Recheck delayed queue pressure and grow by one worker.
-    # @api private
-    def scale_if_needed(started)
-      return unless state == :running && @pressure.value == started
-      age = @queue.oldest_age
-      return clear_pressure(started) unless age
-      return reschedule_scaler(started, @grow_after - age) if age < @grow_after
-
-      start_worker unless at_max_size?
-      return clear_pressure(started) if queue_empty? || at_max_size?
-
-      next_started = @queue.generation
-      schedule_scaler(next_started) if @pressure.compare_and_set(started, next_started)
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      @error.compare_and_set(nil, Envelope.new(e))
-    end
-
-    # @api private
-    def inspect_with(inspector)
-      super do
-        inspector.attribute(:state,        state)
-        inspector.attribute(:backend,      @backend)
-        inspector.attribute(:size,         size)
-        inspector.attribute(:min_size,     @min_size)
-        inspector.attribute(:max_size,     @max_size)
-        inspector.attribute(:max_inflight, @max_inflight) if @max_inflight
-        yield if block_given?
-      end
-    end
-
-    private
-
-    def validate_sizes
-      raise ArgumentError, "min_size must be non-negative" if @min_size.negative?
-      raise ArgumentError, "max_size must be positive" unless @max_size.positive?
-      raise ArgumentError, "min_size must not exceed max_size" if @min_size > @max_size
-      raise ArgumentError, "max_inflight must be positive" if @max_inflight && !@max_inflight.positive?
-    end
-
-    def duration(value, name, nil_allowed: false)
-      return if value.nil? && nil_allowed
-      value = Float(value)
-      raise ArgumentError, "#{name} must be finite and non-negative" if !value.finite? || value.negative?
-      value
-    end
-
-    def start_worker(drain: false, only_if_empty: false)
-      reserved = false
-      @worker_count.update do |count|
-        can_start = state == :running || (drain && closing? && !queue_empty?)
-        if can_start && count < @max_size && (!only_if_empty || count.zero?)
-          reserved = true
-          count + 1
-        else
-          count
-        end
-      end
-      return false unless reserved
-
-      worker = Internal::PoolWorker.new(self)
-      scheduler = Scheduler.new(
-        backend:     @backend,
-        queue:       @queue,
-        pool_worker: worker,
-        queue_owner: false,
-        &@constructor
-      )
-      scheduler.launch_ractor
-      admission_changed if at_max_size?
-      true
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      worker ? worker.stopped(e, replace: false) : @worker_count.update { |count| count - 1 }
-      raise
-    end
-
-    def arm_scaler
-      return if at_max_size? || queue_empty? || state != :running
-      start_worker(only_if_empty: true) if size.zero?
-      return if at_max_size?
-
-      started = @queue.generation
-      age     = @queue.oldest_age
-
-      return unless age
-      return unless @pressure.compare_and_set(nil, started)
-
-      remaining = @grow_after - age
-      remaining = 0 if remaining.negative?
-
-      schedule_scaler(started, remaining)
-    end
-
-    def schedule_scaler(started, delay = @grow_after)
-      Internal::PoolSupervisor.schedule(self, started, delay)
-    end
-
-    def reschedule_scaler(started, delay)
-      next_started = @queue.generation
-      schedule_scaler(next_started, delay) if @pressure.compare_and_set(started, next_started)
-    end
-
-    def clear_pressure(started)
-      return unless @pressure.compare_and_set(started, nil)
-      arm_scaler if @queue.size.positive?
-    end
-
-    def queue_empty? = @queue.size.zero? # rubocop:disable Style/ZeroLengthPredicate
-
-    def finish_close = @state.compare_and_set(:closing, :closed)
+    private def publish_pool = publish_shareable
   end
 end

data/lib/farce/proxy.rb

@@ -216,7 +216,7 @@ module Farce
       new(object, register:, scheduler:)
     end
 
-    def self.owner_scheduler = ::Farce::ThreadScheduler.new { |*args, &block| ::Farce::Ractor.new(*args, &block) }
+    def self.owner_scheduler = ::Farce::ThreadExecutor.new { |*args, &block| ::Farce::Ractor.new(*args, &block) }
     private_class_method :owner_scheduler
 
     def self.schedule_initializer(scheduler, *)
@@ -254,7 +254,7 @@ module Farce
 
     # @param object [BasicObject] the object to be managed by the proxy
     # @param register [Farce::Proxy::Register, nil] the register to use
-    # @param scheduler [Farce::Abstract::Scheduler, nil] the scheduler to use
+    # @param scheduler [Farce::Abstract::Executor, nil] the scheduler to use
     def initialize(object, register: nil, scheduler: nil)
       @token        = ::Object.new.freeze # cross-ractor finalizers don't work reliably across Ruby versions
       @supervisor   = Supervisor.new(register || REGISTER, scheduler || ::Farce, ::Farce::WeakValue.new(@token))