concurrent-ruby 0.8.0 → 0.9.0.pre2

data/lib/concurrent/tvar.rb

@@ -57,28 +57,31 @@ module Concurrent
   end
 
   # Run a block that reads and writes `TVar`s as a single atomic transaction.
-  # With respect to the value of `TVar` objects, the transaction is atomic,
-  # in that it either happens or it does not, consistent, in that the `TVar`
+  # With respect to the value of `TVar` objects, the transaction is atomic, in
+  # that it either happens or it does not, consistent, in that the `TVar`
   # objects involved will never enter an illegal state, and isolated, in that
   # transactions never interfere with each other. You may recognise these
   # properties from database transactions.
-  # 
+  #
   # There are some very important and unusual semantics that you must be aware of:
-  # 
-  # *   Most importantly, the block that you pass to atomically may be executed more than once. In most cases your code should be free of side-effects, except for via TVar.
-  # 
-  # *   If an exception escapes an atomically block it will abort the transaction.
-  # 
-  # *   It is undefined behaviour to use callcc or Fiber with atomically.
-  # 
-  # *   If you create a new thread within an atomically, it will not be part of the transaction. Creating a thread counts as a side-effect.
-  # 
+  #
+  # * Most importantly, the block that you pass to atomically may be executed
+  #     more than once. In most cases your code should be free of
+  #     side-effects, except for via TVar.
+  #
+  # * If an exception escapes an atomically block it will abort the transaction.
+  #
+  # * It is undefined behaviour to use callcc or Fiber with atomically.
+  #
+  # * If you create a new thread within an atomically, it will not be part of
+  #     the transaction. Creating a thread counts as a side-effect.
+  #
   # Transactions within transactions are flattened to a single transaction.
-  # 
+  #
   # @example
   #   a = new TVar(100_000)
   #   b = new TVar(100)
-  #   
+  #
   #   Concurrent::atomically do
   #     a.value -= 10
   #     b.value += 10
@@ -112,6 +115,9 @@ module Concurrent
           rescue Transaction::AbortError => e
             transaction.abort
             result = Transaction::ABORTED
+          rescue Transaction::LeaveError => e
+            transaction.abort
+            break result
           rescue => e
             transaction.abort
             raise e
@@ -141,7 +147,12 @@ module Concurrent
     raise Transaction::AbortError.new
   end
 
-  module_function :atomically, :abort_transaction
+  # Leave a transaction without commiting or aborting - see `Concurrent::atomically`.
+  def leave_transaction
+    raise Transaction::LeaveError.new
+  end
+
+  module_function :atomically, :abort_transaction, :leave_transaction
 
   private
 
@@ -150,26 +161,30 @@ module Concurrent
     ABORTED = Object.new
 
     ReadLogEntry = Struct.new(:tvar, :version)
-    UndoLogEntry = Struct.new(:tvar, :value)
 
     AbortError = Class.new(StandardError)
+    LeaveError = Class.new(StandardError)
 
     def initialize
-      @write_set = Set.new
       @read_log  = []
-      @undo_log  = []
+      @write_log = {}
     end
 
     def read(tvar)
       Concurrent::abort_transaction unless valid?
-      @read_log.push(ReadLogEntry.new(tvar, tvar.unsafe_version))
-      tvar.unsafe_value
+
+      if @write_log.has_key? tvar
+        @write_log[tvar]
+      else
+        @read_log.push(ReadLogEntry.new(tvar, tvar.unsafe_version))
+        tvar.unsafe_value
+      end
     end
 
     def write(tvar, value)
       # Have we already written to this TVar?
 
-      unless @write_set.include? tvar
+      unless @write_log.has_key? tvar
         # Try to lock the TVar
 
         unless tvar.unsafe_lock.try_lock
@@ -177,10 +192,6 @@ module Concurrent
           Concurrent::abort_transaction
         end
 
-        # We've locked it - add it to the write set
-
-        @write_set.add(tvar)
-
         # If we previously wrote to it, check the version hasn't changed
 
         @read_log.each do |log_entry|
@@ -190,27 +201,20 @@ module Concurrent
         end
       end
 
-      # Record the current value of the TVar so we can undo it later
+      # Record the value written
 
-      @undo_log.push(UndoLogEntry.new(tvar, tvar.unsafe_value))
-
-      # Write the new value to the TVar
-
-      tvar.unsafe_value = value
+      @write_log[tvar] = value
     end
 
     def abort
