concurrent-ruby 1.1.8 → 1.2.2

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

@@ -1,4 +1,5 @@
 require 'concurrent/thread_safe/util'
+require 'concurrent/utility/engine'
 
 # Shim for TruffleRuby.synchronized
 if Concurrent.on_truffleruby? && !TruffleRuby.respond_to?(:synchronized)
@@ -12,40 +13,28 @@ end
 module Concurrent
   module ThreadSafe
     module Util
-      def self.make_synchronized_on_rbx(klass)
+      def self.make_synchronized_on_cruby(klass)
         klass.class_eval do
-          private
-
-          def _mon_initialize
-            @_monitor = Monitor.new unless @_monitor # avoid double initialisation
+          def initialize(*args, &block)
+            @_monitor = Monitor.new
+            super
           end
 
-          def self.new(*args)
-            obj = super(*args)
-            obj.send(:_mon_initialize)
-            obj
+          def initialize_copy(other)
+            # make sure a copy is not sharing a monitor with the original object!
+            @_monitor = Monitor.new
+            super
           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
+          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
 

data/lib/concurrent-ruby/concurrent/timer_task.rb

@@ -25,9 +25,7 @@ module Concurrent
   # Should the task experience an unrecoverable crash only the task thread will
   # 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
-  # long.
+  # performing logging or ancillary operations.
   #
   # One other advantage of `TimerTask` is that it forces the business logic to
   # be completely decoupled from the concurrency logic. The business logic can
@@ -48,9 +46,7 @@ module Concurrent
   # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
   # Observable} module. On execution the `TimerTask` will notify the observers
   # with three arguments: time of execution, the result of the block (or nil on
-  # failure), and any raised exceptions (or nil on success). If the timeout
-  # interval is exceeded the observer will receive a `Concurrent::TimeoutError`
-  # object as the third argument.
+  # failure), and any raised exceptions (or nil on success).
   #
   # @!macro copy_options
   #
@@ -59,20 +55,18 @@ module Concurrent
   #   task.execute
   #
   #   task.execution_interval #=> 60 (default)
-  #   task.timeout_interval   #=> 30 (default)
   #
   #   # wait 60 seconds...
   #   #=> 'Boom!'
   #
   #   task.shutdown #=> true
   #
-  # @example Configuring `:execution_interval` and `:timeout_interval`
-  #   task = Concurrent::TimerTask.new(execution_interval: 5, timeout_interval: 5) do
+  # @example Configuring `:execution_interval`
+  #   task = Concurrent::TimerTask.new(execution_interval: 5) do
   #          puts 'Boom!'
   #        end
   #
   #   task.execution_interval #=> 5
-  #   task.timeout_interval   #=> 5
   #
   # @example Immediate execution with `:run_now`
   #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
@@ -115,15 +109,13 @@ module Concurrent
   #     def update(time, result, ex)
   #       if result
   #         print "(#{time}) Execution successfully returned #{result}\n"
-  #       elsif ex.is_a?(Concurrent::TimeoutError)
-  #         print "(#{time}) Execution timed out\n"
   #       else
   #         print "(#{time}) Execution failed with error #{ex}\n"
   #       end
   #     end
   #   end
   #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ 42 }
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ 42 }
   #   task.add_observer(TaskObserver.new)
   #   task.execute
   #   sleep 4
@@ -133,7 +125,7 @@ module Concurrent
   #   #=> (2013-10-13 19:09:00 -0400) Execution successfully returned 42
   #   task.shutdown
   #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ sleep }
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ sleep }
   #   task.add_observer(TaskObserver.new)
   #   task.execute
   #
@@ -169,8 +161,6 @@ module Concurrent
     #   @param [Hash] opts the options defining task execution.
     #   @option opts [Integer] :execution_interval number of seconds between
     #     task executions (default: EXECUTION_INTERVAL)
-    #   @option opts [Integer] :timeout_interval number of seconds a task can
-    #     run before it is considered to have failed (default: TIMEOUT_INTERVAL)
     #   @option opts [Boolean] :run_now Whether to run the task immediately
     #     upon instantiation or to wait until the first #  execution_interval
     #     has passed (default: false)
@@ -256,18 +246,14 @@ module Concurrent
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
     def timeout_interval
-      synchronize { @timeout_interval }
+      warn 'TimerTask timeouts are now ignored as these were not able to be implemented correctly'
     end
 
     # @!attribute [rw] timeout_interval
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
     def timeout_interval=(value)
-      if (value = value.to_f) <= 0.0
-        raise ArgumentError.new('must be greater than zero')
-      else
-        synchronize { @timeout_interval = value }
-      end
+      warn 'TimerTask timeouts are now ignored as these were not able to be implemented correctly'
     end
 
     private :post, :<<
