pangea-core 0.2.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb

@@ -0,0 +1,128 @@
+require 'concurrent/synchronization/lockable_object'
+require 'concurrent/utility/native_integer'
+
+module Concurrent
+
+  # A synchronization aid that allows a set of threads to all wait for each
+  # other to reach a common barrier point.
+  # @example
+  #   barrier = Concurrent::CyclicBarrier.new(3)
+  #   jobs    = Array.new(3) { |i| -> { sleep i; p done: i } }
+  #   process = -> (i) do
+  #     # waiting to start at the same time
+  #     barrier.wait
+  #     # execute job
+  #     jobs[i].call
+  #     # wait for others to finish
+  #     barrier.wait
+  #   end
+  #   threads = 2.times.map do |i|
+  #     Thread.new(i, &process)
+  #   end
+  #
+  #   # use main as well
+  #   process.call 2
+  #
+  #   # here we can be sure that all jobs are processed
+  class CyclicBarrier < Synchronization::LockableObject
+
+    # @!visibility private
+    Generation = Struct.new(:status)
+    private_constant :Generation
+
+    # Create a new `CyclicBarrier` that waits for `parties` threads
+    #
+    # @param [Fixnum] parties the number of parties
+    # @yield an optional block that will be executed that will be executed after
+    #  the last thread arrives and before the others are released
+    #
+    # @raise [ArgumentError] if `parties` is not an integer or is less than zero
+    def initialize(parties, &block)
+      Utility::NativeInteger.ensure_integer_and_bounds parties
+      Utility::NativeInteger.ensure_positive_and_no_zero parties
+
+      super(&nil)
+      synchronize { ns_initialize parties, &block }
+    end
+
+    # @return [Fixnum] the number of threads needed to pass the barrier
+    def parties
+      synchronize { @parties }
+    end
+
+    # @return [Fixnum] the number of threads currently waiting on the barrier
+    def number_waiting
+      synchronize { @number_waiting }
+    end
+
+    # Blocks on the barrier until the number of waiting threads is equal to
+    # `parties` or until `timeout` is reached or `reset` is called
+    # If a block has been passed to the constructor, it will be executed once by
+    #  the last arrived thread before releasing the others
+    # @param [Fixnum] timeout the number of seconds to wait for the counter or
+    #  `nil` to block indefinitely
+    # @return [Boolean] `true` if the `count` reaches zero else false on
+    #  `timeout` or on `reset` or if the barrier is broken
+    def wait(timeout = nil)
+      synchronize do
+
+        return false unless @generation.status == :waiting
+
+        @number_waiting += 1
+
+        if @number_waiting == @parties
+          @action.call if @action
+          ns_generation_done @generation, :fulfilled
+          true
+        else
+          generation = @generation
+          if ns_wait_until(timeout) { generation.status != :waiting }
+            generation.status == :fulfilled
+          else
+            ns_generation_done generation, :broken, false
+            false
+          end
+        end
+      end
+    end
+
+    # resets the barrier to its initial state
+    # If there is at least one waiting thread, it will be woken up, the `wait`
+    # method will return false and the barrier will be broken
+    # If the barrier is broken, this method restores it to the original state
+    #
+    # @return [nil]
+    def reset
+      synchronize { ns_generation_done @generation, :reset }
+    end
+
+    # A barrier can be broken when:
+    # - a thread called the `reset` method while at least one other thread was waiting
+    # - at least one thread timed out on `wait` method
+    #
+    # A broken barrier can be restored using `reset` it's safer to create a new one
+    # @return [Boolean] true if the barrier is broken otherwise false
+    def broken?
+      synchronize { @generation.status != :waiting }
+    end
+
+    protected
+
+    def ns_generation_done(generation, status, continue = true)
+      generation.status = status
+      ns_next_generation if continue
+      ns_broadcast
+    end
+
+    def ns_next_generation
+      @generation     = Generation.new(:waiting)
+      @number_waiting = 0
+    end
+
+    def ns_initialize(parties, &block)
+      @parties = parties
+      @action  = block
+      ns_next_generation
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/event.rb

