farce 0.4.1-java → 0.6.0-java

data/lib/farce/concurrent.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # Module to replace some functionality of `concurrent-ruby` with.
+  #
+  # Nested in a separate module so it can easily be moved into a dedicated gem
+  # (this would only happen on a major release).
+  #
+  # Not all of them are full drop-in replacements, especially when it comes to matching superclasses.
+  #
+  # If it matches the subset of functionality you need you could replace this:
+  #
+  # ```ruby
+  # require "concurrent"
+  # ```
+  #
+  # With this:
+  #
+  # ```ruby
+  # require "farce"
+  # Concurrent = Farce::Concurrent
+  # ```
+  #
+  # If developing a gem or just part of a larger app, you can and should do this under a namespace rather than globally.
+  #
+  # @see https://ruby-concurrency.github.io/concurrent-ruby/
+  module Concurrent
+    include Internal::Autoloads
+
+    Array         = Vector
+    Atom          = Farce::Atom
+    AtomicBoolean = Flag
+    AtomicFixnum  = Counter
+    Exchanger     = Farce::Exchanger
+    Hash          = Farce::Map
+    Lock          = Farce::Lock
+    Map           = Farce::Map
+    ReadWriteLock = Farce::ReadWriteLock
+
+    autoload :LockLocalVar, "farce/concurrent/fiber_local_var"
+    private_constant :LocalVar
+
+    Farce.on_main do
+      Subscription.define(Event) { |_| subscriber.set }
+      Subscription.define(CountDownLatch) { |_| subscriber.count_down }
+    end
+  end
+end

data/lib/farce/config.rb

@@ -36,6 +36,40 @@ module Farce
     # Can also be set via `FARCE_ADDITIONAL_THREAD_POOL_SIZE`. Defaults to 2.
     attr_reader :additional_thread_pool_size
 
+    # Minimum workers retained by {Farce.in_parallel} on CRuby. Defaults to 0.
+    # Configure before the first scheduler is created. Ignored on JRuby and TruffleRuby.
+    # @return [Integer]
+    attr_reader :parallel_pool_min_size
+
+    # Maximum workers used by {Farce.in_parallel} on CRuby.
+    # Defaults to nil, which uses {System.cpu_count} when the pool is created.
+    # @return [Integer, nil]
+    attr_reader :parallel_pool_max_size
+
+    # Soft task limit for each worker in {Farce.in_parallel}'s CRuby pool.
+    # Defaults to 64. Set to nil to disable the limit.
+    # @return [Integer, nil]
+    attr_reader :parallel_pool_max_inflight
+
+    # Queue wait in seconds before {Farce.in_parallel}'s CRuby pool adds a worker.
+    # Defaults to 0.005.
+    # @return [Float]
+    attr_reader :parallel_pool_grow_after
+
+    # Idle time in seconds before an extra worker in {Farce.in_parallel}'s CRuby pool retires.
+    # Defaults to 30. Set to nil to disable idle retirement.
+    # @return [Float, nil]
+    attr_reader :parallel_pool_shrink_after
+
+    # Pending-task capacity of {Farce.in_parallel}'s CRuby pool.
+    # Defaults to 1024. Set to nil for an unbounded queue.
+    # @return [Integer, nil]
+    attr_reader :parallel_pool_capacity
+
+    PARALLEL_POOL_DEFAULTS = { max_size: nil, min_size: 0, max_inflight: 64,
+                               grow_after: 0.005, shrink_after: 30, capacity: 1024 }.freeze
+    private_constant :PARALLEL_POOL_DEFAULTS
+
     # @yield [config] block to modify the configuration
     # @yieldparam config [Config] the configuration object to configure
     def initialize
@@ -44,21 +78,29 @@ module Farce
       self.fiber_scheduler       = ENV["FARCE_FIBER_SCHEDULER"] unless instance_variable_defined?(:@fiber_scheduler)
       self.main_thread_pool_size       ||= ENV.fetch("FARCE_MAIN_THREAD_POOL_SIZE", 4)
       self.additional_thread_pool_size ||= ENV.fetch("FARCE_ADDITIONAL_THREAD_POOL_SIZE", 2)
+      initialize_parallel_pool
     end
 
     # @api private
     def marshal_dump
-      [1, autoload_integrations, fiber_scheduler, main_thread_pool_size, additional_thread_pool_size, frozen?]
+      [1, autoload_integrations, fiber_scheduler, main_thread_pool_size, additional_thread_pool_size,
+       parallel_pool_options, frozen?]
     end
 
     # @api private
     def marshal_load(data)
