farce 0.4.1-aarch64-linux-gnu → 0.6.0-aarch64-linux-gnu

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)) }

data/lib/farce/engine/shared/trie/ignore_case.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal
+    class PortableTrie
+      # @api private
+      module IgnoreCase
+        private
+
+        def each_result(input, peek:, deduplicate:, &)
+          raise TypeError, "input must be a String" unless input.is_a?(String)
+          input = String.new(input)
+          validate_encoding!(input, "input")
+
+          input_length = input.length
+          static_input = input.downcase
+          if static_input.length != input_length
+            return each_expanding_result(input, static_input, peek:, deduplicate:, &)
+          end
+          seen = {} if deduplicate
+          stack = [[@root, 0, EMPTY_CAPTURES, EMPTY_NAMED_CAPTURES, 0, 0]]
+
+          until stack.empty?
+            node, position, captures, named, phase, index = stack.pop
+            if phase.zero?
+              child = nil
+              stride = node.stride
+              if node.fast_static
+                key = static_input[position, stride]
+                child = node.fast_static[key] if key
+              elsif position < input_length && !node.static.empty?
+                child = node.static[static_input[position]]
+              end
+              if child
+                # Retain only frames with alternatives or a terminal result.
+                stack << [node, position, captures, named, 1, 0] unless node.dynamic.empty? && node.tokens.empty?
+                stack << [child, position + stride, captures, named, 0, 0]
+                next
+              end
+            end
+            if index < node.dynamic.length
+              regexp, child = node.dynamic[index]
+              if index + 1 < node.dynamic.length || !node.tokens.empty?
+                stack << [node, position, captures, named, 1, index + 1]
+              end
+              if (matched = regexp.match(input, position))
+                stack << [
+                  child,
+                  matched.end(0),
+                  captures + matched.captures,
+                  merge_named_captures(named, matched.named_captures),
+                  0,
+                  0
+                ]
+              end
+            elsif (peek || position == input_length) && !node.tokens.empty?
+              node.tokens.each do |token_id|
+                next if deduplicate && seen.key?(token_id)
+
+                seen[token_id] = true if deduplicate
+                yield(
+                  @tokens.fetch(token_id),
+                  captures.map { |value| value&.dup },
+                  copy_named_captures(named),
+                  input[position..] || +""
+                )
+              end
+            end
+          end
+        end
+
+        def each_expanding_result(input, static_input, peek:, deduplicate:)
+          to_original = [0]
+          from_original = [0]
+          input.each_char.with_index do |character, index|
+            count = character.downcase.length
+            # An internal lowercase boundary cannot start a regexp or end a result.
+            (count - 1).times { to_original << nil }
+            to_original << (index + 1)
+            from_original << (to_original.length - 1)
+          end
+          input_length = static_input.length
+          seen = {} if deduplicate
+          stack = [[@root, 0, EMPTY_CAPTURES, EMPTY_NAMED_CAPTURES, 0, 0]]
+
+          until stack.empty?
+            node, position, captures, named, phase, index = stack.pop
+            original_position = to_original[position]
+            case phase
+            when 0
+              stack << [node, position, captures, named, 1, 0]
+              if node.fast_static
+                key = static_input[position, node.stride]
+                if key && (child = node.fast_static[key])
+                  stack << [child, position + node.stride, captures, named, 0, 0]
+                end
+              elsif position < input_length && (child = node.static[static_input[position]])
+                stack << [child, position + 1, captures, named, 0, 0]
+              end
+            when 1
+              if index < node.dynamic.length
+                regexp, child = node.dynamic[index]
+                stack << [node, position, captures, named, 1, index + 1]
+                if original_position && (matched = regexp.match(input, original_position))
+                  stack << [
+                    child,
+                    from_original[matched.end(0)],
+                    captures + matched.captures,
+                    merge_named_captures(named, matched.named_captures),
+                    0,
+                    0
+                  ]
+                end
+              elsif original_position && (peek || position == input_length) && !node.tokens.empty?
+                node.tokens.each do |token_id|
+                  next if deduplicate && seen.key?(token_id)
+
+                  seen[token_id] = true if deduplicate
+                  yield(
+                    @tokens.fetch(token_id),
+                    captures.map { |value| value&.dup },
+                    copy_named_captures(named),
+                    input[original_position..] || +""
+                  )
+                end
+              end
+            end
+          end
+        end
+      end
+      private_constant :IgnoreCase
+    end
+  end
+end

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

@@ -76,11 +76,16 @@ module Farce
       end
       private_constant :Node
 
-      def initialize(entries, tokens)
+      def initialize(entries, tokens, ignore_case: false)
         validate_array!(entries, "entries")
         validate_array!(tokens, "tokens")
         validate_tokens!(tokens)
 
