farce 0.2.0 → 0.3.0

data/lib/farce/task.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # A unit of work that executes once and retains its result or failure.
+  #
+  # ```ruby
+  # # You can create and schedule a task with one call:
+  # task = Farce::Task.schedule { 1 + 2 }
+  # task.value # => 3
+  #
+  # # There is also a shorthand for running a task on the global Ractor pool:
+  # task = Farce::Task.in_parallel { sleep 1 }
+  # task.join
+  # task.alive? # => false
+  #
+  # # schedule accepts a custom scheduler:
+  # scheduler = Farce::Scheduler.create
+  # task      = Farce::Task.schedule(scheduler:) { 1 + 2 }
+  #
+  # # or alternatively you can manually create a task and hand it to the scheduler
+  # task = Farce::Task.new { 1 + 2 }
+  # scheduler.schedule(&task)
+  #
+  # # or execute it manually
+  # task = Farce::Task.new { Ractor.current.name.upcase }
+  # Ractor.new(task, name: "Herbert") { it.call }
+  # task.value # => "HERBERT"
+  # ```
+  class Task
+    include Abstract::Value
+    include Internal::Freeze::Delegated
+    include Internal::MarshalSupport::Reject
+
+    # Raised when an operation is attempted on a task that is in an incorrect state.
+    InvalidStateError = Class.new(RuntimeError)
+
+    # @!macro [new] task_schedule
+    #   @!macro modes
+    #   @param args [Array] the arguments to pass to the task
+    #   @param mode [Symbol] the mode for arguments and the successful result
+    #     Arguments can be overridden by {#add_argument}.
+    #   @yield [*args] the block to execute with the given arguments
+    #   @yieldparam args [Array] the arguments passed to the block
+    #   @yieldreturn [Object] the result of the block execution, will become the task's {#value}
+    #   @raise ArgumentError if the provided mode is invalid
+    #   @raise LocalJumpError if no callback is provided
+
+    # @overload in_parallel(*args, mode: :smart)
+    #   Creates a task and schedules it for execution on the {Farce.in_parallel globally shared executor pool}.
+    #   @!macro task_schedule
+    #   @return [Task] the created task
+    def self.in_parallel(*, **, &) = enqueue(false, Farce.in_parallel, *, auto_local: false, **, &)
+
+    # @overload on_main(*args, mode: :smart, auto_local: true)
+    #   Creates a task and schedules it for execution on the {Farce.on_main main scheduler}.
+    #   If `auto_local` is true (default), `mode` will be set to `:local` if the method is called from the main Ractor.
+    #
+    #   @!macro task_schedule
+    #   @param auto_local [Boolean] whether to automatically switch to local mode if called from the main Ractor
+    #   @return [Task] the created task
+    def self.on_main(*, **, &) = enqueue(false, Farce.on_main, *, **, &)
+
+    # @overload schedule(*args, mode: :smart, auto_local: true, scheduler: nil, &)
+    #   Creates a task and schedules it for execution.
+    #   A scheduler may optionally be provided.
+    #
+    #   If no scheduler is provided, then it will look for a Ractor-local scheduler if mode is `:local` or `auto_local`
+    #   is true. If none is found, one will be created automatically if `:mode` is `:local`, otherwise the
+    #   {Farce.in_parallel globally shared executor pool} will be used.
+    #
+    #   The scheduler may be a {Abstract::Executor executor}, or a Fiber scheduler.
+    #
+    #   @!macro task_schedule
+    #   @param scheduler [Abstract::Executor, Fiber::Scheduler, nil] the scheduler to use for execution
+    #   @return [Task] the created task
+    def self.schedule(*, scheduler: nil, **, &) = enqueue(false, scheduler, *, **, &)
+
+    # @overload try_schedule(*args, mode: :smart, auto_local: true, scheduler: nil, &)
+    #   Creates a task and attempts to schedule it for execution.
+    #
+    #   Behaves exactly like {.schedule}, except it uses {Abstract::Executor#try_schedule} instead of
+    #   {Abstract::Executor#schedule} if the scheduler is an executor, and that it returns `nil` if it fails to
+    #   schedule the task.
+    #
+    #   @!macro task_schedule
+    #   @return [Task, nil] the created task, or `nil` if it failed to schedule
+    def self.try_schedule(*, scheduler: nil, **, &) = enqueue(true, scheduler, *, **, &)
+
+    # @api private
+    def self.enqueue(non_block, scheduler, *, mode: :smart, auto_local: true, &) # :nodoc:
+      unless scheduler
+        scheduler = Internal.local_scheduler(create: mode == :local) if auto_local || mode == :local
+        unless scheduler
+          scheduler  = Internal::ParallelScheduler
+          auto_local = false
+        end
+      end
+
+      if scheduler.is_a?(Abstract::Executor)
+        mode = :local if auto_local && scheduler.local?(wait: false)
+        task = new(*, mode:, &)
+
+        if non_block
+          return unless scheduler.try_schedule(mode:, auto_local: false, &task)
+        else
+          scheduler.schedule(mode:, auto_local: false, &task)
+        end
+      else
+        task = new(*, mode: :local, &)
+        scheduler.fiber(&task)
+      end
+
+      task
+    end
+    private_class_method :enqueue
+
+    # @return [Symbol] the default mode used for task arguments and the return value
+    attr_reader :mode
+
+    # Creates a new task with the given arguments and callback.
+    #
+    # This does not schedule the task for execution, nor does it associate it with any executor.
+    #
+    # In fact, the task object itself is a proc-like object, that can be {call called} like a regular proc,
+    # but will track its execution state and result.
+    #
+    # @example Using a Task without an Executor
+    #   task = Farce::Task.new(1, 2) { |a, b| a + b }
+    #
+    #   task.alive?       # => true
+    #   task.call == task # => true
+    #   task.alive?       # => false
+    #   task.value        # => 3
+    #
+    # @example Passing a task to an executor
+    #   task = Farce::Task.new { puts "Hello, world!" }
+    #   Farce.in_parallel(&task)
+    #   task.join # waits for the task to complete
+    #
+    # @!macro task_schedule
+    def initialize(*args, mode: :smart, &callback)
+      raise ArgumentError, "invalid mode: #{mode}" unless MODES.include?(mode)
+      raise LocalJumpError, "no callback provided" unless block_given?
+
+      @mode   = mode
+      @ractor = Strict::Atom.new
+      @state  = Strict::Atom.new(:initialized)
+
+      if mode == :local
+        @arguments    = args
+        @callback     = callback
+        @manager      = nil
+        @ractor.value = Ractor.current
+        @result       = Unshared::Atom.new
+      else
+        @arguments = Strict::Vector.new
+        @callback  = Ractor.shareable?(callback) ? callback : Ractor.shareable_proc(&callback)
+        @manager   = ModeManager.new(mode: mode)
+        @result    = Strict::Atom.new
+        args.each { add_argument(it) }
+      end
+
+      __freeze__
+    end
+
+    # Adds an argument to the task.
+    # Can only be called before the task is frozen and before {#call} is invoked.
+    #
+    # Allows for arguments to use different modes than the return value (or other arguments).
+    # Mode is ignored for {#local? local} tasks.
+    #
+    # For non-local tasks, `mode` may only be set to `:local` for arguments added by the Ractor that will
+    # {#call execute} the task.
+    #
+    # @example A task using `move` for the return value, but `copy` for its argument
+    #   task = Farce::Task.new(mode: :move) { |arg| arg.upcase }
+    #   task.add_argument("hello", mode: :copy)
+    #   Farce.in_parallel(&task)
+    #   task.value # => "HELLO"
+    #
+    # @param argument [BasicObject] the argument to add to the task
+    # @param mode [Symbol, nil] the mode to use for the argument, or `nil` to use the task's default mode
+    # @raise ArgumentError if the provided mode is invalid
+    # @raise FrozenError if the task has already been frozen or called
+    # @raise InvalidStateError if trying to add a local argument from more than one ractor
+    # @return [self] the task itself, for chaining
+    def add_argument(argument, mode: nil)
+      check_frozen!
+
+      unless local?
+        raise ArgumentError, "invalid mode: #{mode}" unless mode.nil? || MODES.include?(mode)
+        raise InvalidStateError, "cannot add local argument to a non-local task" if mode == :local && !claim_for_ractor?
+        argument = @manager.wrap(argument, mode:)
+      end
+
+      @arguments << argument
+      self
+    end
+
+    alias << add_argument
+
+    # @return [Boolean] whether the task is currently alive (initialized or running)
+    def alive? = alive_state?(@state.value)
+
+    # Executes the task by invoking its callback with the added arguments.
+    # @raise InvalidStateError if the task has already been claimed by another ractor or has already been called
+    # @return [self] the task itself, for chaining
+    def call
+      raise InvalidStateError, "task already claimed by another ractor" unless claim_for_ractor?
+      raise InvalidStateError, "call may only be called once" unless @state.compare_and_set(:initialized, :running)
+      begin
+        arguments     = local? ? @arguments.freeze : @arguments.freeze.to_a.map! { @manager.unwrap(it) }
+        result        = @callback.call(*arguments)
+        @result.value = local? ? result : @manager.wrap(result)
+        @state.value  = :finished
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        # Every callback failure must release waiters, including ScriptError and SystemExit.
+        begin
+          @result.value = e
+        rescue Ractor::Error
+          @result.value = [RuntimeError, -"#{e.class}: #{e.message}", Ractor.make_shareable(e.backtrace)].freeze
+        end
+        @state.value = :error
+      ensure
+        if @state.value == :running
+          @result.value = [RuntimeError, -"task execution aborted"].freeze
+          @state.value  = :error
+        end
+      end
+
+      self
+    end
+
+    # Waits for the task to finish, with an optional timeout.
+    # @param timeout [Numeric, nil] the maximum time to wait, or `nil` to wait indefinitely
+    # @return [self, nil] the task itself if it finished within the timeout, or `nil` otherwise
+    def join(timeout = nil)
+      return unless @state.wait_while(timeout:) { alive_state?(it) }
+      self
+    end
+
+    # @return [Boolean] whether the task is local (i.e., its mode is `:local`)
+    def local? = @mode == :local
+
+    # Waits for the task to finish and returns its value, with an optional timeout.
+    # If the task raises an error, it will be propagated.
+    #
+    # @param timeout [Numeric, nil] the maximum time to wait, or `nil` to wait indefinitely
+    # @return [BasicObject, nil]
+    #   the value returned by the task's callback, or `nil` if the task did not finish within the timeout
+    # @raise Exception if the task raises an error
+    # @raise RuntimeError with the original class, message, and backtrace if the exception cannot be shared
+    # @raise RuntimeError if execution is aborted before producing a result or exception
+    def value(timeout = nil)
+      case @state.wait_while(timeout:) { alive_state?(it) }
+      when :finished then local? ? @result.value : @manager.unwrap(@result.value)
+      when :error    then raise(*@result.value)
+      end
+    end
+
+    # Converts the task to a Proc object.
+    # If the task is Ractor-shareable, then so is the returned Proc.
+    # @return [Proc] a Proc that calls the task's `call` method
+    def to_proc
+      return method(:call).to_proc if local?
+      task = self
+      Ractor.make_shareable(-> { task.call })
+    end
+
+    private
+
+    def alive_state?(state) = state == :initialized || state == :running
+
+    def claim_for_ractor?
+      current_ractor = Ractor.current
+      @ractor.compare_and_set(nil, current_ractor)
+      @ractor.value == current_ractor
+    end
+
+    define_method(:__freeze__, Kernel.instance_method(:freeze))
+    def freeze_backend = @arguments
+  end
+end