-      autoload, scheduler, main_size, additional_size, frozen = Internal::MarshalSupport.payload(data, 5)
+      if data.is_a?(Array) && data.length == 6
+        autoload, scheduler, main_size, additional_size, frozen = Internal::MarshalSupport.payload(data, 5)
+        options = {}
+      else
+        autoload, scheduler, main_size, additional_size, options, frozen = Internal::MarshalSupport.payload(data, 6)
+      end
 
       self.autoload_integrations        = autoload
       self.fiber_scheduler              = scheduler
       self.main_thread_pool_size        = main_size
       self.additional_thread_pool_size  = additional_size
+      initialize_parallel_pool(options)
       freeze if frozen
     end
 
@@ -149,6 +191,45 @@ module Farce
       @additional_thread_pool_size = normalize_thread_pool_size(value)
     end
 
+    # Sets a non-negative minimum worker count for the shared parallel pool.
+    # It must not exceed an explicitly configured maximum.
+    def parallel_pool_min_size=(value)
+      value = normalize_parallel_pool_size(value, :min_size, minimum: 0)
+      if parallel_pool_max_size && value > parallel_pool_max_size
+        raise ArgumentError, "parallel pool min_size must not exceed max_size"
+      end
+      @parallel_pool_min_size = value
+    end
+
+    # Sets a positive maximum worker count, or nil to use the CPU count.
+    def parallel_pool_max_size=(value)
+      value = normalize_parallel_pool_size(value, :max_size, nil_allowed: true)
+      if value && parallel_pool_min_size && value < parallel_pool_min_size
+        raise ArgumentError, "parallel pool min_size must not exceed max_size"
+      end
+      @parallel_pool_max_size = value
+    end
+
+    # Sets a positive soft task limit per worker, or nil to disable it.
+    def parallel_pool_max_inflight=(value)
+      @parallel_pool_max_inflight = normalize_parallel_pool_size(value, :max_inflight, nil_allowed: true)
+    end
+
+    # Sets a finite, non-negative queue wait before growing the pool.
+    def parallel_pool_grow_after=(value)
+      @parallel_pool_grow_after = normalize_parallel_pool_duration(value, :grow_after)
+    end
+
+    # Sets a finite, non-negative idle timeout, or nil to disable retirement.
+    def parallel_pool_shrink_after=(value)
+      @parallel_pool_shrink_after = normalize_parallel_pool_duration(value, :shrink_after, nil_allowed: true)
+    end
+
+    # Sets a positive pending-task capacity, or nil for an unbounded queue.
+    def parallel_pool_capacity=(value)
+      @parallel_pool_capacity = normalize_parallel_pool_size(value, :capacity, nil_allowed: true)
+    end
+
     # Called internally once the configuration is applied.
     def freeze
       return self if frozen?
@@ -159,6 +240,35 @@ module Farce
 
     private
 
+    def initialize_parallel_pool(options = {})
+      PARALLEL_POOL_DEFAULTS.each do |name, default|
+        next if instance_variable_defined?(:"@parallel_pool_#{name}")
+        public_send(:"parallel_pool_#{name}=", options.fetch(name, default))
+      end
+    end
+
+    def parallel_pool_options
+      PARALLEL_POOL_DEFAULTS.to_h { |name, _| [name, public_send(:"parallel_pool_#{name}")] }
+    end
+
+    def normalize_parallel_pool_size(value, name, minimum: 1, nil_allowed: false)
+      return if value.nil? && nil_allowed
+      value = Integer(value, 10) if value.is_a?(String)
+      unless value.is_a?(Integer) && value >= minimum
+        raise ArgumentError, "parallel pool #{name} must be an integer >= #{minimum}"
+      end
+      value
+    end
+
+    def normalize_parallel_pool_duration(value, name, nil_allowed: false)
+      return if value.nil? && nil_allowed
+      value = Float(value)
+      raise ArgumentError unless value.finite? && value >= 0
+      value
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "parallel pool #{name} must be finite and non-negative"
+    end
+
     def normalize_thread_pool_size(value)
       size = value.is_a?(String) ? Integer(value, 10) : value
       raise ArgumentError, "thread pool size must be a positive integer" unless size.is_a?(Integer) && size.positive?

data/lib/farce/counter.rb

@@ -13,21 +13,11 @@ module Farce
   #
   # On CRuby, subclasses must not add Ruby instance variables.
   #
