farce 0 → 0.1.0

data/lib/farce/engine/truffleruby/native/unsafe_tree_map.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce/engine/truffleruby/native/ordered_array_support"
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    # Unsynchronized ordered map for callers that provide their own ownership.
+    # Entries live in one sorted Array and are located by binary search.
+    class UnsafeTreeMap
+      include TruffleOrderedArraySupport
+
+      INITIALIZATION_LOCK = Mutex.new
+      private_constant :INITIALIZATION_LOCK
+
+      Entry = Struct.new(:key, :value)
+      private_constant :Entry
+
+      class State
+        attr_accessor :operation_owner, :revision
+        attr_reader :entries, :lock
+
+        def initialize(lock:)
+          @entries         = []
+          @lock            = lock
+          @operation_owner = nil
+          @revision        = 0
+        end
+      end
+      private_constant :State
+
+      def initialize(entries = nil)
+        ensure_initializable!
+        entries  = normalize_entries(entries)
+        prepared = State.new(lock: operation_lock)
+        entries&.each { |key, value| stage_store(prepared, key, value) }
+        commit_initialization(prepared)
+      end
+
+      def initialize_copy(_other)
+        raise TypeError, "tree maps cannot be copied"
+      end
+
+      def freeze
+        state = @freeze_state
+        return primitive_freeze(self) unless synchronized? && state
+
+        state.set
+        self
+      end
+
+      def frozen?
+        state = @freeze_state
+        synchronized? && state ? state.value : primitive_frozen?(self)
+      end
+
+      def prepare_key(key) = canonical_ordered_key(key)
+
+      def [](key)
+        key = canonical_ordered_key(key)
+        state = initialized_state
+        with_map_operation(state, mutation: false) do
+          index, found = locate_key(state.entries, key)
+          state.entries[index].value if found
+        end
+      end
+
+      def fetch(*arguments)
+        unless arguments.length.between?(1, 2)
+          raise ArgumentError, "wrong number of arguments (given #{arguments.length}, expected 1..2)"
+        end
+
+        original_key, default = arguments
+        key = canonical_ordered_key(original_key)
+        default_given = arguments.length == 2
+        warn "block supersedes default value argument", uplevel: 1 if block_given? && default_given
+        state = initialized_state
+        entry = with_map_operation(state, mutation: false) do
+          index, found = locate_key(state.entries, key)
+          state.entries[index] if found
+        end
+        return entry.value if entry
+        return yield(original_key) if block_given?
+        return default if default_given
+
+        raise KeyError.new(
+          "key not found: #{original_key.inspect}",
+          receiver: self,
+          key:      original_key,
+        )
+      end
+
+      def key?(key)
+        key = canonical_ordered_key(key)
+        state = initialized_state
+        with_map_operation(state, mutation: false) do
+          _, found = locate_key(state.entries, key)
+          found
+        end
+      end
+
+      def getkey(key)
+        key = canonical_ordered_key(key)
+        state = initialized_state
+        with_map_operation(state, mutation: false) do
+          index, found = locate_key(state.entries, key)
+          state.entries[index].key if found
+        end
+      end
+
+      def each
+        return enum_for(__method__) { size } unless block_given?
+
+        state = initialized_state
+        entries = with_map_operation(state, mutation: false) do
+          state.entries.map { [it.key, it.value] }
+        end
+        entries.each { yield it }
+        self
+      end
+
+      def each_live
+        return enum_for(__method__) { size } unless block_given?
+
+        state    = initialized_state
+        index    = 0
+        last_key = nil
+        revision = nil
+        started  = false
+
+        loop do
+          pair = with_map_operation(state, mutation: false) do
+            if started && revision != state.revision
+              index, found = locate_key(state.entries, last_key)
+              index += 1 if found
+            end
+            entry = state.entries[index]
+            next unless entry
+
+            index   += 1
+            last_key = entry.key
+            revision = state.revision
+            [entry.key, entry.value]
+          end
+          break unless pair
+          started = true
+          yield pair
+        end
+        self
+      end
+
+      def []=(key, value)
+        key = canonical_ordered_key(key)
+        state = initialized_state
+        with_map_operation(state, mutation: true) do
+          index, found = locate_key(state.entries, key)
+          if found
+            ensure_mutation_still_allowed!
+            without_async_interrupts do
+              state.entries[index].value = value
+              state.revision += 1
+            end
+          else
+            pending = Entry.new(key, value)
+            without_async_interrupts do
+              index, duplicate = with_interruptible_callbacks do
+                locate_key(state.entries, key)
+              end
+              raise "key comparator changed during insertion" if duplicate
+              ensure_mutation_still_allowed!
+              state.entries.insert(index, pending)
+              state.revision += 1
+            end
+          end
+          value
+        end
+      end
+
+      def delete(key)
+        key = canonical_ordered_key(key)
+        state = initialized_state
+        with_map_operation(state, mutation: true) do
+          index, found = locate_key(state.entries, key)
+          next unless found
+
+          ensure_mutation_still_allowed!
+          without_async_interrupts do
+            state.revision += 1
+            state.entries.delete_at(index).value
+          end
+        end
+      end
+
+      def first_key
+        state = initialized_state
+        with_map_operation(state, mutation: false) { state.entries.first&.key }
+      end
+
+      def last_key
+        state = initialized_state
+        with_map_operation(state, mutation: false) { state.entries.last&.key }
+      end
+
+      def shift
+        state = initialized_state
+        with_map_operation(state, mutation: true) do
+          entry = state.entries.first
+          next unless entry
+
+          pair = [entry.key, entry.value]
+          without_async_interrupts do
+            state.entries.shift
+            state.revision += 1
+          end
+          pair
+        end
+      end
+
+      def pop
+        state = initialized_state
+        with_map_operation(state, mutation: true) do
+          entry = state.entries.last
+          next unless entry
+
+          pair = [entry.key, entry.value]
+          without_async_interrupts do
+            state.entries.pop
+            state.revision += 1
+          end
+          pair
+        end
+      end
+
+      def size
+        state = initialized_state
+        with_map_operation(state, mutation: false) { state.entries.length }
+      end
+      alias length size
+
+      def empty?
+        state = initialized_state
+        with_map_operation(state, mutation: false) { state.entries.empty? }
+      end
+
+      def clear
+        state = initialized_state
+        with_map_operation(state, mutation: true) do
+          without_async_interrupts do
+            unless state.entries.empty?
+              state.entries.clear
+              state.revision += 1
+            end
+          end
+          self
+        end
+      end
+
+      private
+
+      def synchronized? = false
+      def operation_lock = nil
+
+      def with_map_operation(state, mutation:)
+        ensure_mutation_still_allowed! if mutation
+        current = Fiber.current
+        raise "container cannot be modified during comparison" if state.operation_owner
+
+        begin
+          without_async_interrupts { state.operation_owner = current }
+          yield
+        ensure
+          without_async_interrupts { state.operation_owner = nil }
+        end
+      end
+
+      def ensure_mutation_still_allowed!
+        raise FrozenError, "can't modify frozen tree map" if primitive_frozen?(self)
+      end
+
+      def ensure_initializable!
+        raise "tree map is already initialized" if @state
+        raise FrozenError, "can't modify frozen tree map" if primitive_frozen?(self)
+      end
+
+      def commit_initialization(prepared)
+        INITIALIZATION_LOCK.synchronize do
+          raise "tree map is already initialized" if @state
+          raise FrozenError, "can't modify frozen tree map" if primitive_frozen?(self)
+
+          without_async_interrupts do
+            @state        = prepared
+            @freeze_state = Flag.new(false) if synchronized?
+            primitive_freeze(self) if synchronized?
+          end
+        end
+        self
+      end
+
+      def initialized_state
+        @state || raise("uninitialized tree map")
+      end
+
+      def normalize_entries(entries)
+        return if entries.nil?
+        entries = Hash.try_convert(entries)
+        return entries if entries
+        raise TypeError, "entries must be a Hash or respond to #to_hash"
+      end
+
+      def stage_store(state, key, value)
+        key = canonical_ordered_key(key)
+        index, found = locate_key(state.entries, key)
+        if found
+          ensure_initializable!
+          state.entries[index].value = value
+          return
+        end
+
+        pending = Entry.new(key, value)
+        index, duplicate = locate_key(state.entries, key)
+        raise "key comparator changed during insertion" if duplicate
+        ensure_initializable!
+        state.entries.insert(index, pending)
+      end
+
+      def locate_key(entries, key)
+        low = 0
+        high = entries.length
+        while low < high
+          middle = (low + high) / 2
+          order = compare_keys(key, entries[middle].key)
+          return [middle, true] if order.zero?
+          order.negative? ? high = middle : low = middle + 1
+        end
+        [low, false]
+      end
+
+      def compare_keys(left, right)
+        result = left <=> right
+        raise ArgumentError, "key comparison failed" if result.nil?
+        # rb_cmpint calls #> and #< when <=> returns a non-Integer object.
+        return 1 if result > 0 # rubocop:disable Style/NumericPredicate
+        return -1 if result < 0 # rubocop:disable Style/NumericPredicate
+        0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    class Signal
+      include Freeze::Unfreezable
+
+      TIMED_OUT = Object.new.freeze
+      private_constant :TIMED_OUT
+
+      def initialize
+        @generation     = TruffleRuby::AtomicReference.new(0)
+        @num_waiting    = TruffleRuby::AtomicReference.new(0)
+        @condition      = ConditionVariable.new
+        @broadcast_lock = Mutex.new
+        Freeze.publish(self)
+      end
+
+      def generation  = @generation.get
+      def num_waiting = @num_waiting.get
+
+      def broadcast
+        @broadcast_lock.synchronize do
+          generation = @generation.get + 1
+          @generation.set(generation)
+          @condition.broadcast
+          generation
+        end
+      end
+
+      def wait(observed = nil, timeout: nil, &fallback)
+        validate_generation(observed) unless observed.nil?
+        deadline = timeout_deadline(timeout)
+
+        result = @broadcast_lock.synchronize do
+          observed ||= generation
+          waiting = false
+          begin
+            loop do
+              current = generation
+              break current unless current == observed
+
+              remaining = deadline - Clock.now if deadline
+              break TIMED_OUT if remaining && !remaining.positive?
+              @num_waiting.set(@num_waiting.get + 1) unless waiting
+              waiting = true
+              @condition.wait(@broadcast_lock, remaining)
+            end
+          ensure
+            @num_waiting.set(@num_waiting.get - 1) if waiting
+          end
+        end
+
+        TIMED_OUT.equal?(result) ? fallback&.call : result
+      end
+
+      private
+
+      def validate_generation(generation)
+        raise TypeError, "generation must be an Integer" unless generation.is_a?(::Integer)
+      end
+
+      def timeout_deadline(timeout)
+        return if timeout.nil?
+
+        timeout = Float(timeout)
+        if !timeout.finite? || timeout.negative?
+          raise ArgumentError, "timeout must be a finite, non-negative number or nil"
+        end
+        Clock.now + timeout
+      end
+    end
+  end
+end

