concurrent-ruby 1.1.5 → 1.2.2

data/lib/concurrent/synchronization/truffleruby_object.rb

@@ -1,47 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    module TruffleRubyAttrVolatile
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def attr_volatile(*names)
-          names.each do |name|
-            ivar = :"@volatile_#{name}"
-
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                full_memory_barrier
-                #{ivar}                  
-              end
-
-              def #{name}=(value)
-                #{ivar} = value
-                full_memory_barrier
-              end
-            RUBY
-          end
-
-          names.map { |n| [n, :"#{n}="] }.flatten
-        end
-      end
-
-      def full_memory_barrier
-        TruffleRuby.full_memory_barrier
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class TruffleRubyObject < AbstractObject
-      include TruffleRubyAttrVolatile
-
-      def initialize
-        # nothing to do
-      end
-    end
-  end
-end

data/lib/concurrent/synchronization/volatile.rb

@@ -1,36 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # Volatile adds the attr_volatile class method when included.
-    #
-    # @example
-    #   class Foo
-    #     include Concurrent::Synchronization::Volatile
-    #
-    #     attr_volatile :bar
-    #
-    #     def initialize
-    #       self.bar = 1
-    #     end
-    #   end
-    #
-    #  foo = Foo.new
-    #  foo.bar
-    #  => 1
-    #  foo.bar = 2
-    #  => 2
-
-    Volatile = case
-               when Concurrent.on_cruby?
-                 MriAttrVolatile
-               when Concurrent.on_jruby?
-                 JRubyAttrVolatile
-               when Concurrent.on_rbx?
-                 RbxAttrVolatile
-               when Concurrent.on_truffleruby?
-                 TruffleRubyAttrVolatile
-               else
-                 MriAttrVolatile
-               end
-  end
-end

data/lib/concurrent/synchronization.rb

@@ -1,30 +0,0 @@
-require 'concurrent/utility/engine'
-
-require 'concurrent/synchronization/abstract_object'
-require 'concurrent/utility/native_extension_loader' # load native parts first
-Concurrent.load_native_extensions
-
-require 'concurrent/synchronization/mri_object'
-require 'concurrent/synchronization/jruby_object'
-require 'concurrent/synchronization/rbx_object'
-require 'concurrent/synchronization/truffleruby_object'
-require 'concurrent/synchronization/object'
-require 'concurrent/synchronization/volatile'
-
-require 'concurrent/synchronization/abstract_lockable_object'
-require 'concurrent/synchronization/mutex_lockable_object'
-require 'concurrent/synchronization/jruby_lockable_object'
-require 'concurrent/synchronization/rbx_lockable_object'
-
-require 'concurrent/synchronization/lockable_object'
-
-require 'concurrent/synchronization/condition'
-require 'concurrent/synchronization/lock'
-
-module Concurrent
-  # {include:file:docs-source/synchronization.md}
-  # {include:file:docs-source/synchronization-notes.md}
-  module Synchronization
-  end
-end
-

data/lib/concurrent/thread_safe/synchronized_delegator.rb

@@ -1,50 +0,0 @@
-require 'delegate'
-require 'monitor'
-
-module Concurrent
-  unless defined?(SynchronizedDelegator)
-
-    # This class provides a trivial way to synchronize all calls to a given object
-    # by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
-    # around the delegated `#send`. Example:
-    #
-    #   array = [] # not thread-safe on many impls
-    #   array = SynchronizedDelegator.new([]) # thread-safe
-    #
-    # A simple `Monitor` provides a very coarse-grained way to synchronize a given
-    # object, in that it will cause synchronization for methods that have no need
-    # for it, but this is a trivial way to get thread-safety where none may exist
-    # currently on some implementations.
-    #
-    # This class is currently being considered for inclusion into stdlib, via
-    # https://bugs.ruby-lang.org/issues/8556
-    #
-    # @!visibility private
-    class SynchronizedDelegator < SimpleDelegator
-      def setup
-        @old_abort = Thread.abort_on_exception
-        Thread.abort_on_exception = true
-      end
-
-      def teardown
-        Thread.abort_on_exception = @old_abort
-      end
-
-      def initialize(obj)
-        __setobj__(obj)
-        @monitor = Monitor.new
-      end
-
-      def method_missing(method, *args, &block)
-        monitor = @monitor
-        begin
-          monitor.enter
-          super
-        ensure
-          monitor.exit
-        end
-      end
-
-    end
-  end
-end

