concurrent-ruby 1.0.3.pre3-java → 1.0.4-java

data/lib/concurrent/errors.rb

@@ -30,7 +30,18 @@ module Concurrent
 
   # Raised when an attempt is made to modify an immutable object
   # (such as an `IVar`) after its final state has been set.
-  MultipleAssignmentError = Class.new(Error)
+  class MultipleAssignmentError < Error
+    attr_reader :inspection_data
+
+    def initialize(message = nil, inspection_data = nil)
+      @inspection_data = inspection_data
+      super message
+    end
+
+    def inspect
+      format '%s %s>', super[0..-2], @inspection_data.inspect
+    end
+  end
 
   # Raised by an `Executor` when it is unable to process a given task,
   # possibly because of a reject policy or other internal error.
@@ -43,4 +54,16 @@ module Concurrent
   # Raised when an operation times out.
   TimeoutError = Class.new(Error)
 
+  # Aggregates multiple exceptions.
+  class MultipleErrors < Error
+    attr_reader :errors
+
+    def initialize(errors, message = "#{errors.size} errors")
+      @errors = errors
+      super [*message,
+             *errors.map { |e| [format('%s (%s)', e.message, e.class), *e.backtrace] }.flatten(1)
+            ].join("\n")
+    end
+  end
+
 end

data/lib/concurrent/executor/timer_set.rb

@@ -78,6 +78,7 @@ module Concurrent
       @task_executor  = Options.executor_from_options(opts) || Concurrent.global_io_executor
       @timer_executor = SingleThreadExecutor.new
       @condition      = Event.new
+      @ruby_pid       = $$ # detects if Ruby has forked
       self.auto_terminate = opts.fetch(:auto_terminate, true)
     end
 
@@ -95,6 +96,7 @@ module Concurrent
     # @!visibility private
     def ns_post_task(task)
       return false unless ns_running?
+      ns_reset_if_forked
       if (task.initial_delay) <= 0.01
         task.executor.post{ task.process_task }
       else
@@ -121,11 +123,20 @@ module Concurrent
     #
     # @!visibility private
     def ns_shutdown_execution
+      ns_reset_if_forked
       @queue.clear
       @timer_executor.kill
       stopped_event.set
     end
 
+    def ns_reset_if_forked
+      if $$ != @ruby_pid
+        @queue.clear
+        @condition.reset
+        @ruby_pid = $$
+      end
+    end
+
     # Run a loop and execute tasks in the scheduled order and at the approximate
     # scheduled time. If no tasks remain the thread will exit gracefully so that
     # garbage collection can occur. If there are no ready tasks it will sleep

data/lib/concurrent/hash.rb

@@ -8,7 +8,8 @@ module Concurrent
     #
     #   A thread-safe subclass of Hash. This version locks against the object
     #   itself for every method call, ensuring only one thread can be reading
-    #   or writing at a time. This includes iteration methods like `#each`.
+    #   or writing at a time. This includes iteration methods like `#each`,
+    #   which takes the lock repeatedly when reading an item.
     #
     #   @see http://ruby-doc.org/core-2.2.0/Hash.html Ruby standard library `Hash`
     class Hash < ::Hash;

data/lib/concurrent/map.rb

@@ -171,6 +171,8 @@ module Concurrent
       each_pair {|k, v| yield v}
     end unless method_defined?(:each_value)
 
+    alias_method :each, :each_pair unless method_defined?(:each)
+
     def key(value)
       each_pair {|k, v| return k if v == value}
       nil
@@ -203,7 +205,7 @@ module Concurrent
     undef :freeze
 
     # @!visibility private
-    DEFAULT_OBJ_ID_STR_WIDTH = (2**50).class == Fixnum ? 14 : 7 # we want to look "native", 7 for 32-bit, 14 for 64-bit
+    DEFAULT_OBJ_ID_STR_WIDTH = 0.size == 4 ? 7 : 14 # we want to look "native", 7 for 32-bit, 14 for 64-bit
     # override default #inspect() method: firstly, we don't want to be spilling our guts (i-vars), secondly, MRI backend's
     # #inspect() call on its @backend i-var will bump @backend's iter level while possibly yielding GVL
     def inspect
@@ -227,8 +229,8 @@ module Concurrent
     end
 
     def validate_options_hash!(options)
-      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(Fixnum) || initial_capacity < 0)
-        raise ArgumentError, ":initial_capacity must be a positive Fixnum"
+      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(Integer) || initial_capacity < 0)
+        raise ArgumentError, ":initial_capacity must be a positive Integer"
       end
       if (load_factor = options[:load_factor]) && (!load_factor.kind_of?(Numeric) || load_factor <= 0 || load_factor > 1)
         raise ArgumentError, ":load_factor must be a number between 0 and 1"

