farce 0.0.1.alpha2-x86_64-linux-gnu

data/lib/farce/engine/jruby.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "jruby"
+require "java"
+
+# Load wait helpers before worker threads can contend or be canceled.
+require "farce/internal/reservation_waiting"
+require "farce/engine/jruby/lease_waiting"
+require "farce/engine/shared"
+require "farce/engine/jvm"
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    include Autoloads["#{__dir__}/jruby"]
+
+    Lock = Mutex
+
+    autoload :WeakMap,         "farce/engine/shared/unshared_weak_map"
+    autoload :WeakKeyMap,      "farce/engine/shared/unshared_weak_map"
+    autoload :WeakValueMap,    "farce/engine/shared/unshared_weak_map"
+    autoload :LFUMap,          "farce/engine/jruby/bounded_map"
+    autoload :LRUMap,          "farce/engine/jruby/bounded_map"
+    autoload :ShareableLFUMap, "farce/engine/jruby/bounded_map"
+    autoload :ShareableLRUMap, "farce/engine/jruby/bounded_map"
+    autoload :StrictLFUMap,    "farce/engine/jruby/bounded_map"
+    autoload :StrictLRUMap,    "farce/engine/jruby/bounded_map"
+
+    java_import org.jruby.RubyProc
+    java_import org.jruby.runtime.Block
+
+    def native_ractors? = false
+
+    def prepare_mutable_numeric(klass) = klass.include MutableNumericCopy
+
+    # Fibers expose their backing thread through Thread.current.
+    def storage_thread(thread) = JRuby.reference(thread).getFiberCurrentThread
+
+    def rebind(proc, new_self, lambda)
+      # Proc#dup shares its binding. Copy the frame before changing the receiver,
+      # while retaining the dynamic scope that owns captured local variables.
+      jproc    = ref(proc)
+      block    = jproc.get_block.clone_block_and_frame
+      self_ref = ref(new_self)
+      binding  = block.get_binding
+
+      binding.set_self(self_ref)
+      binding.get_frame.set_self(self_ref)
+
+      lambda = proc.lambda? if lambda.nil?
+      type = lambda ? Block::Type::LAMBDA : Block::Type::PROC
+      rebound = RubyProc.new_proc(jproc.get_runtime, jproc.get_type, block, type, nil, -1)
+      jproc.copy_instance_variables_into(ref(rebound).get_instance_variables)
+      rebound
+    end
+
+    private
+
+    def ref(obj) = JRuby.reference(obj)
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce/engine/jvm/types"
+require "farce/engine/shared/weak_map/reference"
+
+module Farce
+  module Internal
+    # Weak cell references in a registry whose iterator permits removal.
+    # JRuby's ObjectSpace::WeakMap iterator fails when its registry changes.
+    class ConcurrentWeakRegistry
+      Holder = Data.define(:reference)
+      private_constant :Holder
+
+      def initialize
+        @entries = JVMContainers::ConcurrentHashMap.new
+        @sweep = nil
+      end
+
+      def []=(token, entry)
+        @entries.put(token, Holder.new(UnsharedWeakMapWeakReference.for(entry)))
+        sweep_one
+        entry
+      end
+
+      def delete(token) = @entries.remove(token)
+
+      def each_value
+        return enum_for(__method__) unless block_given?
+        iterator = @entries.entrySet.iterator
+        while iterator.hasNext
+          entry = iterator.next
+          alive, cell = entry.getValue.reference.read
+          if alive
+            yield cell
+          else
+            @entries.remove(entry.getKey, entry.getValue)
+          end
+        end
+        self
+      end
+
+      def values = each_value.to_a
+
+      def sweep_one
+        @sweep = @entries.entrySet.iterator unless @sweep&.hasNext
+        return unless @sweep.hasNext
+        entry = @sweep.next
+        return if entry.getValue.reference.read.first
+        @entries.remove(entry.getKey, entry.getValue)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce/engine/jvm/types"
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    class Counter < Numeric
+      attr_reader :initial
+
+      def initialize(value = 0)
+        raise "Counter is already initialized" if defined?(@counter)
+        check_frozen!
+        raise TypeError, "initial value must be an Integer" unless value.is_a?(Integer)
+
+        @signal = Signal.new
+        @initial = value
+        @counter = JVMContainers::AtomicLong.new(value)
+        super()
+      end
+
+      def get = @counter.get
+
+      def store(value)
+        check_frozen!
+        raise TypeError, "value must be an Integer" unless value.is_a?(Integer)
+
+        @counter.set(value)
+        @signal.broadcast
+        value
+      end
+
+      def swap(value)
+        check_frozen!
+        raise TypeError, "value must be an Integer" unless value.is_a?(Integer)
+
+        @counter.getAndSet(value).tap { @signal.broadcast }
+      end
+
+      def add(delta = 1)
+        check_frozen!
+        raise TypeError, "delta must be an Integer" unless delta.is_a?(Integer)
+
+        @counter.addAndGet(delta).tap { @signal.broadcast }
+      end
+
+      def compare_and_set(expected_value, new_value)
+        check_frozen!
+        raise TypeError, "expected value must be an Integer" unless expected_value.is_a?(Integer)
+        raise TypeError, "replacement value must be an Integer" unless new_value.is_a?(Integer)
+
+        @counter.compareAndSet(expected_value, new_value).tap { @signal.broadcast }
+      end
+
+      def subtract(delta = 1)
+        check_frozen!
+        raise TypeError, "delta must be an Integer" unless delta.is_a?(Integer)
+
+        @counter.addAndGet(-delta).tap { @signal.broadcast }
+      end
+
+      def increment(delta = 1)
+        check_frozen!
+        unless delta.is_a?(Integer)
+          delta = Integer(delta)
+          check_frozen!
+        end
+        @counter.addAndGet(delta).tap { @signal.broadcast }
+        self
+      end
+
+      def decrement(delta = 1)
+        check_frozen!
+        unless delta.is_a?(Integer)
+          delta = Integer(delta)
+          check_frozen!
+        end
+        @counter.addAndGet(-delta).tap { @signal.broadcast }
+        self
+      end
+
+      alias value get
+      alias value= store
+
+      def change_signal = @signal
+
+      private
+
+      def check_frozen!
+        raise FrozenError.new("can't modify frozen #{self.class}", receiver: self) if frozen?
+      end
+
+      def initialize_copy(other)
+        @signal = Signal.new
+        @initial = other.initial
+        @counter = JVMContainers::AtomicLong.new(other.value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    module JVMExtension
+      jar = File.expand_path("farce.jar", __dir__)
+      unless File.file?(jar)
+        raise LoadError, "Farce's Java extension is missing; run rake java:compile in the source checkout"
+      end
+
+      if RUBY_ENGINE == "jruby"
+        require "java"
+        require jar
+        BoundedMap    = Java::OrgFarce::BoundedMap
+        PriorityKey   = Java::OrgFarce::PriorityKey
+        PriorityQueue = Java::OrgFarce::PriorityQueue
+        QueueFailure  = Java::OrgFarce::PriorityQueue::Failure
+        QueueSignal   = Java::OrgFarce::QueueSignal
+      else
+        Java.add_to_classpath(jar)
+        BoundedMap    = Java.type("org.farce.BoundedMap")
+        PriorityKey   = Java.type("org.farce.PriorityKey")
+        PriorityQueue = Java.type("org.farce.PriorityQueue")
+        QueueFailure  = Java.type("org.farce.PriorityQueue$Failure")
+        QueueSignal   = Java.type("org.farce.QueueSignal")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce/engine/jvm/types"
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    class Flag
+      def initialize(value = false) # rubocop:disable Style/OptionalBooleanParameter
+        raise "Flag is already initialized" if defined?(@reference)
+        check_frozen!
+        @reference = JVMContainers::AtomicBoolean.new(validate_boolean(value, "initial value"))
+      end
+
+      def value = @reference.get
+
+      def set # rubocop:disable Naming/PredicateMethod
+        check_frozen!
+        @reference.set(true)
+        true
+      end
+
+      def unset # rubocop:disable Naming/PredicateMethod
+        check_frozen!
+        @reference.set(false)
+        false
+      end
+
+      def store(value)
+        check_frozen!
+        value = validate_boolean(value, "value")
+        @reference.set(value)
+        value
+      end
+
+      def swap(value)
+        check_frozen!
+        value = validate_boolean(value, "value")
+        @reference.getAndSet(value)
+      end
+
+      def compare_and_set(expected_value, replacement_value)
+        check_frozen!
+        expected_value    = validate_boolean(expected_value, "expected value")
+        replacement_value = validate_boolean(replacement_value, "replacement value")
+        @reference.compareAndSet(expected_value, replacement_value)
+      end
+
+      def toggle
+        check_frozen!
+        loop do
+          current = @reference.get
+          replacement = !current
+          return replacement if @reference.compareAndSet(current, replacement)
+        end
+      end
+
+      alias get value
+      alias value= store
+
+      private
+
+      def check_frozen!
+        raise FrozenError.new("can't modify frozen #{self.class}", receiver: self) if frozen?
+      end
+
+      def validate_boolean(value, name)
+        return value if value.equal?(true) || value.equal?(false)
+        raise ArgumentError, "#{name} must be true or false"
+      end
+
+      def initialize_copy(other)
+        @reference = JVMContainers::AtomicBoolean.new(other.value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce/engine/jvm/types"
+require "farce/engine/jvm/extension"
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    # Java owns the lock, ordered buckets, FIFO links, and cancellation index.
+    # Ruby callbacks retain Ruby comparison, identity, and notification semantics.
+    class PriorityQueue
+      include Freeze::Unfreezable
+
+      Box                 = Struct.new(:value)
+      INITIALIZATION_LOCK = Mutex.new
+      JAVA_CAPACITY_MAX   = (1 << 63) - 1
+      IDENTITY            = ->(box) { JVMContainers.identity_token(box.value).to_s }
+      EQUAL               = ->(stored, requested) { stored.value == requested.value }
+      IDENTICAL           = ->(stored, requested) { JVMContainers.identical?(stored.value, requested.value) }
+      MATCH               = ->(stored, requested) { requested.value === stored.value } # rubocop:disable Style/CaseEquality
+
+      COMPARATOR = JVMExtension::PriorityKey.comparator(JVMContainers.comparator do |left, right|
+        JVMContainers.compare(left.value, right.value)
+      end)
+
+      SNAPSHOT = lambda do |key|
+        value = JVMContainers.copy_frozen_string(key.getRubyKey.value)
+        JVMExtension::PriorityKey.new(Box.new(value), false, 0.0)
+      end
+
+      SCHEDULED = lambda do
+        next false unless Fiber.respond_to?(:scheduler)
+        next false if Fiber.current.respond_to?(:blocking?) && Fiber.current.blocking?
+
+        scheduler = Fiber.current_scheduler if Fiber.respond_to?(:current_scheduler)
+        scheduler ||= Fiber.scheduler
+        !scheduler.nil?
+      end
+
+      private_constant :Box, :INITIALIZATION_LOCK, :JAVA_CAPACITY_MAX,
+        :COMPARATOR, :SNAPSHOT, :IDENTITY, :EQUAL, :IDENTICAL, :MATCH, :SCHEDULED
+
+      def initialize(capacity: nil, signal: nil, track_age: false)
+        check_initialization
+        parsed_capacity = normalize_capacity(capacity)
+        raise TypeError, "signal must respond to #broadcast" unless signal.nil? || signal.respond_to?(:broadcast)
+        # A failed notification leaves storage unchanged. Defer asynchronous
+        # cancellation through notification and the Java commit it announces.
+        unless signal.nil?
+          committer = lambda do |operation|
+            Thread.handle_interrupt(INTERRUPT_MASK) do
+              signal.broadcast
+              operation.run
+            end
+          end
+        end
+        java_capacity = parsed_capacity ? [parsed_capacity, JAVA_CAPACITY_MAX].min : 0
+        # Subclasses may override broadcast and must retain callback semantics.
+        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)
+        INITIALIZATION_LOCK.synchronize do
+          Thread.handle_interrupt(INTERRUPT_MASK) do
+            check_initialization
+            @capacity = parsed_capacity
+            @core = core
+            JVMContainers.freeze_object(self)
+          end
+        end
+      end
+
+      def push(priority, value)
+        core = storage
+        if Float === priority
+          core.pushFloat(priority, Box.new(priority), Box.new(value))
+        else
+          core.push(key(priority), Box.new(value))
+        end
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def pop(&fallback) = read(0, false, nil, fallback)
+      def pop_last(&fallback) = read(0, true, nil, fallback)
+
+      def pop_before(latest_priority, &fallback)
+        return read(0, false, key(latest_priority), fallback) unless Float === latest_priority
+
+        result = storage.readBefore(latest_priority, Box.new(latest_priority))
+        result.nil? ? fallback&.call : result.value
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def peek(&fallback)                  = read(1, false, nil, fallback)
+      def peek_last(&fallback)             = read(1, true, nil, fallback)
+      def peek_priority(&fallback)         = read(2, false, nil, fallback)
+      def peek_last_priority(&fallback)    = read(2, true, nil, fallback)
+      def delete(priority, value)          = remove(priority, value, 0)
+      def delete_identity(priority, value) = remove(priority, value, 1)
+      def delete_match(priority, pattern)  = remove(priority, pattern, 2)
+
+      def size
+        storage.size
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def empty? = size.zero?
+
+      def capacity
+        storage
+        @capacity
+      end
+
+      def closed?
+        storage.isClosed
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def sealed?
+        storage.isSealed
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def age_tracking?      = storage.isAgeTracking
+      def generation         = JVMContainers.nullable(storage.generation)
+      def oldest_enqueued_at = JVMContainers.nullable(storage.oldestEnqueuedAt)
+      def oldest_age         = JVMContainers.nullable(storage.oldestAge)
+
+      def clear
+        storage.clear
+        self
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def close
+        storage.close
+        self
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def seal
+        storage.seal
+        self
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def initialize_copy(_other)
+        raise TypeError, "priority queues cannot be copied"
+      end
+
+      private
+
+      def check_initialization
+        raise "priority queue is already initialized" if defined?(@core)
+        raise FrozenError, "can't modify frozen #{self.class}" if JVMContainers.frozen_object?(self)
+      end
+
+      def storage
+        raise "priority queue is not initialized" unless defined?(@core) && @core
+
+        @core
+      end
+
+      def key(priority)
+        floating = Float === priority
+        JVMExtension::PriorityKey.new(Box.new(priority), floating, floating ? priority : 0.0,
+          String === priority)
+      end
+
+      def read(kind, last, cutoff, fallback)
+        result = storage.read(kind, last, cutoff)
+        result.nil? ? fallback&.call : result.value
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def remove(priority, value, kind)
+        storage.removeValue(key(priority), Box.new(value), kind)
+      rescue JVMExtension::QueueFailure => e
+        raise_failure(e)
+      end
+
+      def raise_failure(error)
+        klass = case error.getCode
+                when 2 then ::Farce::ClosedQueueError
+                when 4 then ::Farce::SealedQueueError
+                else ThreadError
+                end
+        raise klass, error.getMessage
+      end
+
+      def normalize_capacity(value)
+        return nil if value.nil?
+
+        unless JVMContainers.is_a?(value, Integer)
+          raise TypeError, "capacity must be an Integer or nil" unless value.respond_to?(:to_int)
+
+          value = value.to_int
+        end
+        raise TypeError, "capacity must be an Integer or nil" unless JVMContainers.is_a?(value, Integer)
+        raise ArgumentError, "capacity must be positive or nil" unless value.positive?
+
+        value
+      end
+    end
+  end
+end