+        if ignore_case
+          @ignore_case = true
+          extend IgnoreCase
+        end
+
         @tokens      = Array.new(tokens).freeze
         @root        = Node.new
         nodes        = [@root]
@@ -103,6 +108,7 @@ module Farce
             when String
               literal = String.new(part)
               validate_encoding!(literal, "edge")
+              literal.downcase! if ignore_case
               literal.each_char do |character|
                 child = node.static[character]
                 unless child
@@ -171,6 +177,12 @@ module Farce
 
       private
 
+      def initialize_dup(other)
+        super
+        # Unlike clone, dup does not retain the instance's matching module.
+        extend IgnoreCase if @ignore_case
+      end
+
       def anchor(regexp)
         compile_regexp("\\G(?:#{regexp.source})", regexp)
       rescue RegexpError
@@ -314,4 +326,5 @@ module Farce
   end
 end
 
+require "farce/engine/shared/trie/ignore_case"
 require "farce/engine/shared/trie_builder"

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

@@ -17,6 +17,13 @@ module Farce
     # terminal match. A regexp edge is atomic. Later edges cannot make a regexp
     # choose a different endpoint.
     #
+    # Pass `ignore_case: true` to {.build} or {Builder.new} to compare all static
+    # segments using Unicode downcasing. Regexp options do not change. Regexp
+    # matches, captures, and suffixes use the original input and retain its casing.
+    # This does not include every equivalence supported by `Regexp::IGNORECASE`.
+    # For example, `"SS"` matches `"ss"`, but `"ß"` does not match `"ss"`.
+    # Case-equivalent static entries share a branch and retain their token order.
+    #
     # Tokens must already be Ractor-shareable. They are stored and returned
     # unchanged. Equal but different token objects remain separate. Reusing the
     # same token object produces at most one result per lookup.
@@ -94,20 +101,23 @@ module Farce
       # Collects entries and publishes immutable {Trie} snapshots.
       class Builder
         # Create an empty builder.
-        def initialize
+        # @param ignore_case [Boolean] compare all static segments without case
+        def initialize(ignore_case: false)
           @entries = []
+          @ignore_case = !!ignore_case
         end
 
         # @api private
         def marshal_dump
           entries = @entries.map { |parts, token| [parts, Internal::MarshalSupport.value(token)] }
-          [1, entries, frozen?]
+          [1, entries, frozen?, @ignore_case]
         end
 
         # @api private
         def marshal_load(data)
-          entries, frozen = Internal::MarshalSupport.payload(data, 2)
-          initialize
+          length = data.is_a?(Array) && data.length == 3 ? 2 : 3
+          entries, frozen, ignore_case = Internal::MarshalSupport.payload(data, length)
+          initialize(ignore_case:)
           entries.each { |parts, token| add(parts, Internal::MarshalSupport.restore_value(token)) }
           freeze if frozen
         end
@@ -159,7 +169,7 @@ module Farce
             [parts.dup.freeze, token_ids.fetch(token)].freeze
           end.freeze
 
-          Trie.send(:build_entries, entries, tokens.freeze)
+          Trie.send(:build_entries, entries, tokens.freeze, ignore_case: @ignore_case)
         end
 
         private
@@ -180,17 +190,18 @@ module Farce
       class << self
         # Build an immutable trie.
         #
+        # @param ignore_case [Boolean] compare all static segments without case
         # @yieldparam builder [Builder]
         # @return [Trie]
-        def build
-          builder = Builder.new
+        def build(ignore_case: false)
+          builder = Builder.new(ignore_case:)
           yield builder if block_given?
           builder.build
         end
 
         private
 
-        def build_entries(entries, tokens) = new(entries, tokens)
+        def build_entries(entries, tokens, ignore_case:) = new(entries, tokens, ignore_case:)
 
         private :new
       end

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

@@ -129,7 +129,7 @@ module Farce
 
         loop do
           current, version = @mutex.synchronize { [@value, @version] }
-          return current unless values_equal?(current, expected)
+          return current if Internal.value_changed?(current, expected, compare_by_identity?)
 
           result = @mutex.synchronize do
             next unless @version == version

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

@@ -6,9 +6,11 @@ module Farce
   # @!visibility private
   module Internal # :nodoc: all
     class UnsharedVector
+      def self.normalize_source(source) = source.is_a?(Integer) ? Array.new(source) : source
+
       def initialize(source = nil, compare_by_identity: false)
         validate_boolean(compare_by_identity, "compare_by_identity")
-        raise TypeError, "source must be an Array" unless source.nil? || source.is_a?(Array)
+        raise TypeError, "source must be an Array" unless source.nil? || source.is_a?(Array) || source.is_a?(Integer)
 
         @values              = source ? Array.new(source) : []
         @compare_by_identity = compare_by_identity
@@ -274,12 +276,12 @@ module Farce
         finish_update if completed
       end
 
