farce 0.1.0-x86_64-linux-gnu → 0.3.0-x86_64-linux-gnu

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/unshared/set.rb

@@ -7,6 +7,7 @@ module Farce
     # A thread-safe set for mutable elements used within one Ractor.
     class Set < Farce::Abstract::Set
       include Unshareable
+      include Internal::Freeze::Delegated
 
       private def new_map(...) = Farce::Unshared::Map.new(...)
     end

data/lib/farce/unshared/sorted_set.rb

@@ -7,6 +7,7 @@ module Farce
     # A thread-safe set maintained in ascending order within one Ractor.
     class SortedSet < Farce::Abstract::SortedSet
       include Unshareable
+      include Internal::Freeze::Delegated
 
       class MutableTreeMap < Farce::Unshared::TreeMap # :nodoc:
         private

data/lib/farce/unshared/tree_map.rb

@@ -14,8 +14,12 @@ module Farce
     #   map[2].equal?(value) # => true
     class TreeMap < Abstract::TreeMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
-      private def new_tree_map(...) = Internal::TreeMap.new(...)
+      private
+
+      def new_tree_map(...) = Internal::TreeMap.new(...)
+      def freeze_backend    = @map
     end
   end
 end

data/lib/farce/unshared/vector.rb

@@ -7,6 +7,7 @@ module Farce
     # A thread-safe vector for mutable values used within one Ractor.
     class Vector < Abstract::Vector
       include Unshareable
+      include Internal::Freeze::Delegated
 
       # @param source [Array, nil] Initial values. Values are retained directly.
       # @param compare_by_identity [Boolean] Whether values are compared by identity.
@@ -14,6 +15,8 @@ module Farce
         @vector = Internal::UnsharedVector.new(source, compare_by_identity:)
         super()
       end
+
+      private def freeze_backend = @vector
     end
   end
 end

data/lib/farce/unshared/weak_atom.rb

@@ -24,8 +24,12 @@ module Farce
     #   atom.value.equal?(replacement)              # => true
     class WeakAtom < Abstract::WeakAtom
       include Unshareable
+      include Internal::Freeze::Delegated
 
-      private def internal_atom_class = Internal::UnsharedWeakAtom
+      private
+
+      def internal_atom_class = Internal::UnsharedWeakAtom
+      def freeze_backend      = @atom
     end
   end
 end

data/lib/farce/unshared/weak_key_map.rb