data/lib/farce/{thread_scheduler.rb → thread_executor.rb}

@@ -3,11 +3,11 @@
 # warn_indent: true
 
 module Farce
-  # A scheduler that starts a new thread for each scheduled task. Executes synchronous tasks inline.
+  # A task executor that starts a new thread for each scheduled task. Executes synchronous tasks inline.
   # Creating an instance starts no threads. Blocks and arguments stay local to the caller.
-  # Tasks are not tracked, and closing this stateless scheduler has no effect.
+  # Tasks are not tracked, and closing this stateless executor has no effect.
   # Default instances support Marshal. Instances with a custom thread factory reject dumping.
-  class ThreadScheduler < Farce::Abstract::Scheduler
+  class ThreadExecutor < Farce::Abstract::Executor
     include Shareable::Immutable
     include Internal::Inspect
 
@@ -18,7 +18,7 @@ module Farce
 
     # @api private
     def marshal_dump
-      raise TypeError, "scheduler factories cannot be marshaled" if @factory
+      raise TypeError, "thread factories cannot be marshaled" if @factory
       [1]
     end
 
@@ -32,7 +32,7 @@ module Farce
     #
     # @overload schedule(*args, **options)
     #   @param args [Array<Object>] Arguments passed to the block.
-    #   @param options [Hash] Scheduler options are ignored. All tasks use local arguments.
+    #   @param options [Hash] Execution options are ignored. All tasks use local arguments.
     #   @yield [*args] The task to run.
     #   @return [self]
     def schedule(*, **, &)