data/lib/concurrent/thread_safe/util/data_structures.rb

@@ -1,63 +0,0 @@
-require 'concurrent/thread_safe/util'
-
-# Shim for TruffleRuby.synchronized
-if Concurrent.on_truffleruby? && !TruffleRuby.respond_to?(:synchronized)
-  module TruffleRuby
-    def self.synchronized(object, &block)
-      Truffle::System.synchronized(object, &block)
-    end
-  end
-end
-
-module Concurrent
-  module ThreadSafe
-    module Util
-      def self.make_synchronized_on_rbx(klass)
-        klass.class_eval do
-          private
-
-          def _mon_initialize
-            @_monitor = Monitor.new unless @_monitor # avoid double initialisation
-          end
-
-          def self.new(*args)
-            obj = super(*args)
-            obj.send(:_mon_initialize)
-            obj
-          end
-        end
-
-        klass.superclass.instance_methods(false).each do |method|
-          case method
-          when :new_range, :new_reserved
-            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method}(*args)
-                obj = super
-                obj.send(:_mon_initialize)
-                obj
-              end
-            RUBY
-          else
-            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method}(*args)
-                monitor = @_monitor
-                monitor or raise("BUG: Internal monitor was not properly initialized. Please report this to the concurrent-ruby developers.")
-                monitor.synchronize { super }
-              end
-            RUBY
-          end
-        end
-      end
-
-      def self.make_synchronized_on_truffleruby(klass)
-        klass.superclass.instance_methods(false).each do |method|
-          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(*args, &block)    
-              TruffleRuby.synchronized(self) { super(*args, &block) }
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/utility/at_exit.rb

@@ -1,97 +0,0 @@
-require 'logger'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # Provides ability to add and remove handlers to be run at `Kernel#at_exit`, order is undefined.
-  # Each handler is executed at most once.
-  #
-  # @!visibility private
-  class AtExitImplementation < Synchronization::LockableObject
-    include Logger::Severity
-
-    def initialize(*args)
-      super()
-      synchronize { ns_initialize(*args) }
-    end
-
-    # Add a handler to be run at `Kernel#at_exit`
-    # @param [Object] handler_id optionally provide an id, if already present, handler is replaced
-    # @yield the handler
-    # @return id of the handler
-    def add(handler_id = nil, &handler)
-      id = handler_id || handler.object_id
-      synchronize { @handlers[id] = handler }
-      id
-    end
-
-    # Delete a handler by handler_id
-    # @return [true, false]
-    def delete(handler_id)
-      !!synchronize { @handlers.delete handler_id }
-    end
-
-    # Is handler with handler_id rpesent?
-    # @return [true, false]
-    def handler?(handler_id)
-      synchronize { @handlers.key? handler_id }
-    end
-
-    # @return copy of the handlers
-    def handlers
-      synchronize { @handlers }.clone
-    end
-
-    # install `Kernel#at_exit` callback to execute added handlers
-    def install
-      synchronize do
-        @installed ||= begin
-                         at_exit { runner }
-                         true
-                       end
-        self
-      end
-    end
-
-    # Will it run during `Kernel#at_exit`
-    def enabled?
-      synchronize { @enabled }
-    end
-
-    # Configure if it runs during `Kernel#at_exit`
-    def enabled=(value)
-      synchronize { @enabled = value }
-    end
-
-    # run the handlers manually
-    # @return ids of the handlers
-    def run
-      handlers, _ = synchronize { handlers, @handlers = @handlers, {} }
-      handlers.each do |_, handler|
-        begin
-          handler.call
-        rescue => error
-          Concurrent.global_logger.call(ERROR, error)
-        end
-      end
-      handlers.keys
-    end
-
-    private
-
-    def ns_initialize(enabled = true)
-      @handlers = {}
-      @enabled  = enabled
-    end
-
-    def runner
-      run if synchronize { @enabled }
-    end
-  end
-
-  private_constant :AtExitImplementation
-
-  # @see AtExitImplementation
-  # @!visibility private
-  AtExit = AtExitImplementation.new.install
-end