-  # @!method initial
-  #   @return [Integer] The initial value retained by reset and copies.
-  #
-  # @!method value
-  #   @return [Integer] The current value of the counter.
-  #
-  # @!method increment(by = 1)
-  #   Increment the counter by the given amount (default is 1).
-  #   @param [Numeric, String, #to_int] by The amount, converted to an Integer.
-  #   @return [self] Returns self for chaining.
-  #
-  # @!method decrement(by = 1)
-  #   Decrement the counter by the given amount (default is 1).
-  #   @param [Numeric, String, #to_int] by The amount, converted to an Integer.
-  #   @return [self] Returns self for chaining.
+  # @example Allocate sequence numbers across threads or Ractors
+  #   counter = Farce::Counter.new
+  #   ticket = counter.increment # => 1
+  #   counter.increment          # => 2
+  #   ticket                     # => 1
   #
   # @example Cross-Ractor counting
   #   counter = Farce::Counter.new

data/lib/farce/deduper.rb

@@ -4,9 +4,10 @@
 
 module Farce
   # Reuse equal frozen values throughout object graphs.
-  # Plain strings use Ruby's string deduplication. Arrays, hashes, and Ruby Sets are frozen
-  # and cached by default. Other objects are traversed but are not cached unless
-  # their class matches {#store}. Modules and classes are skipped by default.
+  # Plain strings use Ruby's string deduplication. Arrays, hashes, Ruby Sets, regular
+  # expressions, Data records, and ranges are frozen and cached by default. Other objects are
+  # traversed but are not cached unless their class matches {#store}.
+  # Modules and classes are skipped by default.
   #
   # Cached objects are held weakly. Keep a reference to a returned object if its
   # identity matters. Shareable results can be reused across Ractors. Other
@@ -28,7 +29,7 @@ module Farce
       @shared = Strict::WeakKeyMap.new
       @local  = Local::WeakKeyMap.new
       @skip   = Strict::Vector[Module]
-      @store  = Strict::Vector[Hash, Array, ::Set]
+      @store  = Strict::Vector[Hash, Array, ::Set, Regexp, Data, Range]
       super
     end
 
@@ -68,6 +69,13 @@ module Farce
     # Use copy: true to preserve the input. Skipped objects are always returned
     # unchanged. Strings are deduplicated before skip rules are checked.
     # Noncopyable coordination objects follow {Walker.modify}'s in-place behavior.
+    #
+    # @note
+    #   Deduplication follows Ruby's `hash` and `eql?` semantics. Equal values
+    #   may differ in observable details. For example, `Time` values representing
+    #   the same instant can have different time zones. Deduplicating these values
+    #   or containers holding them may reuse a different timezone representation.
+    #
     # @param object [Object] the root object
     # @param copy [Boolean, Symbol] copying policy passed to {Walker.modify}
     # @param skip [Module, Array<Module>, nil] additional exclusions for this call

data/lib/farce/engine/jruby/map.rb

@@ -28,7 +28,8 @@ module Farce
         end
 
         def eql?(other)
-          result = other.is_a?(Key) && value.eql?(other.value)
+          result = other.is_a?(Key) &&
+            (BASIC_OBJECT_EQUAL_METHOD.bind_call(value, other.value) || value.eql?(other.value))
           owner = mutation_owner || (other.mutation_owner if other.is_a?(Key))
           Internal::Freeze.check(owner) if owner
           result
@@ -218,11 +219,11 @@ module Farce
       # Yield presence and value under the key reservation.
       # MAP_KEEP and MAP_DELETE are control results. Other results replace the value.
       # Return whether a change committed.
-      def modify(key) # rubocop:disable Naming/PredicateMethod
+      def modify(key, timeout: nil)
         raise LocalJumpError, "no block given" unless block_given?
         check_frozen!
         wrapped = wrap_key(key)
-        _, result = with_mutating_key_operation(wrapped, nil) do |reservation|
+        completed, result = with_mutating_key_operation(wrapped, timeout_deadline(timeout)) do |reservation|
           present, current = native_operation { [concurrent_key?(wrapped), concurrent_get(wrapped)] }
           value = yield(present, current)
           next false if MAP_KEEP.equal?(value)
@@ -235,7 +236,7 @@ module Farce
             changed!
           end
         end
-        !!result
+        completed && !!result
       end
 
       def upsert(key, initial_value, timeout: nil)
@@ -429,7 +430,8 @@ module Farce
             native_operation { concurrent_get(wrapped) }
           end
           return fallback&.call unless completed