@@ -45,7 +45,7 @@ module Farce
     #
     # @overload execute(*args, **options)
     #   @param args [Array<Object>] Arguments passed to the block.
-    #   @param options [Hash] Scheduler options are ignored. All tasks use local arguments.
+    #   @param options [Hash] Execution options are ignored. All tasks use local arguments.
     #   @yield [*args] The task to run.
     #   @return [self]
     def execute(*, **)
@@ -57,7 +57,7 @@ module Farce
     # @return [self] Does not wait for or stop task threads.
     def close = self
 
-    # @return [false] This stateless scheduler is always available.
+    # @return [false] This stateless executor is always available.
     def closed? = false
 
     # @return [Symbol] Always `:running`.

data/lib/farce/unshared/pool.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Unshared
+    # An elastic pool of thread workers within one Ractor.
+    #
+    # Uses the same scaling and fiber schedulers as {Farce::Pool}. Tasks keep their
+    # blocks and argument references. `auto_local: true` ignores `mode`. With
+    # `auto_local: false`, only `:local` and smart modes are accepted.
+    # The pool cannot be copied or moved to another Ractor.
+    # A scheduler constructor may capture objects from this Ractor.
+    #
+    # @example Submit work using local state
+    #   results = Farce::Unshared::Queue.new
+    #   pool    = Farce::Unshared::Pool.new(max_size: 2)
+    #   pool.schedule { results.push(:done) }
+    #   results.pop # => :done
+    #   pool.close
+    class Pool < Abstract::Pool
+      include Unshareable
+      include Internal::LocalExecutorMethods
+
+      private
+
+      def publish_pool                     = pin_unshareable
+      def prepare_constructor(constructor) = constructor
+      def new_queue(capacity:)             = Internal::UnsharedQueue.new(capacity:, track_age: true)
+      def new_worker                       = Internal::UnsharedPoolWorker.new(self)
+      def new_scheduler(**, &)             = Scheduler.new(**, &)
+      def launch_scheduler(scheduler)      = scheduler.launch_thread
+
+      def prepare_task(args, block, mode, auto_local)
+        validate_local_mode(mode, auto_local)
+        Internal::LocalScheduledTask.new(args, block)
+      end
+
+      def schedule_scaler(started, delay = @grow_after)
+        Internal::ThreadPoolSupervisor.current.schedule(self, started, delay)
+      end
+    end
+  end
+end