@@ -16,6 +16,7 @@ module Farce
     #   owner = nil
     class WeakKeyMap < Abstract::WeakKeyMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       def initialize(
         initial_mapping = nil,
@@ -39,6 +40,8 @@ module Farce
         Internal::KeyNormalizer.install_concurrent(self, normalizer) if restoring
         super()
       end
+
+      private def freeze_backend = @map
     end
   end
 end

data/lib/farce/unshared/weak_map.rb

@@ -16,6 +16,7 @@ module Farce
     #   value = nil
     class WeakMap < Abstract::WeakMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       def initialize(
         initial_mapping = nil,
@@ -39,6 +40,8 @@ module Farce
         Internal::KeyNormalizer.install_concurrent(self, normalizer) if restoring
         super()
       end
+
+      private def freeze_backend = @map
     end
   end
 end

data/lib/farce/unshared/weak_set.rb

@@ -7,6 +7,7 @@ module Farce
     # A thread-safe set that retains mutable elements weakly within one Ractor.
     class WeakSet < Farce::Abstract::WeakSet
       include Unshareable
+      include Internal::Freeze::Delegated
 
       private def new_map(...) = Farce::Unshared::WeakMap.new(...)
     end

data/lib/farce/unshared/weak_value_map.rb

@@ -15,6 +15,7 @@ module Farce
     #   value = nil
     class WeakValueMap < Abstract::WeakValueMap
       include Unshareable
+      include Internal::Freeze::Delegated
 
       def initialize(
         initial_mapping = nil,
@@ -38,6 +39,8 @@ module Farce
         Internal::KeyNormalizer.install_concurrent(self, normalizer) if restoring
         super()
       end
+
+      private def freeze_backend = @map
     end
   end
 end

data/lib/farce/vector.rb

@@ -10,9 +10,9 @@ module Farce
   #   vector = Farce::Vector.new([[]], mode: :make_shareable)
   #   vector.update(0) { |jobs| jobs + [:finished] } # => [:finished]
   #
-  # @!method append(value, mode: nil, timeout: nil)
-  #   Append one value using the same options as {#push}.
-  #   @param value [BasicObject] The value to append.
+  # @!method append(*values, mode: nil, timeout: nil)
+  #   Append values using the same options as {#push}.
+  #   @param values [Array<BasicObject>] The values to append.
   #   @param mode [Symbol, nil] The transfer mode, or nil to use the default.
   #   @param timeout [Numeric, nil] The maximum wait in seconds. Nil waits indefinitely.
   #   @return [self, false] Self on success, or false on timeout.
@@ -23,7 +23,7 @@ module Farce
     # @param source [Array, nil] Initial values. The source array is not retained.
     # @param mode [Symbol] The default value transfer mode.
     # @param compare_by_identity [Boolean] Whether values are compared by identity.
-    def initialize(source = nil, mode: :copy, compare_by_identity: false)
+    def initialize(source = nil, mode: :smart, compare_by_identity: false)
       raise TypeError, "source must be an Array" unless source.nil? || source.is_a?(Array)
       unless true.equal?(compare_by_identity) || false.equal?(compare_by_identity)
         raise ArgumentError, "compare_by_identity must be true or false"
@@ -64,13 +64,20 @@ module Farce
     def shareable_values? = true
 
     # (see Farce::Abstract::Vector#[])
-    def [](index) = @manager.unwrap(@vector[index])
+    def [](index, length = UNDEFINED)
+      return @manager.unwrap(@vector[index]) if length.equal?(UNDEFINED) && !index.is_a?(Range)
+      slice(index, length)
+    end
 
     # (see Farce::Abstract::Vector#[]=)
-    def []=(index, value)
-      check_frozen!
-      @vector[index] = @manager.wrap(value)
-      value
+    def []=(index, value, replacement = UNDEFINED)
+      if replacement.equal?(UNDEFINED) && !index.is_a?(Range)
+        check_frozen!
+        @vector[index] = @manager.wrap(value)
+        value
+      else
+        assign_vector_slice(index, value, replacement)
+      end
     end
 
     # (see Farce::Abstract::Vector#get)
@@ -85,13 +92,21 @@ module Farce
 
     # (see Farce::Abstract::Vector#push)
     # @param mode [Symbol, nil] The transfer mode, or nil to use the default.
-    def push(value, mode: nil, timeout: nil)
-      check_frozen!
-      @vector.push(@manager.wrap(value, mode:), timeout:) ? self : false
+    def push(value = UNDEFINED, *rest, mode: nil, timeout: nil)
+      if rest.empty? && !value.equal?(UNDEFINED)
+        check_frozen!
+        stored = mode.nil? ? @manager.wrap(value) : @manager.wrap(value, mode:)
+        completed = timeout.nil? ? @vector.push(stored) : @vector.push(stored, timeout:)
+        return completed ? self : false
+      end
+      push_values(value.equal?(UNDEFINED) ? rest : [value, *rest], mode:, timeout:)
     end
 
     # (see Farce::Abstract::Vector#pop)
-    def pop(timeout: nil) = @manager.unwrap(@vector.pop(timeout:))
+    def pop(count = UNDEFINED, timeout: nil)
+      return @manager.unwrap(timeout.nil? ? @vector.pop : @vector.pop(timeout:)) if count.equal?(UNDEFINED)
+      pop_values(count, timeout:)
+    end
 
     # (see Farce::Abstract::Vector#swap)
     # @!macro modes
@@ -183,7 +198,9 @@ module Farce
 
     protected
 
-    def logical_value(value) = @manager.unwrap(value)
+    def logical_value(value)              = @manager.unwrap(value)
+    def deletion_comparison(value)        = wrap_comparison(value)
+    def deletion_match?(stored, expected) = values_equal?(stored, expected)
 
     def build_derived_vector(values)
       self.class.allocate.initialize_derived_vector(values, @manager, @compare_by_identity)
@@ -206,11 +223,19 @@ module Farce
 
     private
 
-    def inspect_value(inspector, value) = super(inspector, value, @manager)
-    def derived_storage(value)          = @manager.wrap(value)
-    def freeze_backend                  = @vector
-    def wrap_comparison(value)          = @manager.wrap(value, mode: compare_by_identity? ? :local : :copy)
-    def values_equal?(left, right)      = @manager.same_value?(left, right, identity: compare_by_identity?)
+    def inspect_value(inspector, value)        = super(inspector, value, @manager)
+    def derived_storage(value)                 = @manager.wrap(value)
+    def prepare_vector_value(value, mode: nil) = @manager.wrap(value, mode:)
+
+    # Expanded descendants have no independent envelope to reuse. Copy them rather than
+    # moving them out of a retained parent Array or another sequence's storage.
+    def prepare_sequence_value(value)
+      @manager.wrap(value, mode: mode == :move ? :copy : nil)
+    end
+
+    def freeze_backend             = @vector
+    def wrap_comparison(value)     = @manager.wrap(value, mode: compare_by_identity? ? :local : :copy)
+    def values_equal?(left, right) = @manager.same_value?(left, right, identity: compare_by_identity?)
 
     def timeout_deadline(timeout)
       return if timeout.nil?

data/lib/farce/version.rb

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

data/lib/farce.rb

@@ -54,7 +54,10 @@ module Farce
 
   # The valid transfer modes for values that are not Ractor-shareable.
   # @return [::Set<Symbol>]
-  MODES = ::Set[:copy, :move, :local, :make_shareable, :mutable, :raise, :shareable_copy, :dedup, :proxy].freeze
+  MODES = ::Set[
+    :copy, :marshal, :move, :local, :make_shareable, :mutable, :raise, :shareable_copy, :dedup, :proxy,
+    :smart, :smart_raise, :smart_move, :smart_copy,
+  ].freeze
 
   UNDEFINED = Internal::Undefined.new("UNDEFINED")
 
@@ -171,7 +174,7 @@ module Farce
     DEDUPER.dedup(object, **)
   end
 
-  # @overload enfarce(object, freeze: nil, mode: :copy)
+  # @overload enfarce(object, freeze: nil, mode: :smart)
   #   Converts vanilla Ruby objects into their {Farce} equivalents.
   #
   #   @!macro modes
@@ -357,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 = []
@@ -396,7 +399,7 @@ module Farce
   #   # Hi from the current ractor!
   #   # Hi again from the main ractor!
   #
-  # @overload on_main(*args, mode: :copy)
+  # @overload on_main(*args, mode: :smart)
   #   @param args [Array] The arguments to be passed to the block.
   #   @param mode [Symbol] The argument transfer mode when called from another ractor.
   #   @yield [*args] The block to be executed on the main ractor.
@@ -405,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?
@@ -418,7 +421,7 @@ module Farce
     if Ractor.main?
       yield(*args)
     else
-      mode = :copy if UNDEFINED.equal?(mode)
+      mode = :smart if UNDEFINED.equal?(mode)
       Internal::MainScheduler.execute(*args, mode:, auto_local: false, &)
     end
 
@@ -438,16 +441,16 @@ module Farce
   #   Farce.in_parallel("hello") { |message| puts message.upcase }
   #   Farce.in_parallel.schedule { puts "another task" }
   #
-  # @overload in_parallel(*args, mode: :copy)
+  # @overload in_parallel(*args, mode: :smart)
   #   @param args [Array<Object>] Arguments passed to the block.
   #   @param mode [Symbol] Argument transfer mode. Ignored on JRuby and TruffleRuby.
   #   @yield [*args] The task to schedule.
   #   @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?
@@ -455,12 +458,12 @@ module Farce
       return Internal::ParallelScheduler
     end
 
-    mode = :copy if UNDEFINED.equal?(mode)
+    mode = :smart if UNDEFINED.equal?(mode)
     Internal::ParallelScheduler.schedule(*args, mode:, &)
     nil
   end
 
-  # @overload schedule(*args, mode: :copy, auto_local: true, **kwargs)
+  # @overload schedule(*args, mode: :smart, auto_local: true, **kwargs)
   #   Schedules work to be executed out of band.
   #
   #   If the `mode` is set to `:local`, it will use the current thread's fiber scheduler to schedule the task.
@@ -486,26 +489,18 @@ module Farce
   #   @param kwargs [Hash] Additional keyword arguments passed to the scheduler.
   #   @yield [*args] The task to schedule.
   #   @return [nil]
-  def self.schedule(*, mode: :copy, auto_local: true, **, &)
+  def self.schedule(*, mode: :smart, auto_local: true, **, &)
     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.1.0
+  version: 0.3.0
 platform: x86_64-linux-gnu
 authors:
 - Konstantin Haase
@@ -83,6 +83,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
@@ -92,6 +93,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
@@ -157,6 +159,7 @@ files:
 - lib/farce/engine/ruby/shared/proxy_owner.rb
 - lib/farce/engine/ruby/shared/ractor_methods.rb
 - lib/farce/engine/ruby/shared/ractor_selector.rb
+- lib/farce/engine/ruby/shared/require_hook.rb
 - lib/farce/engine/ruby/shared/strict_map.rb
 - lib/farce/engine/ruby/shared/unshared_vector.rb
 - lib/farce/engine/ruby/shared/vault.rb
@@ -229,6 +232,7 @@ files:
 - lib/farce/integrations/bson.rb
 - lib/farce/integrations/cbor.rb
 - lib/farce/integrations/concurrent.rb
+- lib/farce/integrations/date.rb
 - lib/farce/integrations/dry-types.rb
 - lib/farce/integrations/dry_types.rb
 - lib/farce/integrations/json.rb
@@ -252,6 +256,7 @@ files:
 - lib/farce/internal/delegation.rb
 - lib/farce/internal/external_transaction.rb
 - lib/farce/internal/fake_ractor.rb
+- lib/farce/internal/flag_waiting.rb
 - lib/farce/internal/freeze.rb
 - lib/farce/internal/inspect.rb
 - lib/farce/internal/key_lock_map.rb
@@ -261,6 +266,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
@@ -286,12 +293,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
@@ -315,8 +324,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
@@ -332,6 +343,7 @@ files:
 - lib/farce/lru_map.rb
 - lib/farce/map.rb
 - lib/farce/mode_manager.rb
+- lib/farce/mode_manager/smart_rule.rb
 - lib/farce/molecule.rb
 - lib/farce/mutable.rb
 - lib/farce/pool.rb
@@ -380,7 +392,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
@@ -413,8 +426,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