-          ready = non_nil ? !current.nil? : !values_equal?(current, expected)
+          ready = non_nil ? !current.nil? :
+            Internal.value_changed?(current, expected, compare_values_by_identity?)
           return current if ready
           return fallback&.call unless wait_for_signal(@change_signal, generation, deadline)
         end
@@ -438,7 +440,7 @@ module Farce
       def wait_for_signal(signal, generation, deadline)
         return signal.wait(generation) unless deadline
 
-        remaining = deadline - Clock.now
+        remaining = Clock.remaining(deadline)
         return false unless remaining.positive?
         !signal.wait(generation, timeout: remaining).nil?
       end

data/lib/farce/engine/jruby/signal.rb

@@ -90,7 +90,7 @@ module Farce
             current = generation
             return current unless current == observed
 
-            remaining = deadline - Clock.now if deadline
+            remaining = Clock.remaining(deadline)
             return yield if remaining && !remaining.positive?
 
             # Java Phaser waits do not deliver Ruby cancellation until they return.
@@ -131,7 +131,7 @@ module Farce
           current = generation
           return current unless current == observed
 
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           return yield if remaining && !remaining.positive?
 
           scheduler.io_wait(reader, READABLE, remaining)

data/lib/farce/engine/jvm/counter.rb

@@ -68,7 +68,6 @@ module Farce
           check_frozen!
         end
         @counter.addAndGet(delta).tap { @signal.broadcast }
-        self
       end
 
       def decrement(delta = 1)
@@ -78,7 +77,6 @@ module Farce
           check_frozen!
         end
         @counter.addAndGet(-delta).tap { @signal.broadcast }
-        self
       end
 
       alias value get

data/lib/farce/engine/jvm/priority_queue.rb

@@ -61,11 +61,11 @@ module Farce
         native_signal = signal if RUBY_ENGINE == "jruby" &&
           JVMContainers.identical?(JVMContainers::OBJECT_CLASS_METHOD.bind_call(signal), Signal)
         core = JVMExtension::PriorityQueue.new(COMPARATOR, SNAPSHOT, IDENTITY, EQUAL,
-          IDENTICAL, MATCH, committer, SCHEDULED, java_capacity, native_signal, track_age ? true : false)
+          IDENTICAL, MATCH, committer, SCHEDULED, java_capacity, Box.new(parsed_capacity), native_signal,
+          track_age ? true : false)
         INITIALIZATION_LOCK.synchronize do
           Thread.handle_interrupt(INTERRUPT_MASK) do
             check_initialization
-            @capacity = parsed_capacity
             @core = core
             JVMContainers.freeze_object(self)
           end
@@ -112,8 +112,18 @@ module Farce
       def empty? = size.zero?
 
       def capacity
-        storage
-        @capacity
+        storage.getCapacity.value
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def capacity=(value)
+        value = normalize_capacity(value)
+        java_capacity = value ? [value, JAVA_CAPACITY_MAX].min : 0
+        storage.setCapacity(java_capacity, Box.new(value))
+        value
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
       end
 
       def closed?

data/lib/farce/engine/ruby/shared/parallel_scheduler.rb

@@ -4,6 +4,14 @@
 
 module Farce
   module Internal # :nodoc: all
-    ParallelScheduler = Pool.new(max_size: System.cpu_count)
+    config = FROZEN_CONFIG
+    ParallelScheduler = Pool.new(
+      min_size:     config.parallel_pool_min_size,
+      max_size:     config.parallel_pool_max_size || System.cpu_count,
+      max_inflight: config.parallel_pool_max_inflight,
+      grow_after:   config.parallel_pool_grow_after,
+      shrink_after: config.parallel_pool_shrink_after,
+      capacity:     config.parallel_pool_capacity,
+    )
   end
 end

data/lib/farce/engine/ruby/shared/ractor_selector.rb

@@ -125,10 +125,7 @@ module Farce
         command(:add, request)
         request.ready&.pop
 
-        if deadline
-          remaining = deadline - Clock.now
-          remaining = 0 if remaining.negative?
-        end
+        remaining = Clock.remaining(deadline)
 
         delivery = request.reply.pop(timeout: remaining)
         if delivery