data/lib/concurrent/utility/monotonic_time.rb

@@ -1,58 +0,0 @@
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  class_definition = Class.new(Synchronization::LockableObject) do
-    def initialize
-      @last_time = Time.now.to_f
-      super()
-    end
-
-    if defined?(Process::CLOCK_MONOTONIC)
-      # @!visibility private
-      def get_time
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-    elsif Concurrent.on_jruby?
-      # @!visibility private
-      def get_time
-        java.lang.System.nanoTime() / 1_000_000_000.0
-      end
-    else
-
-      # @!visibility private
-      def get_time
-        synchronize do
-          now = Time.now.to_f
-          if @last_time < now
-            @last_time = now
-          else # clock has moved back in time
-            @last_time += 0.000_001
-          end
-        end
-      end
-
-    end
-  end
-
-  # Clock that cannot be set and represents monotonic time since
-  # some unspecified starting point.
-  #
-  # @!visibility private
-  GLOBAL_MONOTONIC_CLOCK = class_definition.new
-  private_constant :GLOBAL_MONOTONIC_CLOCK
-
-  # @!macro monotonic_get_time
-  #
-  #   Returns the current time a tracked by the application monotonic clock.
-  #
-  #   @return [Float] The current monotonic time since some unspecified
-  #     starting point
-  #
-  #   @!macro monotonic_clock_warning
-  def monotonic_time
-    GLOBAL_MONOTONIC_CLOCK.get_time
-  end
-
-  module_function :monotonic_time
-end

data/lib/concurrent/utility/processor_counter.rb