@@ -0,0 +1,109 @@
+require 'thread'
+require 'concurrent/synchronization/lockable_object'
+
+module Concurrent
+
+  # Old school kernel-style event reminiscent of Win32 programming in C++.
+  #
+  # When an `Event` is created it is in the `unset` state. Threads can choose to
+  # `#wait` on the event, blocking until released by another thread. When one
+  # thread wants to alert all blocking threads it calls the `#set` method which
+  # will then wake up all listeners. Once an `Event` has been set it remains set.
+  # New threads calling `#wait` will return immediately. An `Event` may be
+  # `#reset` at any time once it has been set.
+  #
+  # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx
+  # @example
+  #   event = Concurrent::Event.new
+  #
+  #   t1 = Thread.new do
+  #     puts "t1 is waiting"
+  #     event.wait(1)
+  #     puts "event occurred"
+  #   end
+  #
+  #   t2 = Thread.new do
+  #     puts "t2 calling set"
+  #     event.set
+  #   end
+  #
+  #   [t1, t2].each(&:join)
+  #
+  #   # prints:
+  #   # t1 is waiting
+  #   # t2 calling set
+  #   # event occurred
+  class Event < Synchronization::LockableObject
+
+    # Creates a new `Event` in the unset state. Threads calling `#wait` on the
+    # `Event` will block.
+    def initialize
+      super
+      synchronize { ns_initialize }
+    end
+
+    # Is the object in the set state?
+    #
+    # @return [Boolean] indicating whether or not the `Event` has been set
+    def set?
+      synchronize { @set }
+    end
+
+    # Trigger the event, setting the state to `set` and releasing all threads
+    # waiting on the event. Has no effect if the `Event` has already been set.
+    #
+    # @return [Boolean] should always return `true`
+    def set
+      synchronize { ns_set }
+    end
+
+    def try?
+      synchronize { @set ? false : ns_set }
+    end
+
+    # Reset a previously set event back to the `unset` state.
+    # Has no effect if the `Event` has not yet been set.
+    #
+    # @return [Boolean] should always return `true`
+    def reset
+      synchronize do
+        if @set
+          @set       = false
+          @iteration +=1
+        end
+        true
+      end
+    end
+
+    # Wait a given number of seconds for the `Event` to be set by another
+    # thread. Will wait forever when no `timeout` value is given. Returns
+    # immediately if the `Event` has already been set.
+    #
+    # @return [Boolean] true if the `Event` was set before timeout else false
+    def wait(timeout = nil)
+      synchronize do
+        unless @set
+          iteration = @iteration
+          ns_wait_until(timeout) { iteration < @iteration || @set }
+        else
+          true
+        end
+      end
+    end
+
+    protected
+
+    def ns_set
+      unless @set
+        @set = true
+        ns_broadcast
+      end
+      true
+    end
+
+    def ns_initialize
+      @set       = false
+      @iteration = 0
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb

@@ -0,0 +1,109 @@
+require 'concurrent/constants'
+require_relative 'locals'
+
+module Concurrent
+
+  # A `FiberLocalVar` is a variable where the value is different for each fiber.
+  # Each variable may have a default value, but when you modify the variable only
+  # the current fiber will ever see that change.
+  #
+  # This is similar to Ruby's built-in fiber-local variables (`Thread.current[:name]`),
+  # but with these major advantages:
+  # * `FiberLocalVar` has its own identity, it doesn't need a Symbol.
+  # * Each Ruby's built-in fiber-local variable leaks some memory forever (it's a Symbol held forever on the fiber),
+  #   so it's only OK to create a small amount of them.
+  #   `FiberLocalVar` has no such issue and it is fine to create many of them.
+  # * Ruby's built-in fiber-local variables leak forever the value set on each fiber (unless set to nil explicitly).
+  #   `FiberLocalVar` automatically removes the mapping for each fiber once the `FiberLocalVar` instance is GC'd.
+  #
+  # @example
+  #   v = FiberLocalVar.new(14)
+  #   v.value #=> 14
+  #   v.value = 2
+  #   v.value #=> 2
+  #
+  # @example
+  #   v = FiberLocalVar.new(14)
+  #
+  #   Fiber.new do
+  #     v.value #=> 14
+  #     v.value = 1
+  #     v.value #=> 1
+  #   end.resume
+  #
+  #   Fiber.new do
+  #     v.value #=> 14
+  #     v.value = 2
+  #     v.value #=> 2
+  #   end.resume
+  #
+  #   v.value #=> 14
+  class FiberLocalVar
+    LOCALS = FiberLocals.new
+
+    # Creates a fiber local variable.
+    #
+    # @param [Object] default the default value when otherwise unset
+    # @param [Proc] default_block Optional block that gets called to obtain the
+    #   default value for each fiber
+    def initialize(default = nil, &default_block)
+      if default && block_given?
+        raise ArgumentError, "Cannot use both value and block as default value"
+      end
+
+      if block_given?
+        @default_block = default_block
+        @default = nil
+      else
+        @default_block = nil
+        @default = default
+      end
+
+      @index = LOCALS.next_index(self)
+    end
+
+    # Returns the value in the current fiber's copy of this fiber-local variable.
+    #
+    # @return [Object] the current value
+    def value
+      LOCALS.fetch(@index) { default }
+    end
+
+    # Sets the current fiber's copy of this fiber-local variable to the specified value.
+    #
+    # @param [Object] value the value to set
+    # @return [Object] the new value
+    def value=(value)
+      LOCALS.set(@index, value)
+    end
+
+    # Bind the given value to fiber local storage during
+    # execution of the given block.
+    #
+    # @param [Object] value the value to bind
+    # @yield the operation to be performed with the bound variable
+    # @return [Object] the value
+    def bind(value)
+      if block_given?
+        old_value = self.value
+        self.value = value
+        begin
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
+    end
+
+    protected
+
+    # @!visibility private
+    def default
+      if @default_block
+        self.value = @default_block.call
+      else
+        @default
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb

@@ -0,0 +1,43 @@
+if Concurrent.on_jruby?
+  require 'concurrent/utility/native_extension_loader'
+
+  module Concurrent
+
+    # @!macro count_down_latch
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class JavaCountDownLatch
+
+      # @!macro count_down_latch_method_initialize
+      def initialize(count = 1)
+        Utility::NativeInteger.ensure_integer_and_bounds(count)
+        Utility::NativeInteger.ensure_positive(count)
+        @latch = java.util.concurrent.CountDownLatch.new(count)
+      end
+
+      # @!macro count_down_latch_method_wait
+      def wait(timeout = nil)
+        result = nil
+        if timeout.nil?
+          Synchronization::JRuby.sleep_interruptibly { @latch.await }
+          result = true
+        else
+          Synchronization::JRuby.sleep_interruptibly do
+            result = @latch.await(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          end
+        end
+        result
+      end
+
+      # @!macro count_down_latch_method_count_down
+      def count_down
+        @latch.countDown
+      end
+
+      # @!macro count_down_latch_method_count
+      def count
+        @latch.getCount
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/locals.rb

@@ -0,0 +1,189 @@
+require 'fiber'
+require 'concurrent/utility/engine'
+require 'concurrent/constants'
+
+module Concurrent
+  # @!visibility private
+  # @!macro internal_implementation_note
+  #
+  # An abstract implementation of local storage, with sub-classes for
+  # per-thread and per-fiber locals.
+  #
+  # Each execution context (EC, thread or fiber) has a lazily initialized array
+  # of local variable values. Each time a new local variable is created, we
+  # allocate an "index" for it.
+  #
+  # For example, if the allocated index is 1, that means slot #1 in EVERY EC's
+  # locals array will be used for the value of that variable.
+  #
+  # The good thing about using a per-EC structure to hold values, rather than
+  # a global, is that no synchronization is needed when reading and writing
+  # those values (since the structure is only ever accessed by a single
+  # thread).
+  #
+  # Of course, when a local variable is GC'd, 1) we need to recover its index
+  # for use by other new local variables (otherwise the locals arrays could
+  # get bigger and bigger with time), and 2) we need to null out all the
+  # references held in the now-unused slots (both to avoid blocking GC of those
+  # objects, and also to prevent "stale" values from being passed on to a new
+  # local when the index is reused).
+  #
+  # Because we need to null out freed slots, we need to keep references to
+  # ALL the locals arrays, so we can null out the appropriate slots in all of
+  # them. This is why we need to use a finalizer to clean up the locals array
+  # when the EC goes out of scope.
+  class AbstractLocals
+    def initialize
+      @free = []
+      @lock = Mutex.new
+      @all_arrays = {}
+      @next = 0
+    end
+
+    def synchronize
+      @lock.synchronize { yield }
+    end
+
+    if Concurrent.on_cruby?
+      def weak_synchronize
+        yield
+      end
+    else
+      alias_method :weak_synchronize, :synchronize
+    end
+
+    def next_index(local)
+      index = synchronize do
+        if @free.empty?
+          @next += 1
+        else
+          @free.pop
+        end
+      end
+
+      # When the local goes out of scope, we should free the associated index
+      # and all values stored into it.
+      ObjectSpace.define_finalizer(local, local_finalizer(index))
+
+      index
+    end
+
+    def free_index(index)
+      weak_synchronize do
+        # The cost of GC'ing a TLV is linear in the number of ECs using local
+        # variables. But that is natural! More ECs means more storage is used
+        # per local variable. So naturally more CPU time is required to free
+        # more storage.
+        #
+        # DO NOT use each_value which might conflict with new pair assignment
+        # into the hash in #set method.
+        @all_arrays.values.each do |locals|
+          locals[index] = nil
+        end
+
+        # free index has to be published after the arrays are cleared:
+        @free << index
+      end
+    end
+
+    def fetch(index)
+      locals = self.locals
+      value = locals ? locals[index] : nil
+
+      if nil == value
+        yield
+      elsif NULL.equal?(value)
+        nil
+      else
+        value
+      end
+    end
+
+    def set(index, value)
+      locals = self.locals!
+      locals[index] = (nil == value ? NULL : value)
+
+      value
+    end
+
+    private
+
+    # When the local goes out of scope, clean up that slot across all locals currently assigned.
+    def local_finalizer(index)
+      proc do
+        free_index(index)
+      end
+    end
+
+    # When a thread/fiber goes out of scope, remove the array from @all_arrays.
+    def thread_fiber_finalizer(array_object_id)
+      proc do
+        weak_synchronize do
+          @all_arrays.delete(array_object_id)
+        end
+      end
+    end
+
+    # Returns the locals for the current scope, or nil if none exist.
+    def locals
+      raise NotImplementedError
+    end
+
+    # Returns the locals for the current scope, creating them if necessary.
+    def locals!
+      raise NotImplementedError
+    end
+  end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  # An array-backed storage of indexed variables per thread.
+  class ThreadLocals < AbstractLocals
+    def locals
+      Thread.current.thread_variable_get(:concurrent_thread_locals)
+    end
+
+    def locals!
+      thread = Thread.current
+      locals = thread.thread_variable_get(:concurrent_thread_locals)
+
+      unless locals
+        locals = thread.thread_variable_set(:concurrent_thread_locals, [])
+        weak_synchronize do
+          @all_arrays[locals.object_id] = locals
+        end
+        # When the thread goes out of scope, we should delete the associated locals:
+        ObjectSpace.define_finalizer(thread, thread_fiber_finalizer(locals.object_id))
+      end
+
+      locals
+    end
+  end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  # An array-backed storage of indexed variables per fiber.
+  class FiberLocals < AbstractLocals
+    def locals
+      Thread.current[:concurrent_fiber_locals]
+    end
+
+    def locals!
+      thread = Thread.current
+      locals = thread[:concurrent_fiber_locals]
+
+      unless locals
+        locals = thread[:concurrent_fiber_locals] = []
+        weak_synchronize do
+          @all_arrays[locals.object_id] = locals
+        end
+        # When the fiber goes out of scope, we should delete the associated locals:
+        ObjectSpace.define_finalizer(Fiber.current, thread_fiber_finalizer(locals.object_id))
+      end
+
+      locals
+    end
+  end
+
+  private_constant :AbstractLocals, :ThreadLocals, :FiberLocals
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb

@@ -0,0 +1,29 @@
+require 'concurrent/utility/engine'
+require_relative 'fiber_local_var'
+require_relative 'thread_local_var'
+
+module Concurrent
+  # @!visibility private
+  def self.mutex_owned_per_thread?
+    return false if Concurrent.on_jruby? || Concurrent.on_truffleruby?
+    return RUBY_VERSION < "3.0" if Concurrent.on_cruby?
+
+    mutex = Mutex.new
+    # Lock the mutex:
+    mutex.synchronize do
+      # Check if the mutex is still owned in a child fiber:
+      Fiber.new { mutex.owned? }.resume
+    end
+  end
+
+  if mutex_owned_per_thread?
+    LockLocalVar = ThreadLocalVar
+  else
+    LockLocalVar = FiberLocalVar
+  end
+
+  # Either {FiberLocalVar} or {ThreadLocalVar} depending on whether Mutex (and Monitor)
+  # are held, respectively, per Fiber or per Thread.
+  class LockLocalVar
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb

@@ -0,0 +1,68 @@
+require 'concurrent/synchronization/safe_initialization'
+
+module Concurrent
+
+  # @!macro atomic_boolean
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class MutexAtomicBoolean
+    extend Concurrent::Synchronization::SafeInitialization
+
+    # @!macro atomic_boolean_method_initialize
+    def initialize(initial = false)
+      super()
+      @Lock = ::Mutex.new
+      @value = !!initial
+    end
+
+    # @!macro atomic_boolean_method_value_get
+    def value
+      synchronize { @value }
+    end
+
+    # @!macro atomic_boolean_method_value_set
+    def value=(value)
+      synchronize { @value = !!value }
+    end
+
+    # @!macro atomic_boolean_method_true_question
+    def true?
+      synchronize { @value }
+    end
+
+    # @!macro atomic_boolean_method_false_question
+    def false?
+      synchronize { !@value }
+    end
+
+    # @!macro atomic_boolean_method_make_true
+    def make_true
+      synchronize { ns_make_value(true) }
+    end
+
+    # @!macro atomic_boolean_method_make_false
+    def make_false
+      synchronize { ns_make_value(false) }
+    end
+
+    protected
+
+    # @!visibility private
+    def synchronize
+      if @Lock.owned?
+        yield
+      else
+        @Lock.synchronize { yield }
+      end
+    end
+
+    private
+
+    # @!visibility private
+    def ns_make_value(value)
+      old = @value
+      @value = value
+      old != @value
+    end
+  end
+end