data/lib/farce/engine/ruby/shared/weak_cache_mirror.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal # :nodoc: all
+    class WeakCacheMirror
+      include Shareable::Delegated
+
+      CACHED_NIL = Object.new.freeze
+      private_constant :CACHED_NIL
+
+      def initialize(shared)
+        @shared = shared
+        super()
+      end
+
+      def store_if_absent(key, &)
+        check_frozen!
+        return @shared.store_if_absent(key, &) unless Ractor.shareable?(key)
+
+        local = local_cache
+        value = local[key]
+        return CACHED_NIL.equal?(value) ? nil : value unless nil.equal?(value)
+
+        value = @shared.store_if_absent(key, &)
+        local[key] = nil.equal?(value) ? CACHED_NIL : value
+        value
+      end
+
+      def fetch(key)
+        return @shared.fetch(key) { yield(key) } unless Ractor.shareable?(key)
+
+        local = local_cache
+        value = local[key]
+        return CACHED_NIL.equal?(value) ? nil : value unless nil.equal?(value)
+
+        value = @shared.fetch(key) { return yield(key) }
+        local[key] = nil.equal?(value) ? CACHED_NIL : value
+        value
+      end
+
+      private
+
+      # CRuby's weak-map operations hold the GVL. Shared misses serialize generation,
+      # and a retained value cannot be replaced, so local hits need no reservation.
+      # Only shareable keys enter the mirror, since mutable strings can change meaning.
+      def local_cache
+        caches = Ractor.store_if_absent(:"Farce::Internal::WeakCacheMirror") { ObjectSpace::WeakKeyMap.new }
+        caches[self] ||= ObjectSpace::WeakMap.new
+      end
+
+      def freeze_backend = @shared
+    end
+  end
+end

data/lib/farce/engine/ruby/shared/weak_map.rb

@@ -134,17 +134,19 @@ module Farce
       # Yield presence and value under the entry claim.
       # MAP_KEEP and MAP_DELETE are control results. Other results replace the value.
       # Return whether a change committed.
-      def modify(key)
+      def modify(key, timeout: nil)
         raise LocalJumpError, "no block given" unless block_given?
         check_frozen!
         key = canonical_key(key)
+        deadline = timeout_deadline(timeout)
         ticket = Object.new.freeze
         sent = finished = false
         begin
-          response = await_response(deadline: nil) do
+          response = await_response(deadline:) do
             sent = true
             request(:claim, key, ticket, true)
           end
+          return false if response.equal?(TIMED_OUT)
           present, current, signal = response[1], response[2], response[3]
           owners = claim_owners
           owners[signal] = Fiber.current
@@ -306,7 +308,7 @@ module Farce
 
           signal, generation = response[1], response[2]
           reject_recursive_wait!(signal)
-          timeout = remaining_timeout(deadline)
+          timeout = Clock.remaining(deadline)
           if timeout&.zero?
             return TIMED_OUT if checked_after_timeout
             checked_after_timeout = true
@@ -332,11 +334,13 @@ module Farce
           key     = response[5] if response.first == :ok
           present = response.first == :ok && response[1]
           current = present ? response[2] : nil
-          return current if non_nil ? !current.nil? : !values_equal?(current, expected)
+
+          return current if non_nil ? !current.nil? :
+            Internal.value_changed?(current, expected, compare_values_by_identity?)
 
           signal = response.first == :ok ? response[3] : response[1]
           generation = response.first == :ok ? response[4] : response[2]
-          changed = signal.wait_until_changed(generation, timeout: remaining_timeout(deadline)) { TIMED_OUT }
+          changed = signal.wait_until_changed(generation, timeout: Clock.remaining(deadline)) { TIMED_OUT }
           if changed.equal?(TIMED_OUT)
             return fallback&.call if checked_after_timeout
             checked_after_timeout = true
@@ -381,13 +385,6 @@ module Farce
         Clock.now + timeout
       end
 
-      def remaining_timeout(deadline)
-        return unless deadline
-
-        remaining = deadline - Clock.now
-        remaining.positive? ? remaining : 0
-      end
-
       def validate_boolean(value, name)
         return if value.equal?(true) || value.equal?(false)
         raise ArgumentError, "#{name} must be true or false"

data/lib/farce/engine/ruby.rb

@@ -40,10 +40,14 @@ module Farce
       raise e unless e.path == "#{ENGINE_PATH}/patch"
     end
 
-    unless const_defined?(:NATIVE_WEAK_MAPS, false) && NATIVE_WEAK_MAPS
+    if const_defined?(:NATIVE_WEAK_MAPS, false) && NATIVE_WEAK_MAPS
+      def native_weak_maps? = true
+    else
+      def native_weak_maps? = false
       autoload :WeakMap,      "farce/engine/ruby/shared/weak_map"
       autoload :WeakKeyMap,   "farce/engine/ruby/shared/weak_map"
       autoload :WeakValueMap, "farce/engine/ruby/shared/weak_map"