@@ -278,7 +264,9 @@ module Concurrent
       set_deref_options(opts)
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
-      self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
+      if opts[:timeout] || opts[:timeout_interval]
+        warn 'TimeTask timeouts are now ignored as these were not able to be implemented correctly'
+      end
       @run_now = opts[:now] || opts[:run_now]
       @executor = Concurrent::SafeTaskExecutor.new(task)
       @running = Concurrent::AtomicBoolean.new(false)
@@ -308,7 +296,6 @@ module Concurrent
     # @!visibility private
     def execute_task(completion)
       return nil unless @running.true?
-      ScheduledTask.execute(timeout_interval, args: [completion], &method(:timeout_task))
       _success, value, reason = @executor.execute(self)
       if completion.try?
         self.value = value
@@ -320,14 +307,5 @@ module Concurrent
       end
       nil
     end
-
-    # @!visibility private
-    def timeout_task(completion)
-      return unless @running.true?
-      if completion.try?
-        schedule_next_task
-        observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
-      end
-    end
   end
 end

data/lib/concurrent-ruby/concurrent/tuple.rb

@@ -23,16 +23,12 @@ module Concurrent
     # The (fixed) size of the tuple.
     attr_reader :size
 
-    # @!visibility private
-    Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : ::Array
-    private_constant :Tuple
-
     # Create a new tuple of the given size.
     #
     # @param [Integer] size the number of elements in the tuple
     def initialize(size)
       @size = size
-      @tuple = tuple = Tuple.new(size)
+      @tuple = tuple = ::Array.new(size)
       i = 0
       while i < size
         tuple[i] = Concurrent::AtomicReference.new

data/lib/concurrent-ruby/concurrent/tvar.rb

@@ -1,5 +1,5 @@
 require 'set'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 
@@ -15,7 +15,6 @@ module Concurrent
     # Create a new `TVar` with an initial value.
     def initialize(value)
       @value = value
-      @version = 0
       @lock = Mutex.new
     end
 
@@ -43,16 +42,6 @@ module Concurrent
       @value = value
     end
 
-    # @!visibility private
-    def unsafe_version # :nodoc:
-      @version
-    end
-
-    # @!visibility private
-    def unsafe_increment_version # :nodoc:
-      @version += 1
-    end
-
     # @!visibility private
     def unsafe_lock # :nodoc:
       @lock
@@ -160,57 +149,44 @@ module Concurrent
 
   private
 
+  # @!visibility private
   class Transaction
 
     ABORTED = ::Object.new
 
-    ReadLogEntry = Struct.new(:tvar, :version)
+    OpenEntry = Struct.new(:value, :modified)
 
     AbortError = Class.new(StandardError)
     LeaveError = Class.new(StandardError)
 
     def initialize
-      @read_log  = []
-      @write_log = {}
+      @open_tvars = {}
     end
 
     def read(tvar)
-      Concurrent::abort_transaction unless valid?
-
-      if @write_log.has_key? tvar
-        @write_log[tvar]
-      else
-        @read_log.push(ReadLogEntry.new(tvar, tvar.unsafe_version))
-        tvar.unsafe_value
-      end
+      entry = open(tvar)
+      entry.value
     end
 
     def write(tvar, value)
-      # Have we already written to this TVar?
+      entry = open(tvar)
+      entry.modified = true
+      entry.value = value
+    end
 
-      if @write_log.has_key? tvar
-        # Record the value written
-        @write_log[tvar] = value
-      else
-        # Try to lock the TVar
+    def open(tvar)
+      entry = @open_tvars[tvar]
 
+      unless entry
         unless tvar.unsafe_lock.try_lock
-          # Someone else is writing to this TVar - abort
           Concurrent::abort_transaction
         end
 
-        # Record the value written
-  
-        @write_log[tvar] = value
-
-        # If we previously read from it, check the version hasn't changed
-
-        @read_log.each do |log_entry|
-          if log_entry.tvar == tvar and tvar.unsafe_version > log_entry.version
-            Concurrent::abort_transaction
-          end
-        end
+        entry = OpenEntry.new(tvar.unsafe_value, false)
+        @open_tvars[tvar] = entry
       end
+
+      entry
     end
 
     def abort
@@ -218,32 +194,17 @@ module Concurrent
     end
 
     def commit
-      return false unless valid?
-
-      @write_log.each_pair do |tvar, value|
-        tvar.unsafe_value = value
-        tvar.unsafe_increment_version
-      end
-
-      unlock
-
-      true
-    end
-
-    def valid?
-      @read_log.each do |log_entry|
-        unless @write_log.has_key? log_entry.tvar
-          if log_entry.tvar.unsafe_version > log_entry.version
-            return false
-          end
+      @open_tvars.each do |tvar, entry|
+        if entry.modified
+          tvar.unsafe_value = entry.value
         end
       end
 
-      true
+      unlock
     end
 
     def unlock
-      @write_log.each_key do |tvar|
+      @open_tvars.each_key do |tvar|
         tvar.unsafe_lock.unlock
       end
     end