data/lib/farce/engine/truffleruby.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce/engine/shared"
+
+# Concurrent lexical lookup can expose this module before its methods are defined.
+# Load it before reservation or lease waits can first run on competing threads.
+require "farce/internal/lease_waiting"
+
+require "farce/engine/jvm" unless TruffleRuby.native?
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    include Autoloads["#{__dir__}/truffleruby"]
+
+    require "farce/engine/shared/portable_bounded_map"
+
+    autoload :WeakMap,      "farce/engine/shared/unshared_weak_map"
+    autoload :WeakKeyMap,   "farce/engine/shared/unshared_weak_map"
+    autoload :WeakValueMap, "farce/engine/shared/unshared_weak_map"
+
+    LFUMap          = PortableLFUMap
+    LRUMap          = PortableLRUMap
+    ShareableLFUMap = StrictLFUMap = PortableStrictLFUMap
+    ShareableLRUMap = StrictLRUMap = PortableStrictLRUMap
+
+    if TruffleRuby.native?
+      path = "farce/engine/truffleruby/native"
+      autoload :UnsafeTreeMap,    "#{path}/unsafe_tree_map"
+      autoload :PriorityQueue,    "#{path}/priority_queue"
+      autoload :ShareableTreeMap, "#{path}/tree_map"
+      autoload :TreeMap,          "#{path}/tree_map"
+      autoload :MutableTreeMap,   "#{path}/tree_map"
+      autoload :Counter,          "#{path}/counter"
+      autoload :Flag,             "#{path}/flag"
+    end
+
+    def native_ractors? = false
+
+    # @api private
+    # TruffleRuby probes this additional hook before using _dump.
+    def marshal_protocol_method?(name)
+      name == :__custom_marshal__ || MarshalSupport.protocol_method?(name)
+    end
+
+    # Autoload on TruffleRuby is not thread-safe: A thread can see the module before its methods are defined.
+    # So lets eager load all autoloaded constants, except the ones that would trigger a configuration freeze.
+    # These use constant assignment anyway, so they are safe to load lazily.
+    def finalize_engine
+      skip     = %i[FROZEN_CONFIG MainScheduler ParallelScheduler]
+      seen     = ::Set.new.compare_by_identity
+      autoload = lambda do |namespace|
+        namespace.constants(false).each do |const|
+          next if skip.include?(const)
+          result = namespace.const_get(const, false)
+          next unless Module === result && !seen.include?(result)
+          seen << result
+          autoload[result]
+        end
+      end
+
+      autoload[Farce]
+      autoload[Internal]
+    end
+
+    def rebind(proc, new_self, lambda)
+      binding          = new_self.instance_eval { binding() }
+      prefix           = "__rebind_#{proc.object_id}"
+      signature        = Array.new(proc.parameters.size)
+      call_signature   = []
+      optional         = []
+      after_optional   = []
+      keyword_args     = []
+      keyword_optional = []
+      extra_lines      = []
+      keyword_rest     = nil
+      rest             = nil
+      block            = nil
+
+      proc.parameters(lambda: true).each_with_index do |(type, name), index|
+        # simplecov:disable
+        if name.nil? || name == :_ || name == :* || name == :** || name == "&" || name =~ /^_\d+$/
+          name = :"#{prefix}_#{index}"
+        end
+        case type
+        when :req
+          signature[index] = name
+          required = optional.any? ? after_optional : call_signature
+          required << name
+        when :opt
+          signature[index] = "#{name} = UNDEFINED"
+          optional << name
+        when :rest
+          rest = signature[index] = "*#{name}"
+        when :key
+          signature[index] = "#{name}: UNDEFINED"
+          keyword_optional << name
+        when :keyreq
+          keyword_args << signature[index] = "#{name}:"
+        when :keyrest
+          keyword_rest = signature[index] = "**#{name}"
+        when :block
+          block = signature[index] = "&#{name}"
+        else
+          raise "unexpected parameter type: #{type}"
+        end
+      end
+      # simplecov:enable
+
+      if optional.any?
+        extra_lines << "#{prefix}_args = []"
+        call_signature << "*#{prefix}_args"
+        optional.each { extra_lines << "#{prefix}_args << #{it} unless UNDEFINED.equal?(#{it})" }
+      end
+
+      call_signature << rest if rest
+      call_signature += keyword_args if keyword_args.any?
+
+      if keyword_optional.any?
+        extra_lines << "#{prefix}_kwargs = {}"
+        call_signature << "**#{prefix}_kwargs"
+        keyword_optional.each do |arg|
+          extra_lines << "#{prefix}_kwargs[#{arg.inspect}] = #{arg} unless UNDEFINED.equal?(#{arg})"
+        end
+      end
+
+      call_signature << keyword_rest if keyword_rest
+      call_signature << block if block
+
+      Module.new do
+        method_name = proc.inspect
+        define_method(method_name, proc)
+        binding.local_variable_set(:"#{prefix}_unbound", instance_method(method_name))
+      end
+
+      lambda = proc.lambda? if lambda.nil?
+
+      binding.eval <<~RUBY
+        #{lambda ? "lambda" : "proc "} do #{"|#{signature.join(", ")}|" unless signature.empty?}
+          #{extra_lines.join("\n  ")}
+          #{prefix}_unbound.bind_call(self, #{call_signature.join(", ")})
+        end
+      RUBY
+    end
+  end
+end