+      autoload :WeakCacheMirror, "farce/engine/ruby/shared/weak_cache_mirror"
     end
 
     StrictAtom    = Atom

data/lib/farce/engine/shared/exchanger.rb

@@ -77,7 +77,7 @@ module Farce
       def wait_with_condition(waiter, deadline)
         @mutex.synchronize do
           until waiter.matched
-            remaining = deadline - Clock.now if deadline
+            remaining = Clock.remaining(deadline)
             return cancel(waiter) if remaining && !remaining.positive?
             waiter.condition.wait(@mutex, remaining)
           end
@@ -91,7 +91,7 @@ module Farce
             if waiter.matched
               [nil, waiter.received]
             else
-              remaining = deadline - Clock.now if deadline
+              remaining = Clock.remaining(deadline)
               remaining && !remaining.positive? ? [nil, cancel(waiter)] : [WAITING, remaining]
             end
           end

data/lib/farce/engine/shared/queue.rb

@@ -9,17 +9,56 @@ module Farce
       include Freeze::Unfreezable
 
       NIL_VALUE = Object.new.freeze
-      attr_reader :capacity
 
       def initialize(capacity: 1024, track_age: false)
         @queue     = capacity ? Thread::SizedQueue.new(capacity) : Thread::Queue.new
-        @capacity  = capacity
         @signal    = Signal.new
         @tracking  = track_age ? { lock: Mutex.new, timestamps: [], generation: 0 } : nil
-        @lifecycle = { lock: Mutex.new, hard_closed: false }
+        @lifecycle = { lock: Mutex.new, hard_closed: false, token: nil, generation: -1 }
         Freeze.publish(self)
       end
 
+      def capacity = @queue.is_a?(Thread::SizedQueue) ? @queue.max : nil
+
+      def capacity=(value)
+        value = Integer(value) unless value.nil?
+        raise ArgumentError, "capacity must be positive or nil" if value && !value.positive?
+        if value.nil? != capacity.nil?
+          raise ArgumentError, "cannot switch between bounded and unbounded queues on this Ruby engine"
+        end
+        @queue.max = value if value
+        broadcast
+        value
+      end
+
+      def interrupt(token, generation)
+        @lifecycle[:lock].synchronize do
+          return self if generation <= @lifecycle[:generation]
+          @lifecycle[:token] = token
+          @lifecycle[:generation] = generation
+        end
+        broadcast
+        self
+      end
+
+      def pop_interruptible(token, timeout)
+        timeout_at = timeout_at(timeout)
+        loop do
+          return false unless @lifecycle[:lock].synchronize { @lifecycle[:token].equal?(token) }
+          begin
+            result = tracked_pop
+            raise ThreadError if nil.equal?(result) && @queue.closed?
+            broadcast
+            return NIL_VALUE.equal?(result) ? nil : result
+          rescue ThreadError
+            ready = wait(remaining_timeout(timeout_at)) do
+              !@lifecycle[:lock].synchronize { @lifecycle[:token].equal?(token) } || size.positive?
+            end
+            return block_given? ? yield : nil unless ready
+          end
+        end
+      end
+
       def pop(timeout: nil)
         timeout_at = timeout_at(timeout)
         # Observing an empty queue is sufficient for a nonblocking miss. Avoid
@@ -223,8 +262,7 @@ module Farce
       def remaining_timeout(timeout_at)
         return unless timeout_at
         return 0 if timeout_at.zero?
-        timeout = timeout_at - Clock.now
-        timeout.positive? ? timeout : 0
+        Clock.remaining(timeout_at)
       end
 
       def broadcast = @signal.broadcast

data/lib/farce/engine/shared/ractor_selector.rb

@@ -61,7 +61,7 @@ module Farce
             result = port.select_receive
             return result if result
           end
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           return if remaining && !remaining.positive?
           return unless ReservationWaiting.wait(wakeup, generation, deadline)
         end

data/lib/farce/engine/shared/strict_map.rb

@@ -67,6 +67,11 @@ module Farce
         super(check_key(key), **) { |value| check_value(yield(value)) }
       end
 
+      def modify(key, **)
+        raise LocalJumpError, "no block given" unless block_given?
+        super(check_key(key), **) { |present, value| check_value(yield(present, value)) }
+      end
+
       def upsert(key, initial, **)
         raise LocalJumpError, "no block given" unless block_given?
         super(check_key(key), check_value(initial), **) { |value| check_value(yield(value)) }