farce 0.0.1.alpha2-x86_64-linux-gnu

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

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    class Queue
+      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 }
+        Freeze.publish(self)
+      end
+
+      def pop(timeout: nil)
+        timeout_at = timeout_at(timeout)
+        # Observing an empty queue is sufficient for a nonblocking miss. Avoid
+        # constructing a ThreadError (and its backtrace) just to return nil.
+        if timeout_at&.zero? && @queue.empty?
+          raise_closed if closed?
+          return block_given? ? yield : nil
+        end
+
+        while true
+          begin
+            result = tracked_pop
+            raise ThreadError if nil.equal?(result) && @queue.closed?
+            broadcast
+            return NIL_VALUE.equal?(result) ? nil : result
+          rescue ThreadError
+            remaining = remaining_timeout(timeout_at)
+            return block_given? ? yield : nil unless wait_pop(timeout: remaining)
+          end
+        end
+      end
+
+      def push(item, timeout: nil)
+        check_value(item)
+        item = NIL_VALUE if nil.equal?(item)
+
+        unless capacity
+          tracked_push(item)
+          broadcast
+          return true
+        end
+
+        timeout_at = timeout_at(timeout)
+        if timeout_at&.zero? && @queue.size >= @queue.max
+          raise_unwritable if sealed?
+          return false
+        end
+        while true
+          begin
+            tracked_push(item, non_block: true)
+            broadcast
+            return true
+          rescue ThreadError
+            return false unless wait_push(timeout: remaining_timeout(timeout_at))
+          end
+        end
+      end
+
+      def wait_pop(timeout: nil) = wait(timeout) { size.positive? }
+
+      def try_pop(&) = pop(timeout: 0, &)
+
+      def try_push(item) = push(item, timeout: 0)
+
+      def wait_push(timeout: nil)
+        raise_unwritable if sealed?
+        return true unless capacity
+        wait(timeout) do
+          raise_unwritable if sealed?
+          size < capacity
+        end
+      end
+
+      def close
+        @lifecycle[:lock].synchronize do
+          changed = !@lifecycle[:hard_closed]
+          @lifecycle[:hard_closed] = true
+          @queue.close
+          bump_generation if changed
+        end
+        broadcast
+        self
+      end
+
+      def seal
+        @lifecycle[:lock].synchronize do
+          changed = !@queue.closed?
+          @queue.close
+          bump_generation if changed
+        end
+        broadcast
+        self
+      end
+
+      def clear
+        if @tracking
+          @tracking[:lock].synchronize do
+            changed = @queue.size.positive?
+            @queue.clear
+            @tracking[:timestamps].clear
+            @tracking[:generation] += 1 if changed
+          end
+        else
+          @queue.clear
+        end
+        broadcast
+        self
+      end
+
+      def num_waiting = @queue.num_waiting + @signal.num_waiting
+
+      Internal.delegate(self, :@queue, :size)
+
+      def sealed? = @queue.closed?
+
+      def closed?
+        @lifecycle[:hard_closed] || (@queue.closed? && @queue.empty?)
+      end
+
+      def age_tracking? = !@tracking.nil?
+      def generation = @tracking && @tracking[:lock].synchronize { @tracking[:generation] }
+
+      def oldest_enqueued_at
+        @tracking && @tracking[:lock].synchronize { @tracking[:timestamps].first }
+      end
+
+      def oldest_age
+        timestamp = oldest_enqueued_at
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) - timestamp if timestamp
+      end
+
+      private
+
+      def check_value(item)
+        raise Ractor::IsolationError, "value is not Ractor-shareable" unless Ractor.shareable?(item)
+      end
+
+      def tracked_push(item, non_block: false)
+        if @tracking
+          @tracking[:lock].synchronize do
+            result = non_block ? @queue.push(item, true) : @queue.push(item)
+            @tracking[:timestamps] << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            @tracking[:generation] += 1
+            result
+          end
+        else
+          non_block ? @queue.push(item, true) : @queue.push(item)
+        end
+      rescue ::ClosedQueueError
+        raise_unwritable
+      end
+
+      def tracked_pop
+        return @queue.pop(true) unless @tracking
+        @tracking[:lock].synchronize do
+          result = @queue.pop(true)
+          unless nil.equal?(result) && @queue.closed?
+            @tracking[:timestamps].shift
+            @tracking[:generation] += 1
+          end
+          result
+        end
+      end
+
+      def bump_generation
+        @tracking[:lock].synchronize { @tracking[:generation] += 1 } if @tracking
+      end
+
+      def normalize_timeout(timeout)
+        return nil if timeout.nil?
+        timeout = Float(timeout)
+        raise ArgumentError, "timeout must be non-negative" if timeout.negative?
+        raise ArgumentError, "timeout must be finite" unless timeout.finite?
+        raise ArgumentError, "timeout must be a number" if timeout.nan?
+        timeout
+      end
+
+      def wait(timeout)
+        timeout_at = timeout_at(timeout)
+
+        if timeout_at&.zero?
+          return true if yield
+          raise_closed if closed?
+          return false
+        end
+
+        while true
+          generation = @signal.generation
+          return true if yield
+          raise_closed if closed?
+          return false unless @signal.wait(generation, timeout: remaining_timeout(timeout_at))
+        end
+      end
+
+      def raise_closed
+        raise ::Farce::ClosedQueueError, "queue is closed"
+      end
+
+      def raise_unwritable
+        closed = closed?
+        error = closed ? ::Farce::ClosedQueueError : ::Farce::SealedQueueError
+        raise error, closed ? "queue is closed" : "queue is sealed"
+      end
+
+      def timeout_at(timeout)
+        return if timeout.nil?
+        timeout = normalize_timeout(timeout)
+        timeout.zero? ? 0 : Clock.timeout(timeout)
+      end
+
+      def remaining_timeout(timeout_at)
+        return unless timeout_at
+        return 0 if timeout_at.zero?
+        timeout = timeout_at - Clock.now
+        timeout.positive? ? timeout : 0
+      end
+
+      def broadcast = @signal.broadcast
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    module RactorMethods
+      STORAGE  = Storage::ThreadSafe.new
+      STORAGES = Storage::ThreadSafe.new
+
+      def with_storage(key)
+        key = key.to_s if key.is_a?(Symbol)
+        raise TypeError, "#{key.inspect} is not a symbol nor a string" unless key.is_a?(String)
+        storage = Ractor.main? ? STORAGE : STORAGES.store_if_absent(Ractor.current) { Storage::ThreadSafe.new }
+        yield(storage, key)
+      end
+
+      def new(...)
+        return super if is_a?(Class)
+        FakeRactor::NotMain.new(...)
+      end
+
+      def current = FakeRactor.current
+      def main    = FakeRactor::Main::INSTANCE
+
+      def main?
+        return true if Internal.autoload?(:FakeRactor)
+        FakeRactor.current.main?
+      end
+
+      def count
+        return 1 if Internal.autoload?(:FakeRactor)
+        FakeRactor::GROUPS.size + 1
+      end
+
+      def [](name)                   = with_storage(name) { _1[_2] }
+      def builtin?                   = false
+      def main_thread                = FakeRactor.main_thread
+      def make_shareable(object, **) = object
+      def receive(...)               = Ractor.current.receive(...)
+
+      def shareable?(object)
+        unless Kernel === object
+          begin
+            return object.__send__(:ractor_shareable?)
+          rescue NoMethodError => e
+            raise unless e.name == :ractor_shareable?
+            return true
+          end
+        end
+
+        object.respond_to?(:ractor_shareable?) ? object.ractor_shareable? : true
+      end
+
+      def shareable_lambda(**, &)    = Farce.rebind(lambda: true, **, &)
+      def shareable_proc(**, &)      = Farce.rebind(**, &)
+      def shim?                      = true
+      def store_if_absent(name, &)   = with_storage(name) { _1.store_if_absent(_2, &) }
+      def threads                    = FakeRactor.threads
+
+      def []=(name, value)
+        with_storage(name) { _1[_2] = value }
+      end
+
+      def select(...)
+        raise "TODO: not implemented"
+      end
+
+      alias recv receive
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    # @api private
+    # Rebindable implementation shared between JRuby and TruffleRuby engine support.
+    def rebindable?(proc)
+      return false unless proc.is_a?(Proc)
+      proc.inspect !~ /^#<Proc:0x[0-9a-f]+\(&:.*\) \(lambda\)>$/
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    # Preserve the unrestricted Atom backend for unshared internals.
+    class StrictAtom < Atom
+      def initialize(value = nil, **)
+        super(check_value(value), **)
+      end
+
+      def store(value, **, &)
+        check_frozen!
+        super(check_value(value), **, &)
+      end
+
+      def swap(value, **, &)
+        check_frozen!
+        super(check_value(value), **, &)
+      end
+
+      def wait_until_changed(expected, **, &) = super(check_value(expected), **, &)
+
+      def value=(value)
+        store(value)
+      end
+
+      def compare_and_set(expected, value, **)
+        check_frozen!
+        super(check_value(expected), check_value(value), **)
+      end
+
+      def store_if_absent(**)
+        raise LocalJumpError, "no block given" unless block_given?
+        check_frozen!
+        super do
+          value = yield
+          check_frozen!
+          check_value(value)
+        end
+      end
+
+      def update(**)
+        raise LocalJumpError, "no block given" unless block_given?
+        check_frozen!
+        super do |value|
+          replacement = yield(value)
+          check_frozen!
+          check_value(replacement)
+        end
+      end
+
+      def upsert(initial, **)
+        raise LocalJumpError, "no block given" unless block_given?
+        check_frozen!
+        super(check_value(initial), **) do |value|
+          replacement = yield(value)
+          check_frozen!
+          check_value(replacement)
+        end
+      end
+
+      private
+
+      def check_value(value)
+        return value if Ractor.shareable?(value)
+        raise Ractor::IsolationError, "value must be Ractor-shareable"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    module StrictMapValues
+      def self.included(base)
+        base.class_eval do
+          alias_method :assignment_prepared, :[]=
+          alias_method :get_prepared, :get
+          alias_method :store_prepared, :store
+          alias_method :swap_prepared, :swap
+          alias_method :update_prepared, :update
+          alias_method :wait_until_changed_prepared, :wait_until_changed
+        end
+        super
+      end
+
+      def initialize(initial_mapping = nil, **)
+        raise TypeError, "initial mapping must be a Hash" unless initial_mapping.nil? || initial_mapping.is_a?(Hash)
+        initial_mapping&.each { |key, value| check_pair(key, value) }
+        super
+      end
+
+      def [](key) = super(check_key(key))
+
+      def []=(key, value)
+        key = check_key(key)
+        super(key, check_value(value))
+      end
+
+      def get(key, **) = super(check_key(key), **)
+
+      def store(key, value, **)
+        key = check_key(key)
+        super(key, check_value(value), **)
+      end
+
+      def swap(key, value, **)
+        key = check_key(key)
+        super(key, check_value(value), **)
+      end
+
+      def key?(key)                   = super(check_key(key))
+      def delete(key)                 = super(check_key(key))
+      def getkey(key)                 = super(check_key(key))
+      def wait_until_non_nil(key, **) = super(check_key(key), **)
+
+      def fetch(*arguments, &)
+        arguments[0] = check_key(arguments.first) unless arguments.empty?
+        super
+      end
+
+      def store_if_absent(key, **)
+        raise LocalJumpError, "no block given" unless block_given?
+        super(check_key(key), **) { check_value(yield) }
+      end
+
+      def compare_and_set(key, expected, replacement, **)
+        super(check_key(key), check_value(expected), check_value(replacement), **)
+      end
+
+      def update(key, **)
+        raise LocalJumpError, "no block given" unless block_given?
+        super(check_key(key), **) { |value| check_value(yield(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)) }
+      end
+
+      def wait_until_changed(key, expected, **)
+        super(check_key(key), check_value(expected), **)
+      end
+
+      def normalize_external_key(key) = check_key(key)
+
+      private
+
+      def check_pair(key, value)
+        check_key(key)
+        check_value(value)
+      end
+
+      def check_key(key)
+        key = String.instance_method(:-@).bind_call(key) if String === key && !key.frozen? && !compare_keys_by_identity?
+        return key if Ractor.shareable?(key)
+        raise Ractor::IsolationError, "key must be Ractor-shareable"
+      end
+
+      def check_value(value)
+        return value if Ractor.shareable?(value)
+        raise Ractor::IsolationError, "value must be Ractor-shareable"
+      end
+    end
+    private_constant :StrictMapValues
+
+    class StrictMap < Map
+      include StrictMapValues
+    end
+
+    class StrictWeakKeyMap < WeakKeyMap
+      include StrictMapValues
+    end
+
+    class StrictWeakValueMap < WeakValueMap
+      include StrictMapValues
+    end
+
+    class StrictWeakMap < WeakMap
+      include StrictMapValues
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal # :nodoc: all
+    module StrictQueueValues
+      def push(value, *arguments, **options)
+        check_queue_value(value)
+        check_queue_value(options[:priority]) if options.key?(:priority)
+        super
+      end
+
+      def try_push(value, **options, &)
+        check_queue_value(value)
+        check_queue_value(options[:priority]) if options.key?(:priority)
+        super
+      end
+
+      private
+
+      def check_queue_value(value)
+        raise Ractor::IsolationError, "value is not Ractor-shareable" unless Ractor.shareable?(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    module StrictTreeMapValues
+      def initialize(entries = nil)
+        unless entries.nil? || entries.is_a?(Hash)
+          entries = entries.to_hash if entries.respond_to?(:to_hash)
+          raise TypeError, "entries must be a Hash or respond to #to_hash" unless entries.is_a?(Hash)
+        end
+        entries&.each { |key, value| check_tree_pair(key, value) }
+        super
+      end
+
+      def [](key) = super(check_tree_key(key))
+
+      def []=(key, value)
+        super(check_tree_key(key), check_tree_value(value))
+      end
+
+      def delete(key) = super(check_tree_key(key))
+      def getkey(key) = super(check_tree_key(key))
+      def key?(key)   = super(check_tree_key(key))
+
+      def fetch(*arguments, &)
+        check_tree_key(arguments.first) unless arguments.empty?
+        super
+      end
+
+      private
+
+      def check_tree_pair(key, value)
+        check_tree_key(key)
+        check_tree_value(value)
+      end
+
+      def check_tree_key(key)
+        return key if String === key || Ractor.shareable?(key)
+        raise Ractor::IsolationError, "key must be Ractor-shareable"
+      end
+
+      def check_tree_value(value)
+        return value if Ractor.shareable?(value)
+        raise Ractor::IsolationError, "value must be Ractor-shareable"
+      end
+    end
+    private_constant :StrictTreeMapValues
+
+    class StrictTreeMap < ShareableTreeMap
+      include StrictTreeMapValues
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal # :nodoc: all
+    # Transaction hooks for the JRuby and TruffleRuby map backends.
+    module TransactionMapBackend
+      def transaction_snapshot            = PortableTransaction.snapshot(self, :map)
+      def transaction_size_snapshot(size) = PortableTransaction::MapSizeEntry.new(self, size)
+      def transaction_pairs               = entries_snapshot
+
+      # Whether no native operations, key reservations, or clear are active.
+      # Commit calls this with the reservation and state mutexes already held.
+      def transaction_idle?
+        !@active_owner_fiber && !@active_owners && !@clearing_reservations && @reservations.empty?
+      end
+    end
+  end
+end