data/lib/concurrent-ruby/concurrent/utility/engine.rb

@@ -1,26 +1,19 @@
 module Concurrent
+  # @!visibility private
   module Utility
 
     # @!visibility private
     module EngineDetector
-      def on_jruby?
-        ruby_engine == 'jruby'
-      end
-
-      def on_jruby_9000?
-        on_jruby? && ruby_version(JRUBY_VERSION, :>=, 9, 0, 0)
-      end
-
       def on_cruby?
-        ruby_engine == 'ruby'
+        RUBY_ENGINE == 'ruby'
       end
 
-      def on_rbx?
-        ruby_engine == 'rbx'
+      def on_jruby?
+        RUBY_ENGINE == 'jruby'
       end
 
       def on_truffleruby?
-        ruby_engine == 'truffleruby'
+        RUBY_ENGINE == 'truffleruby'
       end
 
       def on_windows?
@@ -35,10 +28,6 @@ module Concurrent
         !(RbConfig::CONFIG['host_os'] =~ /linux/).nil?
       end
 
-      def ruby_engine
-        defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
-      end
-
       def ruby_version(version = RUBY_VERSION, comparison, major, minor, patch)
         result      = (version.split('.').map(&:to_i) <=> [major, minor, patch])
         comparisons = { :== => [0],

data/lib/concurrent-ruby/concurrent/utility/monotonic_time.rb

@@ -1,58 +1,19 @@
-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.
+  #   Returns the current time as tracked by the application monotonic clock.
+  #
+  #   @param [Symbol] unit the time unit to be returned, can be either
+  #     :float_second, :float_millisecond, :float_microsecond, :second,
+  #     :millisecond, :microsecond, or :nanosecond default to :float_second.
   #
   #   @return [Float] The current monotonic time since some unspecified
   #     starting point
   #
   #   @!macro monotonic_clock_warning
-  def monotonic_time
-    GLOBAL_MONOTONIC_CLOCK.get_time
+  def monotonic_time(unit = :float_second)
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
   end
-
   module_function :monotonic_time
 end

data/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb

@@ -1,9 +1,10 @@
 require 'concurrent/utility/engine'
+# Synchronization::AbstractObject must be defined before loading the extension
+require 'concurrent/synchronization/abstract_object'
 
 module Concurrent
-
+  # @!visibility private
   module Utility
-
     # @!visibility private
     module NativeExtensionLoader
 
@@ -15,15 +16,7 @@ module Concurrent
         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"
@@ -54,6 +47,10 @@ module Concurrent
         @c_extensions_loaded = true
       end
 
+      def java_extensions_loaded?
+        defined?(@java_extensions_loaded) && @java_extensions_loaded
+      end
+
       def set_java_extensions_loaded
         @java_extensions_loaded = true
       end
@@ -77,3 +74,4 @@ module Concurrent
   extend Utility::NativeExtensionLoader
 end
 
+Concurrent.load_native_extensions

data/lib/concurrent-ruby/concurrent/utility/native_integer.rb

@@ -1,4 +1,5 @@
 module Concurrent
+  # @!visibility private
   module Utility
     # @private
     module NativeInteger

data/lib/concurrent-ruby/concurrent/utility/processor_counter.rb

@@ -3,6 +3,7 @@ require 'rbconfig'
 require 'concurrent/delay'
 
 module Concurrent
+  # @!visibility private
   module Utility
 
     # @!visibility private
@@ -12,64 +13,10 @@ module Concurrent
         @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.
-      #
-      # Ruby's Etc.nprocessors will be used if available (MRI 2.2+).
-      #
-      # 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
@@ -79,47 +26,14 @@ module Concurrent
       def compute_processor_count
         if Concurrent.on_jruby?
           java.lang.Runtime.getRuntime.availableProcessors
-        elsif Etc.respond_to?(:nprocessors) && (nprocessor = Etc.nprocessors rescue nil)
-          nprocessor
         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
+          Etc.nprocessors
         end
-      rescue
-        return 1
       end
 
       def compute_physical_processor_count
         ppc = case RbConfig::CONFIG["target_os"]
-              when /darwin1/
+              when /darwin\d\d/
                 IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
               when /linux/
                 cores = {} # unique physical ID / core ID combinations
@@ -153,10 +67,43 @@ module Concurrent
   @processor_counter = Utility::ProcessorCounter.new
   singleton_class.send :attr_reader, :processor_counter
 
+  # 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.
+  #
+  # Otherwise Ruby's Etc.nprocessors will be used.
+  #
+  # @return [Integer] number of processors seen by the OS or Java runtime
+  #
+  # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
   def self.processor_count
     processor_counter.processor_count
   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 self.physical_processor_count
     processor_counter.physical_processor_count
   end

data/lib/concurrent-ruby/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION      = '1.1.8'
+  VERSION = '1.2.2'
 end