data/lib/concurrent/promise.rb

@@ -2,6 +2,7 @@ require 'thread'
 require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/ivar'
+require 'concurrent/executor/safe_task_executor'
 
 require 'concurrent/options'
 
@@ -78,7 +79,7 @@ module Concurrent
   # ```
   #
   # Promises can be chained using the `then` method. The `then` method accepts a
-  # block, to be executed on fulfillment, and a callable argument to be executed
+  # block and an executor, to be executed on fulfillment, and a callable argument to be executed
   # on rejection. The result of the each promise is passed as the block argument
   # to chained promises.
   #
@@ -92,7 +93,7 @@ module Concurrent
   # p = Concurrent::Promise.fulfill(20).
   #     then{|result| result - 10 }.
   #     then{|result| result * 3 }.
-  #     then{|result| result % 5 }.execute
+  #     then(executor: different_executor){|result| result % 5 }.execute
   # ```
   #
   # The initial state of a newly created Promise depends on the state of its parent:
@@ -102,7 +103,7 @@ module Concurrent
   # - if parent is *rejected* the child will be *pending* (but will ultimately be *rejected*)
   #
   # Promises are executed asynchronously from the main thread. By the time a
-  # child Promise finishes nitialization it may be in a different state that its
+  # child Promise finishes intialization it may be in a different state than its
   # parent (by the time a child is created its parent may have completed
   # execution and changed state). Despite being asynchronous, however, the order
   # of execution of Promise objects in a chain (or tree) is strictly defined.
@@ -300,15 +301,18 @@ module Concurrent
     # @param [Proc] rescuer An optional rescue block to be executed if the
     #   promise is rejected.
     #
+    # @param [ThreadPool] executor An optional thread pool executor to be used
+    # in the new Promise
+    #
     # @yield The block operation to be performed asynchronously.
     #
     # @return [Promise] the new promise
-    def then(rescuer = nil, &block)
+    def then(rescuer = nil, executor = @executor, &block)
       raise ArgumentError.new('rescuers and block are both missing') if rescuer.nil? && !block_given?
       block = Proc.new { |result| result } unless block_given?
       child = Promise.new(
         parent: self,
-        executor: @executor,
+        executor: executor,
         on_fulfill: block,
         on_reject: rescuer
       )
@@ -524,7 +528,7 @@ module Concurrent
     # @!visibility private
     def realize(task)
       @executor.post do
-        success, value, reason = SafeTaskExecutor.new(task).execute(*@args)
+        success, value, reason = SafeTaskExecutor.new(task, rescue_exception: true).execute(*@args)
         complete(success, value, reason)
       end
     end

data/lib/concurrent/synchronization/object.rb

@@ -70,8 +70,8 @@ module Concurrent
       # any instance variables with CamelCase names and isn't {.safe_initialization?}.
       def self.ensure_safe_initialization_when_final_fields_are_present
         Object.class_eval do
-          def self.new(*)
-            object = super
+          def self.new(*args, &block)
+            object = super(*args, &block)
           ensure
             has_final_field = object.instance_variables.any? { |v| v.to_s =~ /^@[A-Z]/ }
             if has_final_field && !safe_initialization?

data/lib/concurrent/synchronization/rbx_object.rb

@@ -30,6 +30,7 @@ module Concurrent
 
       def full_memory_barrier
         # Rubinius instance variables are not volatile so we need to insert barrier
+        # TODO (pitr 26-Nov-2015): check comments like ^
         Rubinius.memory_barrier
       end
     end

data/lib/concurrent/synchronization/truffle_object.rb

@@ -14,8 +14,7 @@ module Concurrent
       end
 
       def full_memory_barrier
-        # Rubinius instance variables are not volatile so we need to insert barrier
-        Rubinius.memory_barrier
+        Truffle::System.full_memory_barrier
       end
     end
 

data/lib/concurrent/thread_safe/util.rb

@@ -6,8 +6,10 @@ module Concurrent
     # @!visibility private
     module Util
 
+      # TODO (pitr-ch 15-Oct-2016): migrate to Utility::NativeInteger
       FIXNUM_BIT_SIZE = (0.size * 8) - 2
       MAX_INT         = (2 ** FIXNUM_BIT_SIZE) - 1
+      # TODO (pitr-ch 15-Oct-2016): migrate to Utility::ProcessorCounter
       CPU_COUNT       = 16 # is there a way to determine this?
     end
   end

data/lib/concurrent/timer_task.rb

@@ -9,7 +9,7 @@ require 'concurrent/scheduled_task'
 
 module Concurrent
 