data/lib/farce/unshared/scheduler.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Unshared
+    # A task scheduler that runs work within its creating Ractor.
+    #
+    # Use {.create} to start a background thread, or install an instance with
+    # `Fiber.set_scheduler` on the current thread. Tasks retain their blocks and
+    # argument references. The scheduler cannot be copied or moved to another Ractor.
+    #
+    # `auto_local: true` ignores `mode`. With `auto_local: false`, only `:local`
+    # and smart modes are accepted. All accepted modes keep tasks local.
+    #
+    # @example Run tasks with captured local state
+    #   results   = Farce::Unshared::Queue.new
+    #   scheduler = Farce::Unshared::Scheduler.create
+    #   scheduler.schedule { results.push(:done) }
+    #   results.pop # => :done
+    #   scheduler.close
+    #
+    # @!method schedule(*args, mode: :smart, auto_local: true)
+    #   Enqueue a task while retaining its block and argument references.
+    #   `mode` is ignored when `auto_local` is true. Otherwise, only local and
+    #   smart modes are accepted.
+    #   @param (see Farce::Abstract::Executor#schedule)
+    #   @return [self]
+    class Scheduler < Abstract::Scheduler
+      include Unshareable
+      include Internal::LocalExecutorMethods
+
+      # Start a worker thread in this Ractor. Returns the running scheduler.
+      # Additional options and the block are forwarded to {#initialize}.
+      # @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.
+      # @yieldreturn [Object] Fiber scheduler to install in the worker.
+      # @return [Scheduler]
+      def self.create(executor = Thread, name: nil, priority: nil, **, &) = super
+
+      # Create a scheduler without starting a worker.
+      # A constructor block builds the fiber scheduler when launched or installed.
+      # It may capture objects from this Ractor.
+      #
+      # @overload initialize(capacity: 1024, backend: Farce.config.io_backend, &constructor)
+      #   @param capacity [Integer, nil] Pending-task capacity, or nil for an unbounded queue.
+      #   @param backend [Symbol] IO backend for the built-in scheduler.
+      #   @yieldreturn [Object] Fiber scheduler to install in the worker.
+      def initialize(...)
+        super
+        self.owner = Ractor.current
+      end
+
+      # Start dispatching tasks in a new thread or a custom executor in this Ractor.
+      # Rejects Ractor executors before changing the scheduler's state.
+      # @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, "Unshared schedulers cannot launch Ractor workers" if executor && executor <= Ractor
+        super(executor || Thread, name:, priority:)
+      end
+
+      # @raise [ArgumentError] Unshared schedulers cannot launch Ractor workers.
+      def launch_ractor(...) = launch(Ractor, ...)
+
+      # @param value [Ractor] The creating Ractor.
+      # @raise [ArgumentError] If another Ractor is supplied or the assigned owner changes.
+      def owner=(value)
+        raise ArgumentError, "owner must be the current Ractor" unless value == Ractor.current
+        super
+      end
+
+      private
+
+      def prepare_constructor(constructor) = constructor
+      def new_queue(capacity:)             = Internal::UnsharedQueue.new(capacity:)
+      def launch_callback                  = ->(_scheduler, priority, name) { launch!(name, priority) }
+
+      def prepare_task(args, block, mode, auto_local)
+        validate_local_mode(mode, auto_local)
+        Internal::LocalScheduledTask.new(args, block)
+      end
+    end
+  end
+end

