concurrent-ruby 1.0.3.pre3 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e05d432b7c32dd2b17dc4ae322cdb31ac6f2879
-  data.tar.gz: 9a113f7a1d0f9ebca2692c99898442b5cc167075
+  metadata.gz: faedca437c0657830f5b0cf420bbc9fe8a7f9908
+  data.tar.gz: 26114b1a172fdff0a590694d0c417a9ae3e52b5e
 SHA512:
-  metadata.gz: f8e6c46b5155faaa119a94b3a436eaf50c4f08b496403242ab2b65675e0fb6a5196ef3ed1c21e7cad943530e072e078f26b28fce574d12a406cebddcfcf497f1
-  data.tar.gz: 1652f41ad20dd7d3ac04e0b6751a030eaa6b700b063aef7b8df003b0fdc14bcd85d35543a4b4fed338176f4baf831e72e043b5f62da11e792f3c360ad3b4ec8c
+  metadata.gz: ded8d7abaf69a21931f850de692e0b8e34bbd3275ff294a3afe7f3697dd52e3a638a6359f0c5a8ab7b8d60beaecbf9bfc2469868e4a45629c22678975c42f8c8
+  data.tar.gz: 2d9b104c2c7eeb3352aa78dddf6a0c3a1b46752d973409a443cd6b53ed64a948378290a88fbb83a9d292ab12c649deac86a05c1fff5ad51f39169afba9e65673

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+* Trigger execution of flattened delayed futures
+* Avoid forking for processor_count if possible
+* Semaphore Mutex and JRuby parity
+* Adds Map#each as alias to Map#each_pair
+* Fix uninitialized instance variables
+* Make Fixnum, Bignum merger ready
+* Allows Promise#then to receive an executor
+* TimerSet now survives a fork
+* Reject promise on any exception
+* Allow ThreadLocalVar to be initialized with a block
+* Support Alpha with `Concurrent::processor_count`
+* Fixes format-security error when compiling ruby_193_compatible.h
+* Concurrent::Atom#swap fixed: reraise the exceptions from block
+
 ## Current Release v1.0.2 (2 May 2016)
 
 * Fix bug with `Concurrent::Map` MRI backend `#inspect` method

data/README.md

@@ -235,8 +235,8 @@ The best practice is to depend on `concurrent-ruby` and let users to decide if t
 
 ## Maintainers
 