-  # A very common currency pattern is to run a thread that performs a task at
+  # A very common concurrency pattern is to run a thread that performs a task at
   # regular intervals. The thread that performs the task sleeps for the given
   # interval then wakes up and performs the task. Lather, rinse, repeat... This
   # pattern causes two problems. First, it is difficult to test the business
@@ -23,7 +23,7 @@ module Concurrent
   # execution interval. The `TimerTask` thread does not perform the task,
   # however. Instead, the TimerTask launches the task on a separate thread.
   # Should the task experience an unrecoverable crash only the task thread will
-  # crash. This makes the `TimerTask` very fault tolerant Additionally, the
+  # crash. This makes the `TimerTask` very fault tolerant. Additionally, the
   # `TimerTask` thread can respond to the success or failure of the task,
   # performing logging or ancillary operations. `TimerTask` can also be
   # configured with a timeout value allowing it to kill a task that runs too
@@ -41,7 +41,7 @@ module Concurrent
   #
   # The `TimerTask` class includes the `Dereferenceable` mixin module so the
   # result of the last execution is always available via the `#value` method.
-  # Derefencing options can be passed to the `TimerTask` during construction or
+  # Dereferencing options can be passed to the `TimerTask` during construction or
   # at any later time using the `#set_deref_options` method.
   #
   # `TimerTask` supports notification through the Ruby standard library

data/lib/concurrent/tvar.rb

@@ -151,7 +151,7 @@ module Concurrent
     raise Transaction::AbortError.new
   end
 
-  # Leave a transaction without commiting or aborting - see `Concurrent::atomically`.
+  # Leave a transaction without committing or aborting - see `Concurrent::atomically`.
   def leave_transaction
     raise Transaction::LeaveError.new
   end

data/lib/concurrent/utility/engine.rb

@@ -8,7 +8,7 @@ module Concurrent
       end
 
       def on_jruby_9000?
-        on_jruby? && 0 == (JRUBY_VERSION =~ /^9\.0\.0\.0/)
+        on_jruby? && ruby_version(:>=, 9, 0, 0, JRUBY_VERSION)
       end
 
       def on_cruby?
@@ -39,8 +39,8 @@ module Concurrent
         defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
       end
 
-      def ruby_version(comparison, major, minor = 0, patch = 0)
-        result      = (RUBY_VERSION.split('.').map(&:to_i) <=> [major, minor, patch])
+      def ruby_version(comparison, major, minor, patch, version = RUBY_VERSION)
+        result      = (version.split('.').map(&:to_i) <=> [major, minor, patch])
         comparisons = { :== => [0],
                         :>= => [1, 0],
                         :<= => [-1, 0],

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

@@ -28,6 +28,7 @@ module Concurrent
       # 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
@@ -84,27 +85,28 @@ module Concurrent
             result = WIN32OLE.connect("winmgmts://").ExecQuery(
               "select NumberOfLogicalProcessors from Win32_Processor")
             result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
-          elsif File.readable?("/proc/cpuinfo")
-            IO.read("/proc/cpuinfo").scan(/^processor/).size
+          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
+            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
+            IO.popen("/usr/sbin/psrinfo", &:read).scan(/^.*on-*line/).size
           elsif File.executable?("/usr/sbin/ioscan")
-            IO.popen("/usr/sbin/ioscan -kC processor") do |out|
-              out.read.scan(/^.*processor/).size
-            end
+            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")
+            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")
+            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
+            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
+            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
+            IO.popen("/sbin/sysctl -n hw.ncpu", &:read).to_i
           else
+            # TODO (pitr-ch 05-Nov-2016): warn about failures
             1
           end
         end
@@ -115,7 +117,7 @@ module Concurrent
       def compute_physical_processor_count
         ppc = case RbConfig::CONFIG["target_os"]
               when /darwin1/
-                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu").read.to_i
+                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
               when /linux/
                 cores = {} # unique physical ID / core ID combinations
                 phy   = 0

data/lib/concurrent/version.rb

@@ -1,4 +1,4 @@
 module Concurrent
-  VERSION      = '1.0.3.pre3'
-  EDGE_VERSION = '0.2.3.pre3'
+  VERSION      = '1.0.4'
+  EDGE_VERSION = '0.3.0'
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.3.pre3
+  version: 1.0.4
 platform: java
 authors:
 - Jerry D'Antonio
+- Petr Chalupa
 - The Ruby Concurrency Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-06-23 00:00:00.000000000 Z
+date: 2016-12-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -147,6 +148,7 @@ files:
 - 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
 - lib/concurrent_ruby_ext.jar
@@ -160,17 +162,17 @@ 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: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.5
+rubygems_version: 2.6.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.