data/lib/farce/version.rb

@@ -4,5 +4,5 @@
 
 module Farce
   # @return [String] the current version of Farce
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/farce.rb

@@ -360,7 +360,7 @@ module Farce
   # This allows scheduling without blocking the current thread.
   #
   # On JRuby and TruffleRuby, blocks run inline because there is no native Ractor isolation.
-  # The returned {ThreadScheduler} starts a new thread for each scheduled task.
+  # The returned {ThreadExecutor} starts a new thread for each scheduled task.
   #
   # @example
   #   $results = []
@@ -408,9 +408,9 @@ module Farce
   #
   # @overload on_main
   #   Returns a scheduler that executes tasks on the main ractor.
-  #   @return [Abstract::Scheduler]
+  #   @return [Abstract::Executor]
   #
-  # @return [Abstract::Scheduler, nil]
+  # @return [Abstract::Executor, nil]
   # @see .in_parallel
   def self.on_main(*args, mode: UNDEFINED, &)
     unless block_given?
@@ -448,9 +448,9 @@ module Farce
   #   @return [nil]
   #
   # @overload in_parallel
-  #   @return [Abstract::Scheduler] The shared scheduler.
+  #   @return [Abstract::Executor] The shared scheduler.
   #
-  # @return [Abstract::Scheduler, nil]
+  # @return [Abstract::Executor, nil]
   # @see .on_main
   def self.in_parallel(*args, mode: UNDEFINED, &)
     unless block_given?
@@ -493,22 +493,14 @@ module Farce
     raise LocalJumpError, "no block given" unless block_given?
 
     if auto_local || mode == :local
-      if Fiber.respond_to?(:scheduler) && fiber_scheduler = Fiber.scheduler
-        fiber_scheduler.fiber(**) { yield(*) }
+      scheduler = Internal.local_scheduler(create: mode == :local)
+      if scheduler && !scheduler.is_a?(Abstract::Executor)
+        scheduler.fiber(**) { yield(*) }
         return
       end