-      def wait_until_changed(index, expected, timeout: nil)
-        wait_for_value(convert_index(index), expected, timeout_deadline(timeout), non_nil: false)
+      def wait_until_changed(index, expected, timeout: nil, &fallback)
+        wait_for_value(convert_index(index), expected, timeout_deadline(timeout), fallback, non_nil: false)
       end
 
       def wait_until_non_nil(index, timeout: nil)
-        wait_for_value(convert_index(index), nil, timeout_deadline(timeout), non_nil: true)
+        wait_for_value(convert_index(index), nil, timeout_deadline(timeout), nil, non_nil: true)
       end
 
       def compare_by_identity? = @compare_by_identity
@@ -341,20 +343,21 @@ module Farce
         raise FrozenError.new("can't modify frozen #{self.class}", receiver: self)
       end
 
-      def wait_for_value(index, expected, deadline, non_nil:)
+      def wait_for_value(index, expected, deadline, fallback, non_nil:)
         while true
           generation = @signal.generation
           current    = @mutex.synchronize { @values[index] }
-          ready      = non_nil ? !current.nil? : !values_equal?(current, expected)
+          ready      = non_nil ? !current.nil? :
+            Internal.value_changed?(current, expected, compare_by_identity?)
           return current if ready
-          return unless wait_for_signal(generation, deadline)
+          return fallback&.call unless wait_for_signal(generation, deadline)
         end
       end
 
       def wait_for_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/shared/unshared_weak_map.rb

@@ -145,10 +145,11 @@ module Farce
       # Yield presence and value under the entry 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!
-        _, result = with_entry(key, nil, create: true, mutating: true) do |present, current, entry, index|
+        deadline = timeout_deadline(timeout)
+        completed, result = with_entry(key, deadline, create: true, mutating: true) do |present, current, entry, index|
           value = yield(present, current)
           check_frozen!
           if MAP_KEEP.equal?(value)
@@ -161,7 +162,7 @@ module Farce
             entry.store(value)
           end
         end
-        !!result
+        completed && !!result
       end
 
       def wait_until_changed(key, expected, timeout: nil, &fallback)
@@ -352,7 +353,7 @@ module Farce
           return fallback&.call if timed_out == :timed_out
 
           unless entry
-            return nil unless values_equal?(nil, expected)
+            return nil if Internal.value_changed?(nil, expected, compare_values_by_identity?)
             return fallback&.call unless signal_changed?(@index.change_signal, observed, deadline)
             next
           end
@@ -373,13 +374,14 @@ module Farce
           # lookup object. Otherwise GC could orphan the entry's change signal.
           key     = stored_key
           current = nil unless present
-          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?)
           return fallback&.call unless entry.wait_for_change?(changed, deadline)
         end
       end
 
       def signal_changed?(signal, observed, deadline)
-        timeout = deadline - Clock.now if deadline
+        timeout = Clock.remaining(deadline)
         return false if timeout && !timeout.positive?
 
         timed_out = Object.new

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

@@ -6,6 +6,8 @@ module Farce
   # @!visibility private
   module Internal # :nodoc: all
     class Vector < UnsharedVector
+      def self.new_for_modes(source) = new(source, compare_by_identity: true)
+
       def initialize(source = nil, **)
         source.each { check_value(it) } if source.is_a?(Array)
         super

data/lib/farce/engine/shared/weak_atom/base.rb

@@ -146,7 +146,7 @@ module Farce
       def with_value(timeout)
         deadline = timeout_deadline(timeout)
         result = TIMED_OUT
-        @lock.update(timeout: remaining_timeout(deadline)) do
+        @lock.update(timeout: Clock.remaining(deadline)) do
           result = yield
           nil
         end
@@ -158,11 +158,12 @@ module Farce
         loop do
           generation = @changes.value
           current    = read_value
-          return current if non_nil ? !current.nil? : !values_equal?(current, expected)
+          return current if non_nil ? !current.nil? :
+            Internal.value_changed?(current, expected, compare_by_identity?)
           # Detect recursive waits without waiting for another owner's update.
           @lock.get(timeout: 0)
-          return fallback&.call if remaining_timeout(deadline)&.zero?
-          @changes.wait_until_changed(generation, timeout: remaining_timeout(deadline))
+          return fallback&.call if Clock.remaining(deadline)&.zero?
+          @changes.wait_until_changed(generation, timeout: Clock.remaining(deadline))
         end
       end
 
@@ -177,12 +178,6 @@ module Farce
         raise ArgumentError, "timeout must be finite and non-negative" unless timeout.finite? && !timeout.negative?
         Clock.now + timeout
       end
-
-      def remaining_timeout(deadline)
-        return unless deadline
-        remaining = deadline - Clock.now
-        remaining.negative? ? 0 : remaining
-      end
     end
     private_constant :WeakAtomBase
   end