farce 0.0.1.alpha2-x86_64-linux-gnu

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

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    class UnsharedAtom
+      TIMED_OUT = Object.new.freeze
+      private_constant :TIMED_OUT
+
+      def initialize(value = nil, compare_by_identity: false)
+        if compare_by_identity != true && compare_by_identity != false
+          raise ArgumentError, "compare_by_identity must be a boolean"
+        end
+
+        @value               = value
+        @compare_by_identity = compare_by_identity
+        @mutex               = Mutex.new
+        @signal              = ConditionVariable.new
+        @updating            = false
+        @updating_fiber      = nil
+        @updating_thread     = nil
+        @version             = 0
+        @farce_frozen        = false
+      end
+
+      # @api private
+      def transaction_snapshot
+        PortableTransaction.snapshot(self, :atom)
+      end
+
+      def value = @mutex.synchronize { @value }
+
+      def freeze
+        @mutex.synchronize { @farce_frozen = true }
+        self
+      end
+
+      def frozen? = @mutex.synchronize { @farce_frozen }
+
+      def get(timeout: nil, &fallback)
+        result = with_available_value(timeout) { @value }
+        timed_out(result, fallback)
+      end
+
+      def store(new_value, timeout: nil, &fallback)
+        check_frozen!
+        result = with_available_value(timeout) do
+          check_frozen_locked!
+          @value = new_value
+          changed!
+          new_value
+        end
+        timed_out(result, fallback)
+      end
+
+      def swap(new_value, timeout: nil, &fallback)
+        check_frozen!
+        result = with_available_value(timeout) do
+          check_frozen_locked!
+          old_value = @value
+          @value = new_value
+          changed!
+          old_value
+        end
+        timed_out(result, fallback)
+      end
+
+      def store_if_absent(timeout: nil, &update)
+        raise LocalJumpError, "no block given" unless update
+        check_frozen!
+        deadline = timeout_deadline(timeout)
+
+        current = reserve(deadline) do
+          return @value unless @value.nil?
+        end
+        return if TIMED_OUT.equal?(current)
+
+        update_reserved(&update)
+      end
+
+      def compare_and_set(expected, new_value, timeout: nil)
+        check_frozen!
+        current = reserve(timeout_deadline(timeout))
+        return false if TIMED_OUT.equal?(current)
+
+        matched = false
+        begin
+          matches = values_equal?(current, expected)
+          check_frozen!
+          matched = matches
+        ensure
+          finish_update(new_value, changed: matched)
+        end
+        matched
+      end
+
+      def update(timeout: nil)
+        raise LocalJumpError, "no block given" unless block_given?
+        check_frozen!
+        deadline = timeout_deadline(timeout)
+
+        current = reserve(deadline)
+        return if TIMED_OUT.equal?(current)
+
+        update_reserved { yield(current) }
+      end
+
+      def upsert(initial_value, timeout: nil)
+        raise LocalJumpError, "no block given" unless block_given?
+        check_frozen!
+        deadline = timeout_deadline(timeout)
+
+        current = reserve(deadline) do
+          next unless @value.nil?
+
+          @value = initial_value
+          changed!
+          return initial_value
+        end
+        return if TIMED_OUT.equal?(current)
+
+        update_reserved { yield(current) }
+      end
+
+      def wait_until_changed(expected, timeout: nil, &fallback)
+        deadline = timeout_deadline(timeout)
+
+        loop do
+          current, version = @mutex.synchronize { [@value, @version] }
+          return current unless values_equal?(current, expected)
+
+          result = @mutex.synchronize do
+            next unless @version == version
+            reject_update_wait! if @updating
+            TIMED_OUT unless wait_for_signal(deadline)
+          end
+          return timed_out(result, fallback) if TIMED_OUT.equal?(result)
+        end
+      end
+
+      def wait_until_non_nil(timeout: nil, &) = wait_until_changed(nil, timeout:, &)
+      def compare_by_identity? = @compare_by_identity
+
+      alias value= store
+
+      private
+
+      def with_available_value(timeout)
+        deadline = timeout_deadline(timeout)
+
+        @mutex.synchronize do
+          while @updating
+            reject_update_wait!
+            return TIMED_OUT unless wait_for_signal(deadline)
+          end
+          yield
+        end
+      end
+
+      def reserve(deadline)
+        @mutex.synchronize do
+          while @updating
+            reject_update_wait!
+            return TIMED_OUT unless wait_for_signal(deadline)
+          end
+          check_frozen_locked!
+          yield if block_given?
+          @updating        = true
+          @updating_fiber  = Fiber.current
+          @updating_thread = Thread.current
+          @value
+        end
+      end
+
+      def update_reserved
+        changed = false
+        begin
+          result = yield
+          check_frozen!
+          changed = true
+          result
+        ensure
+          finish_update(result, changed:)
+        end
+      end
+
+      def finish_update(value, changed:)
+        @mutex.synchronize do
+          @value = value if changed
+          @version += 1 if changed
+          @updating        = false
+          @updating_fiber  = nil
+          @updating_thread = nil
+          @signal.broadcast
+        end
+      end
+
+      def changed!
+        @version += 1
+        @signal.broadcast
+      end
+
+      def check_frozen!
+        @mutex.synchronize { check_frozen_locked! }
+      end
+
+      def check_frozen_locked!
+        return unless @farce_frozen
+
+        raise FrozenError.new("can't modify frozen #{self.class}", receiver: self)
+      end
+
+      def timeout_deadline(timeout)
+        return unless timeout
+
+        timeout = Float(timeout)
+        raise ArgumentError, "timeout must be non-negative" if timeout.negative?
+        raise ArgumentError, "timeout must be finite"       if timeout.infinite?
+        raise ArgumentError, "timeout must be a number"     if timeout.nan?
+
+        Clock.now + timeout
+      end
+
+      def wait_for_signal(deadline)
+        return @signal.wait(@mutex) unless deadline
+
+        remaining = deadline - Clock.now
+        return false unless remaining.positive?
+
+        @signal.wait(@mutex, remaining)
+        true
+      end
+
+      def reject_update_wait!
+        raise ThreadError, "deadlock; recursive atom access during an update" if @updating_fiber.equal?(Fiber.current)
+
+        scheduler = Fiber.scheduler if Fiber.respond_to?(:scheduler)
+        return unless @updating_thread.equal?(Thread.current) && !scheduler
+
+        raise ThreadError, "deadlock; atom update is owned by another unscheduled fiber"
+      end
+
+      def timed_out(result, fallback)
+        return result unless TIMED_OUT.equal?(result)
+        fallback&.call
+      end
+
+      def values_equal?(left, right)
+        return left == right unless compare_by_identity?
+        left.equal?(right)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal # :nodoc: all
+    UnsharedPriorityQueue = PriorityQueue
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal # :nodoc: all
+    class UnsharedQueue < Queue
+      def initialize(capacity: 1024, fiber_wait: :auto, track_age: false)
+        raise ArgumentError, "fiber_wait must be :auto, :io, or :block" unless %i[auto io block].include?(fiber_wait)
+        super(capacity:, track_age:)
+      end
+
+      def fiber_wait = :auto
+
+      private def check_value(_item); end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal
+    class UnsharedSignal < Signal
+      def self.for(mode)
+        raise ArgumentError, "fiber_wait must be :auto, :io, or :block" unless %i[auto io block].include?(mode)
+        new
+      end
+
+      # Alternative engines keep their existing scheduler coordination.
+      # @api private
+      def fiber_wait = :auto
+    end
+
+    UnsharedIOSignal = UnsharedSignal
+    UnsharedBlockSignal = UnsharedSignal
+  end
+end

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

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    class UnsharedVector
+      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)
+
+        @values              = source ? Array.new(source) : []
+        @compare_by_identity = compare_by_identity
+        @mutex               = Mutex.new
+        @signal              = Signal.new
+        @updating            = false
+        @farce_frozen        = false
+      end
+
+      # @api private
+      def transaction_snapshot
+        PortableTransaction.snapshot(self, :vector)
+      end
+
+      def freeze
+        @mutex.synchronize { @farce_frozen = true }
+        self
+      end
+
+      def frozen? = @mutex.synchronize { @farce_frozen }
+
+      def size = @mutex.synchronize { @values.size }
+
+      def snapshot = @mutex.synchronize { @values.dup }
+
+      def each
+        return enum_for(__method__) { size } unless block_given?
+
+        limit = size
+        index = 0
+        while index < limit
+          value = @mutex.synchronize do
+            return self if index >= @values.size
+            @values[index]
+          end
+          yield value
+          index += 1
+        end
+        self
+      end
+
+      def reverse_each
+        return enum_for(__method__) { size } unless block_given?
+
+        index = size
+        while index.positive?
+          value = @mutex.synchronize do
+            index = @values.size if index > @values.size
+            index -= 1
+            return self if index.negative?
+            @values[index]
+          end
+          yield value
+        end
+        self
+      end
+
+      def fetch(index)
+        index = convert_index(index)
+        found = true
+        value = @mutex.synchronize { @values.fetch(index) { found = false } }
+        return value if found
+        return yield(index) if block_given?
+
+        raise IndexError, "index #{index} outside of vector bounds"
+      end
+
+      def [](index)
+        index = convert_index(index)
+        @mutex.synchronize { @values[index] }
+      end
+
+      def []=(index, value)
+        check_frozen!
+        index     = convert_index(index)
+        _, result = with_available(nil) do
+          check_frozen_locked!
+          store_value(index, value)
+        end
+        result
+      end
+
+      def get(index, timeout: nil)
+        index             = convert_index(index)
+        completed, result = with_available(timeout_deadline(timeout)) { @values[index] }
+        result if completed
+      end
+
+      def store(index, value, timeout: nil)
+        check_frozen!
+        index             = convert_index(index)
+        completed, result = with_available(timeout_deadline(timeout)) do
+          check_frozen_locked!
+          store_value(index, value)
+        end
+        completed ? result : false
+      end
+
+      def clear
+        check_frozen!
+        with_available(nil) do
+          check_frozen_locked!
+          @values.clear
+          changed!
+        end
+        self
+      end
+
+      def push(value, timeout: nil)
+        check_frozen!
+        completed, = with_available(timeout_deadline(timeout)) do
+          check_frozen_locked!
+          @values.push(value)
+          changed!
+        end
+        completed ? self : false
+      end
+
+      def pop(timeout: nil)
+        check_frozen!
+        completed, result = with_available(timeout_deadline(timeout)) do
+          check_frozen_locked!
+          next if @values.empty?
+
+          value = @values.pop
+          changed!
+          value
+        end
+        result if completed
+      end
+
+      def swap(index, replacement, timeout: nil)
+        check_frozen!
+        index             = convert_index(index)
+        completed, result = with_available(timeout_deadline(timeout)) do
+          check_frozen_locked!
+          index           = assignment_index(index)
+          previous        = @values[index]
+          @values[index]  = replacement
+          changed!
+          previous
+        end
+        result if completed
+      end
+
+      def store_if_absent(index, timeout: nil)
+        raise LocalJumpError, "no block given" unless block_given?
+        check_frozen!
+
+        index                  = convert_index(index)
+        completed, reservation = reserve(timeout_deadline(timeout)) do
+          normalized           = assignment_index(index)
+          current              = @values[normalized]
+          if current.nil?
+            @updating = true
+            [:store, normalized]
+          else
+            [:existing, current]
+          end
+        end
+        return unless completed
+        return reservation.last if reservation.first == :existing
+
+        _, normalized = reservation
+        result        = yield
+        check_frozen!
+        @mutex.synchronize { @values[normalized] = result }
+        result
+      ensure
+        finish_update if reservation&.first == :store
+      end
+
+      def compare_and_set(index, expected, replacement, timeout: nil)
+        check_frozen!
+        index                  = convert_index(index)
+        completed, reservation = reserve(timeout_deadline(timeout)) do
+          normalized = lookup_index(index)
+          next unless normalized
+
+          @updating = true
+          [normalized, @values[normalized]]
+        end
+        return false unless completed && reservation
+
+        normalized, current = reservation
+        matches             = values_equal?(current, expected)
+        check_frozen!
+        @mutex.synchronize { @values[normalized] = replacement if matches }
+        matches
+      ensure
+        finish_update if reservation
+      end
+
+      def upsert(index, initial, timeout: nil)
+        raise LocalJumpError, "no block given" unless block_given?
+        check_frozen!
+
+        index                  = convert_index(index)
+        completed, reservation = reserve(timeout_deadline(timeout)) do
+          normalized           = assignment_index(index)
+          current              = @values[normalized]
+          if current.nil?
+            @values[normalized] = initial
+            changed!
+            [:stored, initial]
+          else
+            @updating = true
+            [:update, normalized, current]
+          end
+        end
+        return unless completed
+        return reservation.last if reservation.first == :stored
+
+        _, normalized, current = reservation
+        result                 = yield(current)
+        check_frozen!
+        @mutex.synchronize { @values[normalized] = result }
+        result
+      ensure
+        finish_update if reservation&.first == :update
+      end
+
+      def update(index, timeout: nil)
+        raise LocalJumpError, "no block given" unless block_given?
+        check_frozen!
+
+        index                  = convert_index(index)
+        completed, reservation = reserve(timeout_deadline(timeout)) do
+          normalized           = assignment_index(index)
+          @updating            = true
+          [normalized, @values[normalized]]
+        end
+        return unless completed
+
+        normalized, current = reservation
+        result              = yield(current)
+        check_frozen!
+        @mutex.synchronize { @values[normalized] = result }
+        result
+      ensure
+        finish_update if reservation
+      end
+
+      def wait_until_changed(index, expected, timeout: nil)
+        wait_for_value(convert_index(index), expected, timeout_deadline(timeout), 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)
+      end
+
+      def compare_by_identity? = @compare_by_identity
+
+      private
+
+      def store_value(index, value)
+        @values[assignment_index(index)] = value
+        changed!
+        value
+      end
+
+      def with_available(deadline)
+        while true
+          generation        = @signal.generation
+          completed, result = @mutex.synchronize do
+            @updating ? [false, nil] : [true, yield]
+          end
+          return [true, result] if completed
+          return [false, nil] unless wait_for_signal(generation, deadline)
+        end
+      end
+
+      def reserve(deadline)
+        while true
+          generation        = @signal.generation
+          completed, result = @mutex.synchronize do
+            if @updating
+              [false, nil]
+            else
+              check_frozen_locked!
+              [true, yield]
+            end
+          end
+          return [true, result] if completed
+          return [false, nil] unless wait_for_signal(generation, deadline)
+        end
+      end
+
+      def finish_update
+        @mutex.synchronize { @updating = false }
+        changed!
+      end
+
+      def changed! = @signal.broadcast
+
+      def check_frozen!
+        @mutex.synchronize { check_frozen_locked! }
+      end
+
+      def check_frozen_locked!
+        return unless @farce_frozen
+
+        raise FrozenError.new("can't modify frozen #{self.class}", receiver: self)
+      end
+
+      def wait_for_value(index, expected, deadline, non_nil:)
+        while true
+          generation = @signal.generation
+          current    = @mutex.synchronize { @values[index] }
+          ready      = non_nil ? !current.nil? : !values_equal?(current, expected)
+          return current if ready
+          return unless wait_for_signal(generation, deadline)
+        end
+      end
+
+      def wait_for_signal(generation, deadline)
+        return @signal.wait(generation) unless deadline
+
+        remaining = deadline - Clock.now
+        return false unless remaining.positive?
+        !@signal.wait(generation, timeout: remaining).nil?
+      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
+
+      def lookup_index(index)
+        index += @values.size if index.negative?
+        index if index >= 0 && index < @values.size
+      end
+
+      def assignment_index(index)
+        return index unless index.negative?
+
+        normalized = @values.size + index
+        return normalized unless normalized.negative?
+        raise IndexError, "index #{index} too small for vector; minimum: -#{@values.size}"
+      end
+
+      def convert_index(index)
+        return index if index.is_a?(Integer)
+
+        raise TypeError, "no implicit conversion of #{index.class} into Integer" unless index.respond_to?(:to_int)
+        converted = index.to_int
+        return converted if converted.is_a?(Integer)
+        raise TypeError, "can't convert #{index.class} to Integer"
+      end
+
+      def validate_boolean(value, name)
+        return if value.equal?(true) || value.equal?(false)
+        raise ArgumentError, "#{name} must be true or false"
+      end
+
+      def values_equal?(left, right)
+        compare_by_identity? ? left.equal?(right) : left == right
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+require "farce/engine/shared/weak_atom/base"
+require "farce/engine/shared/weak_map/reference"
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    class UnsharedWeakAtom < WeakAtomBase
+      private
+
+      def initialize_storage(value)
+        @mutex = Mutex.new
+        @reference = UnsharedWeakMapWeakReference.for(value)
+      end
+
+      def read_value = @mutex.synchronize { @reference.read.last }
+
+      def write_value(value)
+        @mutex.synchronize do
+          @reference = UnsharedWeakMapWeakReference.for(value)
+          @changes.update { |generation| generation + 1 }
+        end
+        nil
+      end
+    end
+  end
+end