-      @undo_log.each do |entry|
-        entry.tvar.unsafe_value = entry.value
-      end
-
       unlock
     end
 
     def commit
       return false unless valid?
 
-      @write_set.each do |tvar|
+      @write_log.each_pair do |tvar, value|
+        tvar.unsafe_value = value
         tvar.unsafe_increment_version
       end
 
@@ -221,7 +225,7 @@ module Concurrent
 
     def valid?
       @read_log.each do |log_entry|
-        unless @write_set.include? log_entry.tvar
+        unless @write_log.has_key? log_entry.tvar
           if log_entry.tvar.unsafe_version > log_entry.version
             return false
           end
@@ -232,7 +236,7 @@ module Concurrent
     end
 
     def unlock
-      @write_set.each do |tvar|
+      @write_log.each_key do |tvar|
         tvar.unsafe_lock.unlock
       end
     end

data/lib/concurrent/utilities.rb

@@ -1,3 +1,5 @@
-require 'concurrent/utility/processor_count'
+# DEPRECATED Remove this file at v1.0
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/utility/processor_counter'
 require 'concurrent/utility/timeout'
 require 'concurrent/utility/timer'

data/lib/concurrent/utility/at_exit.rb

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

data/lib/concurrent/utility/engine.rb

@@ -0,0 +1,40 @@
+module Concurrent
+  module Utility
+
+    # @!visibility private
+    module EngineDetector
+      def on_jruby?
+        ruby_engine == 'jruby'
+      end
+
+      def on_jruby_9000?
+        on_jruby? && 0 == (JRUBY_VERSION =~ /^9\.0\.0\.0/)
+      end
+
+      def on_cruby?
+        ruby_engine == 'ruby'
+      end
+
+      def on_rbx?
+        ruby_engine == 'rbx'
+      end
+
+      def ruby_engine
+        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])
+        comparisons = { :== => [0],
+                        :>= => [1, 0],
+                        :<= => [-1, 0],
+                        :>  => [1],
+                        :<  => [-1] }
+        comparisons.fetch(comparison).include? result
+      end
+    end
+  end
+
+  # @!visibility private
+  extend Utility::EngineDetector
+end

data/lib/concurrent/utility/monotonic_time.rb

@@ -0,0 +1,59 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  class_definition = Class.new(Synchronization::Object) do
+    def initialize
+      super()
+      @last_time = Time.now.to_f
+      ensure_ivar_visibility!
+    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 [attach] monotonic_get_time
+  # 
+  #   Returns the current time a tracked by the application monotonic clock.
+  #
+  #   @return [Float] The current monotonic time when `since` not given else
+  #     the elapsed monotonic time between `since` and the current time
+  #
+  #   @!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,56 @@
+require 'concurrent/synchronization/abstract_object' # for JRuby
+require 'concurrent/utility/engine'
+
+module Concurrent
+  module Utility
+
+    # @!visibility private
+    module NativeExtensionLoader
+
+      @c_ext_loaded    ||= false
+      @java_ext_loaded ||= false
+
+      # @!visibility private
+      def allow_c_extensions?
+        Concurrent.on_cruby?
+      end
+
+      if Concurrent.on_cruby? && !@c_ext_loaded
+        tries = [
+          lambda do
+            require 'concurrent/extension'
+            @c_ext_loaded = true
+          end,
+          lambda do
+            # may be a Windows cross-compiled native gem
+            require "concurrent/#{RUBY_VERSION[0..2]}/extension"
+            @c_ext_loaded = true
+          end,
+          lambda do
+            warn 'Performance on MRI may be improved with the concurrent-ruby-ext gem. Please see http://concurrent-ruby.com'
+          end]
+
+        tries.each do |try|
+          begin
+            try.call
+            break
+          rescue LoadError
+            next
+          end
+        end
+      end
+
+      if Concurrent.on_jruby? && !@java_ext_loaded
+        begin
+          require 'concurrent_ruby_ext'
+          @java_ext_loaded = true
+        rescue LoadError
+          warn 'Performance on JRuby may be improved by installing the pre-compiled Java extensions. Please see http://concurrent-ruby.com'
+        end
+      end
+    end
+  end
+
+  # @!visibility private
+  extend Utility::NativeExtensionLoader
+end

data/lib/concurrent/utility/processor_counter.rb

@@ -0,0 +1,156 @@
+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
+      # * 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")
+            IO.read("/proc/cpuinfo").scan(/^processor/).size
+          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") do |out|
+              out.read.scan(/^.*processor/).size
+            end
+          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
+            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