-      scheduler = Ractor.main? ? Internal::MainScheduler : Internal::Storage[:local_scheduler]
     end
 
-    scheduler ||=
-      if mode == :local
-        Internal::Storage.store_if_absent(:local_scheduler) do
-          Internal.native_ractors? ? Scheduler.create(Thread) : ThreadScheduler.new
-        end
-      else
-        Internal::ParallelScheduler
-      end
-
+    scheduler ||= Internal::ParallelScheduler
     scheduler.schedule(*, mode:, auto_local:, **, &)
     nil
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: farce
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Konstantin Haase
@@ -85,6 +85,7 @@ files:
 - lib/farce/abstract/counter.rb
 - lib/farce/abstract/duplicable_map.rb
 - lib/farce/abstract/exchanger.rb
+- lib/farce/abstract/executor.rb
 - lib/farce/abstract/flag.rb
 - lib/farce/abstract/lazy.rb
 - lib/farce/abstract/lease.rb
@@ -94,6 +95,7 @@ files:
 - lib/farce/abstract/lru_map.rb
 - lib/farce/abstract/map.rb
 - lib/farce/abstract/molecule.rb
+- lib/farce/abstract/pool.rb
 - lib/farce/abstract/port.rb
 - lib/farce/abstract/priority_queue.rb
 - lib/farce/abstract/queue.rb
@@ -262,6 +264,8 @@ files:
 - lib/farce/internal/lease_pool_state.rb
 - lib/farce/internal/lease_state.rb
 - lib/farce/internal/lease_waiting.rb
+- lib/farce/internal/local_executor_methods.rb
+- lib/farce/internal/local_scheduled_task.rb
 - lib/farce/internal/managed_queue.rb
 - lib/farce/internal/map_value_modes.rb
 - lib/farce/internal/marshal_support.rb
@@ -287,12 +291,14 @@ files:
 - lib/farce/internal/strict_lease_map.rb
 - lib/farce/internal/strict_lease_pool.rb
 - lib/farce/internal/thread_pool.rb
+- lib/farce/internal/thread_pool_supervisor.rb
 - lib/farce/internal/transaction_conflict.rb
 - lib/farce/internal/transaction_freeze_guard.rb
 - lib/farce/internal/transaction_map_snapshot.rb
 - lib/farce/internal/undefined.rb
 - lib/farce/internal/unshared_lease.rb
 - lib/farce/internal/unshared_lease_pool.rb
+- lib/farce/internal/unshared_pool_worker.rb
 - lib/farce/internal/unshared_queue_waiting.rb
 - lib/farce/internal/value_serialization.rb
 - lib/farce/internal/weak_map_value_modes.rb
@@ -316,8 +322,10 @@ files:
 - lib/farce/local/lru_map.rb
 - lib/farce/local/map.rb
 - lib/farce/local/molecule.rb
+- lib/farce/local/pool.rb
 - lib/farce/local/priority_queue.rb
 - lib/farce/local/queue.rb
+- lib/farce/local/scheduler.rb
 - lib/farce/local/scoped.rb
 - lib/farce/local/set.rb
 - lib/farce/local/sorted_set.rb
@@ -382,7 +390,8 @@ files:
 - lib/farce/strict/weak_set.rb
 - lib/farce/strict/weak_value_map.rb
 - lib/farce/system.rb
-- lib/farce/thread_scheduler.rb
+- lib/farce/task.rb
+- lib/farce/thread_executor.rb
 - lib/farce/timer_queue.rb
 - lib/farce/transaction.rb
 - lib/farce/transaction/atom.rb
@@ -415,8 +424,10 @@ files:
 - lib/farce/unshared/lru_map.rb
 - lib/farce/unshared/map.rb
 - lib/farce/unshared/molecule.rb
+- lib/farce/unshared/pool.rb
 - lib/farce/unshared/priority_queue.rb
 - lib/farce/unshared/queue.rb
+- lib/farce/unshared/scheduler.rb
 - lib/farce/unshared/set.rb
 - lib/farce/unshared/sorted_set.rb
 - lib/farce/unshared/timer_queue.rb