+* [Petr Chalupa](https://github.com/pitr-ch) (lead maintainer)
 * [Jerry D'Antonio](https://github.com/jdantonio) (creator)
-* [Petr Chalupa](https://github.com/pitr-ch)
 * [Michele Della Torre](https://github.com/mighe)
 * [Chris Seaton](https://github.com/chrisseaton)
 * [Paweł Obrok](https://github.com/obrok)

data/lib/concurrent.rb

@@ -65,13 +65,13 @@ require 'concurrent/options'
 #   Object references in Ruby are mutable. This can lead to serious
 #   problems when the {#value} of an object is a mutable reference. Which
 #   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
-#   "primative" data type. Each instance can be configured with a few
+#   "primitive" data type. Each instance can be configured with a few
 #   options that can help protect the program from potentially dangerous
-#   operations. Each of these options can be optionally set when the oject
+#   operations. Each of these options can be optionally set when the object
 #   instance is created:
 #
 #   * `:dup_on_deref` When true the object will call the `#dup` method on
-#     the `value` object every time the `#value` methid is called
+#     the `value` object every time the `#value` method is called
 #     (default: false)
 #   * `:freeze_on_deref` When true the object will call the `#freeze`
 #     method on the `value` object every time the `#value` method is called

data/lib/concurrent/async.rb

@@ -34,7 +34,7 @@ module Concurrent
   # When an Erlang module implements the `gen_server` behavior it becomes
   # inherently asynchronous. The `start` or `start_link` function spawns a
   # process (similar to a thread but much more lightweight and efficient) and
-  # reurns the ID of the process. Using the process ID, other processes can
+  # returns the ID of the process. Using the process ID, other processes can
   # send messages to the `gen_server` via the `cast` and `call` methods. Unlike
   # Erlang's `gen_server`, however, `Async` classes do not support linking or
   # supervision trees.
@@ -142,7 +142,7 @@ module Concurrent
   # practice is to read the instance variable into a local variable at the start
   # of the method then update the instance variable at the *end* of the method.
   # This way, should an exception be raised during method execution the internal
-  # state of the boject will not have been changed.
+  # state of the object will not have been changed.
   #
   # ### Reader Attributes
   #

data/lib/concurrent/atom.rb

@@ -19,7 +19,7 @@ require 'concurrent/synchronization'
 #     the value will undergo frequent reads but only occasional, though complex,
 #     updates. Suitable when the result of an update must be known immediately.
 #   * *{Concurrent::AtomicReference}:* A simple object reference that can be
-#     atomically. Updates are synchronous but fast. Bast used when updates a
+#     atomically. Updates are synchronous but fast. Best used when updates a
 #     simple set operations. Not suitable when updates are complex.
 #     {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
 #     but optimized for the given data type.
@@ -61,7 +61,7 @@ module Concurrent
   #   set + [set[-2..-1].reduce{|sum,x| sum + x }]
   # end
   #
-  # # create an atom with aninitial value
+  # # create an atom with an initial value
   # atom = Concurrent::Atom.new(next_fibonacci)
   #
   # # send a few update requests
@@ -144,7 +144,7 @@ module Concurrent
     # @param [Object] args Zero or more arguments passed to the block.
     #
     # @yield [value, args] Calculates a new value for the atom based on the
-    #   current value and any supplied agruments.
+    #   current value and any supplied arguments.
     # @yieldparam value [Object] The current value of the atom.
     # @yieldparam args [Object] All arguments passed to the function, in order.
     # @yieldreturn [Object] The intended new value of the atom.

data/lib/concurrent/atomic/abstract_thread_local_var.rb

@@ -8,8 +8,17 @@ module Concurrent
   class AbstractThreadLocalVar
 
     # @!macro thread_local_var_method_initialize
-    def initialize(default = nil)
-      @default = default
+    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
+      else
+        @default = default
+      end
+
       allocate_storage
     end
 
@@ -25,7 +34,15 @@ module Concurrent
 
     # @!macro thread_local_var_method_bind
     def bind(value, &block)
-      raise NotImplementedError
+      if block_given?
+        old_value = self.value
+        begin
+          self.value = value
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
     end
 
     protected
@@ -34,5 +51,14 @@ module Concurrent
     def allocate_storage
       raise NotImplementedError
     end
+
+    # @!visibility private
+    def default
+      if @default_block
+        self.value = @default_block.call
+      else
+        @default
+      end
+    end
   end
 end

data/lib/concurrent/atomic/count_down_latch.rb

@@ -72,6 +72,29 @@ module Concurrent
   #   with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
   #
   # @!macro count_down_latch_public_api
+  # @example Waiter and Decrementer
+  #   latch = Concurrent::CountDownLatch.new(3)
+  #
+  #   waiter = Thread.new do
+  #     latch.wait()
+  #     puts ("Waiter released")
+  #   end
+  #
+  #   decrementer = Thread.new do
+  #     sleep(1)
+  #     latch.count_down
+  #     puts latch.count
+  #
+  #     sleep(1)
+  #     latch.count_down
+  #     puts latch.count
+  #
+  #     sleep(1)
+  #     latch.count_down
+  #     puts latch.count
+  #   end
+  #
+  #   [waiter, decrementer].each(&:join)
   class CountDownLatch < CountDownLatchImplementation
   end
 end

data/lib/concurrent/atomic/cyclic_barrier.rb

@@ -1,9 +1,29 @@
 require 'concurrent/synchronization'
+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
@@ -18,9 +38,9 @@ module Concurrent
     #
     # @raise [ArgumentError] if `parties` is not an integer or is less than zero
     def initialize(parties, &block)
-      if !parties.is_a?(Fixnum) || parties < 1
-        raise ArgumentError.new('count must be in integer greater than or equal zero')
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds parties
+      Utility::NativeInteger.ensure_positive_and_no_zero parties
+
       super(&nil)
       synchronize { ns_initialize parties, &block }
     end

data/lib/concurrent/atomic/java_thread_local_var.rb

@@ -13,7 +13,7 @@ if Concurrent.on_jruby?
         value = @var.get
 
         if value.nil?
-          @default
+          default
         elsif value == NULL
           nil
         else
@@ -26,19 +26,6 @@ if Concurrent.on_jruby?
         @var.set(value)
       end
 
-      # @!macro thread_local_var_method_bind
-      def bind(value, &block)
-        if block_given?
-          old_value = @var.get
-          begin
-            @var.set(value)
-            yield
-          ensure
-            @var.set(old_value)
-          end
-        end
-      end
-
       protected
 
       # @!visibility private

data/lib/concurrent/atomic/mutex_atomic_fixnum.rb

@@ -1,4 +1,5 @@
 require 'concurrent/synchronization'
+require 'concurrent/utility/native_integer'
 
 module Concurrent
 
@@ -7,10 +8,6 @@ module Concurrent
   # @!macro internal_implementation_note
   class MutexAtomicFixnum < Synchronization::LockableObject
 
-    # http://stackoverflow.com/questions/535721/ruby-max-integer
-    MIN_VALUE = -(2**(0.size * 8 - 2))
-    MAX_VALUE = (2**(0.size * 8 - 2) - 1)
-
     # @!macro atomic_fixnum_method_initialize
     def initialize(initial = 0)
       super()
@@ -71,21 +68,8 @@ module Concurrent
 
     # @!visibility private
     def ns_set(value)
-      range_check!(value)
+      Utility::NativeInteger.ensure_integer_and_bounds value
       @value = value
     end
-
-    # @!visibility private
-    def range_check!(value)
-      if !value.is_a?(Fixnum)
-        raise ArgumentError.new('value value must be a Fixnum')
-      elsif value > MAX_VALUE
-        raise RangeError.new("#{value} is greater than the maximum value of #{MAX_VALUE}")
-      elsif value < MIN_VALUE
-        raise RangeError.new("#{value} is less than the maximum value of #{MIN_VALUE}")
-      else
-        value
-      end
-    end
   end
 end

data/lib/concurrent/atomic/mutex_count_down_latch.rb

@@ -9,9 +9,9 @@ module Concurrent
 
     # @!macro count_down_latch_method_initialize
     def initialize(count = 1)
-      unless count.is_a?(Fixnum) && count >= 0
-        raise ArgumentError.new('count must be in integer greater than or equal zero')
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds count
+      Utility::NativeInteger.ensure_positive count
+
       super()
       synchronize { ns_initialize count }
     end

data/lib/concurrent/atomic/mutex_semaphore.rb

@@ -1,4 +1,5 @@
 require 'concurrent/synchronization'
+require 'concurrent/utility/native_integer'
 
 module Concurrent
 
@@ -9,18 +10,17 @@ module Concurrent
 
     # @!macro semaphore_method_initialize
     def initialize(count)
-      unless count.is_a?(Fixnum) && count >= 0
-        fail ArgumentError, 'count must be an non-negative integer'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds count
+
       super()
       synchronize { ns_initialize count }
     end
 
     # @!macro semaphore_method_acquire
     def acquire(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds permits
+      Utility::NativeInteger.ensure_positive permits
+
       synchronize do
         try_acquire_timed(permits, nil)
         nil
@@ -45,9 +45,9 @@ module Concurrent
 
     # @!macro semaphore_method_try_acquire
     def try_acquire(permits = 1, timeout = nil)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds permits
+      Utility::NativeInteger.ensure_positive permits
+
       synchronize do
         if timeout.nil?
           try_acquire_now(permits)
@@ -59,9 +59,9 @@ module Concurrent
 
     # @!macro semaphore_method_release
     def release(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds permits
+      Utility::NativeInteger.ensure_positive permits
+
       synchronize do
         @free += permits
         permits.times { ns_signal }
@@ -81,9 +81,9 @@ module Concurrent
     #
     # @!visibility private
     def reduce_permits(reduction)
-      unless reduction.is_a?(Fixnum) && reduction >= 0
-        fail ArgumentError, 'reduction must be an non-negative integer'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds reduction
+      Utility::NativeInteger.ensure_positive reduction
+
       synchronize { @free -= reduction }
       nil
     end

data/lib/concurrent/atomic/ruby_thread_local_var.rb

@@ -35,29 +35,19 @@ module Concurrent
     @@next = 0
     private_constant :FREE, :LOCK, :ARRAYS
 
-    # @!macro [attach] thread_local_var_method_initialize
-    #
-    #   Creates a thread local variable.
-    #
-    #   @param [Object] default the default value when otherwise unset
-    def initialize(default = nil)
-      @default = default
-      allocate_storage
-    end
-
     # @!macro thread_local_var_method_get
     def value
       if array = get_threadlocal_array
         value = array[@index]
         if value.nil?
-          @default
+          default
         elsif value.equal?(NULL)
           nil
         else
           value
         end
       else
-        @default
+        default
       end
     end
 
@@ -76,19 +66,6 @@ module Concurrent
       value
     end
 
-    # @!macro thread_local_var_method_bind
-    def bind(value, &block)
-      if block_given?
-        old_value = self.value
-        begin
-          self.value = value
-          yield
-        ensure
-          self.value = old_value
-        end
-      end
-    end
-
     protected
 
     # @!visibility private
@@ -158,12 +135,20 @@ module Concurrent
       if array = get_threadlocal_array(thread)
         value = array[@index]
         if value.nil?
-          @default
+          default_for(thread)
         elsif value.equal?(NULL)
           nil
         else
           value
         end
+      else
+        default_for(thread)
+      end
+    end
+
+    def default_for(thread)
+      if @default_block
+        raise "Cannot use default_for with default block"
       else
         @default
       end

data/lib/concurrent/atomic/thread_local_var.rb

@@ -11,6 +11,8 @@ module Concurrent
   #   Creates a thread local variable.
   #
   #   @param [Object] default the default value when otherwise unset
+  #   @param [Proc] block Optional block that gets called to obtain the
+  #     default value for each thread
 
   # @!macro [new] thread_local_var_method_get
   #

data/lib/concurrent/concern/obligation.rb

@@ -138,6 +138,7 @@ module Concurrent
       # @!visibility private
       def init_obligation
         @event = Event.new
+        @value = @reason = nil
       end
 
       # @!visibility private

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/condition.rb

@@ -1,5 +1,6 @@
 module Concurrent
   module Synchronization
+    # TODO (pitr-ch 04-Dec-2016): should be in edge
     class Condition < LockableObject
       safe_initialization!
 

data/lib/concurrent/synchronization/lock.rb

@@ -1,5 +1,6 @@
 module Concurrent
   module Synchronization
+    # TODO (pitr-ch 04-Dec-2016): should be in edge
     class Lock < LockableObject
       # TODO use JavaReentrantLock on JRuby
 

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.3'
+  EDGE_VERSION = '0.2.3'
 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.3
 platform: ruby
 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-17 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
 homepage: http://www.concurrent-ruby.com
@@ -164,12 +166,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       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.6.4
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,