concurrent-ruby 1.1.5

data/lib/concurrent/utility/monotonic_time.rb

@@ -0,0 +1,58 @@
+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/native_extension_loader.rb

@@ -0,0 +1,79 @@
+require 'concurrent/utility/engine'
+
+module Concurrent
+
+  module Utility
+
+    # @!visibility private
+    module NativeExtensionLoader
+
+      def allow_c_extensions?
+        Concurrent.on_cruby?
+      end
+
+      def c_extensions_loaded?
+        defined?(@c_extensions_loaded) && @c_extensions_loaded
+      end
+
+      def java_extensions_loaded?
+        defined?(@java_extensions_loaded) && @java_extensions_loaded
+      end
+
+      def load_native_extensions
+        unless defined? Synchronization::AbstractObject
+          raise 'native_extension_loader loaded before Synchronization::AbstractObject'
+        end
+
+        if Concurrent.on_cruby? && !c_extensions_loaded?
+          ['concurrent/concurrent_ruby_ext',
+           "concurrent/#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+          ].each { |p| try_load_c_extension p }
+        end
+
+        if Concurrent.on_jruby? && !java_extensions_loaded?
+          begin
+            require 'concurrent/concurrent_ruby.jar'
+            set_java_extensions_loaded
+          rescue LoadError => e
+            raise e, "Java extensions are required for JRuby.\n" + e.message, e.backtrace
+          end
+        end
+      end
+
+      private
+
+      def load_error_path(error)
+        if error.respond_to? :path
+          error.path
+        else
+          error.message.split(' -- ').last
+        end
+      end
+
+      def set_c_extensions_loaded
+        @c_extensions_loaded = true
+      end
+
+      def set_java_extensions_loaded
+        @java_extensions_loaded = true
+      end
+
+      def try_load_c_extension(path)
+        require path
+        set_c_extensions_loaded
+      rescue LoadError => e
+        if load_error_path(e) == path
+          # move on with pure-Ruby implementations
+          # TODO (pitr-ch 12-Jul-2018): warning on verbose?
+        else
+          raise e
+        end
+      end
+
+    end
+  end
+
+  # @!visibility private
+  extend Utility::NativeExtensionLoader
+end
+

data/lib/concurrent/utility/native_integer.rb

@@ -0,0 +1,53 @@
+module Concurrent
+  module Utility
+    # @private
+    module NativeInteger
+      # http://stackoverflow.com/questions/535721/ruby-max-integer
+      MIN_VALUE = -(2**(0.size * 8 - 2))
+      MAX_VALUE = (2**(0.size * 8 - 2) - 1)
+
+      def ensure_upper_bound(value)
+        if value > MAX_VALUE
+          raise RangeError.new("#{value} is greater than the maximum value of #{MAX_VALUE}")
+        end
+        value
+      end
+
+      def ensure_lower_bound(value)
+        if value < MIN_VALUE
+          raise RangeError.new("#{value} is less than the maximum value of #{MIN_VALUE}")
+        end
+        value
+      end
+
+      def ensure_integer(value)
+        unless value.is_a?(Integer)
+          raise ArgumentError.new("#{value} is not an Integer")
+        end
+        value
+      end
+
+      def ensure_integer_and_bounds(value)
+        ensure_integer value
+        ensure_upper_bound value
+        ensure_lower_bound value
+      end
+
+      def ensure_positive(value)
+        if value < 0
+          raise ArgumentError.new("#{value} cannot be negative")
+        end
+        value
+      end
+
+      def ensure_positive_and_no_zero(value)
+        if value < 1
+          raise ArgumentError.new("#{value} cannot be negative or zero")
+        end
+        value
+      end
+
+      extend self
+    end
+  end
+end

data/lib/concurrent/utility/processor_counter.rb

@@ -0,0 +1,158 @@
+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

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

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: concurrent-ruby
+version: !ruby/object:Gem::Version
+  version: 1.1.5
+platform: ruby
+authors:
+- Jerry D'Antonio
+- Petr Chalupa
+- The Ruby Concurrency Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-11 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
+  Inspired by Erlang, Clojure, Go, JavaScript, actors, and classic concurrency patterns.
+email: concurrent-ruby@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- ext/concurrent-ruby/ConcurrentRubyService.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/AtomicReferenceLibrary.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/JRubyMapBackendLibrary.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/JavaAtomicBooleanLibrary.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/JavaAtomicFixnumLibrary.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/JavaSemaphoreLibrary.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/SynchronizationLibrary.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/ConcurrentHashMap.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/ConcurrentHashMapV8.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/LongAdder.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/Striped64.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/nounsafe/ConcurrentHashMapV8.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/nounsafe/LongAdder.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/nounsafe/Striped64.java
+- ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166y/ThreadLocalRandom.java
+- lib/concurrent-ruby.rb
+- lib/concurrent.rb
+- lib/concurrent/agent.rb
+- lib/concurrent/array.rb
+- lib/concurrent/async.rb
+- lib/concurrent/atom.rb
+- lib/concurrent/atomic/abstract_thread_local_var.rb
+- lib/concurrent/atomic/atomic_boolean.rb
+- lib/concurrent/atomic/atomic_fixnum.rb
+- lib/concurrent/atomic/atomic_markable_reference.rb
+- lib/concurrent/atomic/atomic_reference.rb
+- lib/concurrent/atomic/count_down_latch.rb
+- lib/concurrent/atomic/cyclic_barrier.rb
+- lib/concurrent/atomic/event.rb
+- lib/concurrent/atomic/java_count_down_latch.rb
+- lib/concurrent/atomic/java_thread_local_var.rb
+- lib/concurrent/atomic/mutex_atomic_boolean.rb
+- lib/concurrent/atomic/mutex_atomic_fixnum.rb
+- lib/concurrent/atomic/mutex_count_down_latch.rb
+- lib/concurrent/atomic/mutex_semaphore.rb
+- lib/concurrent/atomic/read_write_lock.rb
+- lib/concurrent/atomic/reentrant_read_write_lock.rb
+- lib/concurrent/atomic/ruby_thread_local_var.rb
+- lib/concurrent/atomic/semaphore.rb
+- lib/concurrent/atomic/thread_local_var.rb
+- lib/concurrent/atomic_reference/mutex_atomic.rb
+- lib/concurrent/atomic_reference/numeric_cas_wrapper.rb
+- lib/concurrent/atomics.rb
+- lib/concurrent/collection/copy_on_notify_observer_set.rb
+- lib/concurrent/collection/copy_on_write_observer_set.rb
+- lib/concurrent/collection/java_non_concurrent_priority_queue.rb
+- lib/concurrent/collection/lock_free_stack.rb
+- lib/concurrent/collection/map/atomic_reference_map_backend.rb
+- lib/concurrent/collection/map/mri_map_backend.rb
+- lib/concurrent/collection/map/non_concurrent_map_backend.rb
+- lib/concurrent/collection/map/synchronized_map_backend.rb
+- lib/concurrent/collection/non_concurrent_priority_queue.rb
+- lib/concurrent/collection/ruby_non_concurrent_priority_queue.rb
+- lib/concurrent/concern/deprecation.rb
+- lib/concurrent/concern/dereferenceable.rb
+- lib/concurrent/concern/logging.rb
+- lib/concurrent/concern/obligation.rb
+- lib/concurrent/concern/observable.rb
+- lib/concurrent/concurrent_ruby.jar
+- lib/concurrent/configuration.rb
+- lib/concurrent/constants.rb
+- lib/concurrent/dataflow.rb
+- lib/concurrent/delay.rb
+- lib/concurrent/errors.rb
+- lib/concurrent/exchanger.rb
+- lib/concurrent/executor/abstract_executor_service.rb
+- lib/concurrent/executor/cached_thread_pool.rb
+- lib/concurrent/executor/executor_service.rb
+- lib/concurrent/executor/fixed_thread_pool.rb
+- lib/concurrent/executor/immediate_executor.rb
+- lib/concurrent/executor/indirect_immediate_executor.rb
+- lib/concurrent/executor/java_executor_service.rb
+- lib/concurrent/executor/java_single_thread_executor.rb
+- lib/concurrent/executor/java_thread_pool_executor.rb
+- lib/concurrent/executor/ruby_executor_service.rb
+- lib/concurrent/executor/ruby_single_thread_executor.rb
+- lib/concurrent/executor/ruby_thread_pool_executor.rb
+- lib/concurrent/executor/safe_task_executor.rb
+- lib/concurrent/executor/serial_executor_service.rb
+- lib/concurrent/executor/serialized_execution.rb
+- lib/concurrent/executor/serialized_execution_delegator.rb
+- lib/concurrent/executor/simple_executor_service.rb
+- lib/concurrent/executor/single_thread_executor.rb
+- lib/concurrent/executor/thread_pool_executor.rb
+- lib/concurrent/executor/timer_set.rb
+- lib/concurrent/executors.rb
+- lib/concurrent/future.rb
+- lib/concurrent/hash.rb
+- lib/concurrent/immutable_struct.rb
+- lib/concurrent/ivar.rb
+- lib/concurrent/map.rb
+- lib/concurrent/maybe.rb
+- lib/concurrent/mutable_struct.rb
+- lib/concurrent/mvar.rb
+- lib/concurrent/options.rb
+- lib/concurrent/promise.rb
+- lib/concurrent/promises.rb
+- lib/concurrent/re_include.rb
+- lib/concurrent/scheduled_task.rb
+- lib/concurrent/set.rb
+- lib/concurrent/settable_struct.rb
+- lib/concurrent/synchronization.rb
+- lib/concurrent/synchronization/abstract_lockable_object.rb
+- lib/concurrent/synchronization/abstract_object.rb
+- lib/concurrent/synchronization/abstract_struct.rb
+- lib/concurrent/synchronization/condition.rb
+- lib/concurrent/synchronization/jruby_lockable_object.rb
+- lib/concurrent/synchronization/jruby_object.rb
+- lib/concurrent/synchronization/lock.rb
+- lib/concurrent/synchronization/lockable_object.rb
+- lib/concurrent/synchronization/mri_object.rb
+- lib/concurrent/synchronization/mutex_lockable_object.rb
+- lib/concurrent/synchronization/object.rb
+- lib/concurrent/synchronization/rbx_lockable_object.rb
+- lib/concurrent/synchronization/rbx_object.rb
+- lib/concurrent/synchronization/truffleruby_object.rb
+- lib/concurrent/synchronization/volatile.rb
+- lib/concurrent/thread_safe/synchronized_delegator.rb
+- lib/concurrent/thread_safe/util.rb
+- lib/concurrent/thread_safe/util/adder.rb
+- lib/concurrent/thread_safe/util/cheap_lockable.rb
+- lib/concurrent/thread_safe/util/data_structures.rb
+- lib/concurrent/thread_safe/util/power_of_two_tuple.rb
+- lib/concurrent/thread_safe/util/striped64.rb
+- lib/concurrent/thread_safe/util/volatile.rb
+- lib/concurrent/thread_safe/util/xor_shift_random.rb
+- lib/concurrent/timer_task.rb
+- lib/concurrent/tuple.rb
+- lib/concurrent/tvar.rb
+- lib/concurrent/utility/at_exit.rb
+- lib/concurrent/utility/engine.rb
+- lib/concurrent/utility/monotonic_time.rb
+- lib/concurrent/utility/native_extension_loader.rb
+- lib/concurrent/utility/native_integer.rb
+- lib/concurrent/utility/processor_counter.rb
+- lib/concurrent/version.rb
+homepage: http://www.concurrent-ruby.com
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ruby-concurrency/concurrent-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
+  F#, C#, Java, and classic concurrency patterns.
+test_files: []