@@ -1,158 +0,0 @@
-require 'rbconfig'
-require 'concurrent/delay'
-
-module Concurrent
-  module Utility
-
-    # @!visibility private
-    class ProcessorCounter
-      def initialize
-        @processor_count          = Delay.new { compute_processor_count }
-        @physical_processor_count = Delay.new { compute_physical_processor_count }
-      end
-
-      # Number of processors seen by the OS and used for process scheduling. For
-      # performance reasons the calculated value will be memoized on the first
-      # call.
-      #
-      # When running under JRuby the Java runtime call
-      # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
-      # to the Java documentation this "value may change during a particular
-      # invocation of the virtual machine... [applications] should therefore
-      # occasionally poll this property." Subsequently the result will NOT be
-      # memoized under JRuby.
-      #
-      # On Windows the Win32 API will be queried for the
-      # `NumberOfLogicalProcessors from Win32_Processor`. This will return the
-      # total number "logical processors for the current instance of the
-      # processor", which taked into account hyperthreading.
-      #
-      # * AIX: /usr/sbin/pmcycles (AIX 5+), /usr/sbin/lsdev
-      # * Alpha: /usr/bin/nproc (/proc/cpuinfo exists but cannot be used)
-      # * BSD: /sbin/sysctl
-      # * Cygwin: /proc/cpuinfo
-      # * Darwin: /usr/bin/hwprefs, /usr/sbin/sysctl
-      # * HP-UX: /usr/sbin/ioscan
-      # * IRIX: /usr/sbin/sysconf
-      # * Linux: /proc/cpuinfo
-      # * Minix 3+: /proc/cpuinfo
-      # * Solaris: /usr/sbin/psrinfo
-      # * Tru64 UNIX: /usr/sbin/psrinfo
-      # * UnixWare: /usr/sbin/psrinfo
-      #
-      # @return [Integer] number of processors seen by the OS or Java runtime
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      def processor_count
-        @processor_count.value
-      end
-
-      # Number of physical processor cores on the current system. For performance
-      # reasons the calculated value will be memoized on the first call.
-      #
-      # On Windows the Win32 API will be queried for the `NumberOfCores from
-      # Win32_Processor`. This will return the total number "of cores for the
-      # current instance of the processor." On Unix-like operating systems either
-      # the `hwprefs` or `sysctl` utility will be called in a subshell and the
-      # returned value will be used. In the rare case where none of these methods
-      # work or an exception is raised the function will simply return 1.
-      #
-      # @return [Integer] number physical processor cores on the current system
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      # @see http://www.unix.com/man-page/osx/1/HWPREFS/
-      # @see http://linux.die.net/man/8/sysctl
-      def physical_processor_count
-        @physical_processor_count.value
-      end
-
-      private
-
-      def compute_processor_count
-        if Concurrent.on_jruby?
-          java.lang.Runtime.getRuntime.availableProcessors
-        else
-          os_name = RbConfig::CONFIG["target_os"]
-          if os_name =~ /mingw|mswin/
-            require 'win32ole'
-            result = WIN32OLE.connect("winmgmts://").ExecQuery(
-              "select NumberOfLogicalProcessors from Win32_Processor")
-            result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
-          elsif File.readable?("/proc/cpuinfo") && (cpuinfo_count = IO.read("/proc/cpuinfo").scan(/^processor/).size) > 0
-            cpuinfo_count
-          elsif File.executable?("/usr/bin/nproc")
-            IO.popen("/usr/bin/nproc --all", &:read).to_i
-          elsif File.executable?("/usr/bin/hwprefs")
-            IO.popen("/usr/bin/hwprefs thread_count", &:read).to_i
-          elsif File.executable?("/usr/sbin/psrinfo")
-            IO.popen("/usr/sbin/psrinfo", &:read).scan(/^.*on-*line/).size
-          elsif File.executable?("/usr/sbin/ioscan")
-            IO.popen("/usr/sbin/ioscan -kC processor", &:read).scan(/^.*processor/).size
-          elsif File.executable?("/usr/sbin/pmcycles")
-            IO.popen("/usr/sbin/pmcycles -m", &:read).count("\n")
-          elsif File.executable?("/usr/sbin/lsdev")
-            IO.popen("/usr/sbin/lsdev -Cc processor -S 1", &:read).count("\n")
-          elsif File.executable?("/usr/sbin/sysconf") and os_name =~ /irix/i
-            IO.popen("/usr/sbin/sysconf NPROC_ONLN", &:read).to_i
-          elsif File.executable?("/usr/sbin/sysctl")
-            IO.popen("/usr/sbin/sysctl -n hw.ncpu", &:read).to_i
-          elsif File.executable?("/sbin/sysctl")
-            IO.popen("/sbin/sysctl -n hw.ncpu", &:read).to_i
-          else
-            # TODO (pitr-ch 05-Nov-2016): warn about failures
-            1
-          end
-        end
-      rescue
-        return 1
-      end
-
-      def compute_physical_processor_count
-        ppc = case RbConfig::CONFIG["target_os"]
-              when /darwin1/
-                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
-              when /linux/
-                cores = {} # unique physical ID / core ID combinations
-                phy   = 0
-                IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
-                  if ln.start_with?("physical")
-                    phy = ln[/\d+/]
-                  elsif ln.start_with?("core")
-                    cid        = phy + ":" + ln[/\d+/]
-                    cores[cid] = true if not cores[cid]
-                  end
-                end
-                cores.count
-              when /mswin|mingw/
-                require 'win32ole'
-                result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
-                  "select NumberOfCores from Win32_Processor")
-                result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
-              else
-                processor_count
-              end
-        # fall back to logical count if physical info is invalid
-        ppc > 0 ? ppc : processor_count
-      rescue
-        return 1
-      end
-    end
-  end
-
-  # create the default ProcessorCounter on load
-  @processor_counter = Utility::ProcessorCounter.new
-  singleton_class.send :attr_reader, :processor_counter
-
-  def self.processor_count
-    processor_counter.processor_count
-  end
-
-  def self.physical_processor_count
-    processor_counter.physical_processor_count
-  end
-end

data/lib/concurrent/version.rb

@@ -1,3 +0,0 @@
-module Concurrent
-  VERSION      = '1.1.5'
-end

data/lib/concurrent-ruby.rb

@@ -1 +0,0 @@
-require_relative "./concurrent"

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/count_down_latch.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/atomic/mutex_count_down_latch'
 require 'concurrent/atomic/java_count_down_latch'
-require 'concurrent/utility/engine'
 
 module Concurrent
 

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/non_concurrent_priority_queue.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/collection/java_non_concurrent_priority_queue'
 require 'concurrent/collection/ruby_non_concurrent_priority_queue'
-require 'concurrent/utility/engine'
 
 module Concurrent
   module Collection