concurrent-ruby 0.7.0-java

data/lib/concurrent/tvar.rb

@@ -0,0 +1,248 @@
+require 'set'
+
+module Concurrent
+
+  # A `TVar` is a transactional variable - a single-element container that
+  # is used as part of a transaction - see `Concurrent::atomically`.
+  class TVar
+
+    # Create a new `TVar` with an initial value.
+    def initialize(value)
+      @value = value
+      @version = 0
+      @lock = Mutex.new
+    end
+
+    # Get the value of a `TVar`.
+    def value
+      Concurrent::atomically do
+        Transaction::current.read(self)
+      end
+    end
+
+    # Set the value of a `TVar`.
+    def value=(value)
+      Concurrent::atomically do
+        Transaction::current.write(self, value)
+      end
+    end
+
+    # @!visibility private
+    def unsafe_value # :nodoc:
+      @value
+    end
+
+    # @!visibility private
+    def unsafe_value=(value) # :nodoc:
+      @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
+    end
+
+  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`
+  # 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.
+  # 
+  # 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
+  #   end
+  def atomically
+    raise ArgumentError.new('no block given') unless block_given?
+
+    # Get the current transaction
+
+    transaction = Transaction::current
+
+    # Are we not already in a transaction (not nested)?
+
+    if transaction.nil?
+      # New transaction
+
+      begin
+        # Retry loop
+
+        loop do
+
+          # Create a new transaction
+
+          transaction = Transaction.new
+          Transaction::current = transaction
+
+          # Run the block, aborting on exceptions
+
+          begin
+            result = yield
+          rescue Transaction::AbortError => e
+            transaction.abort
+            result = Transaction::ABORTED
+          rescue => e
+            transaction.abort
+            raise e
+          end
+          # If we can commit, break out of the loop
+
+          if result != Transaction::ABORTED
+            if transaction.commit
+              break result
+            end
+          end
+        end
+      ensure
+        # Clear the current transaction
+
+        Transaction::current = nil
+      end
+    else
+      # Nested transaction - flatten it and just run the block
+
+      yield
+    end
+  end
+
+  # Abort a currently running transaction - see `Concurrent::atomically`.
+  def abort_transaction
+    raise Transaction::AbortError.new
+  end
+
+  module_function :atomically, :abort_transaction
+
+  private
+
+  class Transaction
+
+    ABORTED = Object.new
+
+    ReadLogEntry = Struct.new(:tvar, :version)
+    UndoLogEntry = Struct.new(:tvar, :value)
+
+    AbortError = Class.new(StandardError)
+
+    def initialize
+      @write_set = Set.new
+      @read_log  = []
+      @undo_log  = []
+    end
+
+    def read(tvar)
+      Concurrent::abort_transaction unless valid?
+      @read_log.push(ReadLogEntry.new(tvar, tvar.unsafe_version))
+      tvar.unsafe_value
+    end
+
+    def write(tvar, value)
+      # Have we already written to this TVar?
+
+      unless @write_set.include? tvar
+        # Try to lock the TVar
+
+        unless tvar.unsafe_lock.try_lock
+          # Someone else is writing to this TVar - abort
+          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|
+          if log_entry.tvar == tvar and tvar.unsafe_version > log_entry.version
+            Concurrent::abort_transaction
+          end
+        end
+      end
+
+      # Record the current value of the TVar so we can undo it later
+
+      @undo_log.push(UndoLogEntry.new(tvar, tvar.unsafe_value))
+
+      # Write the new value to the TVar
+
+      tvar.unsafe_value = 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|
+        tvar.unsafe_increment_version
+      end
+
+      unlock
+
+      true
+    end
+
+    def valid?
+      @read_log.each do |log_entry|
+        unless @write_set.include? log_entry.tvar
+          if log_entry.tvar.unsafe_version > log_entry.version
+            return false
+          end
+        end
+      end
+
+      true
+    end
+
+    def unlock
+      @write_set.each do |tvar|
+        tvar.unsafe_lock.unlock
+      end
+    end
+
+    def self.current
+      Thread.current[:current_tvar_transaction]
+    end
+
+    def self.current=(transaction)
+      Thread.current[:current_tvar_transaction] = transaction
+    end
+
+  end
+
+end

data/lib/concurrent/utilities.rb

@@ -0,0 +1,3 @@
+require 'concurrent/utility/processor_count'
+require 'concurrent/utility/timeout'
+require 'concurrent/utility/timer'

data/lib/concurrent/utility/processor_count.rb

@@ -0,0 +1,152 @@
+require 'rbconfig'
+require 'concurrent/delay'
+require 'concurrent/executor/immediate_executor'
+
+module Concurrent
+
+  class ProcessorCounter
+    def initialize
+      immediate_executor        = ImmediateExecutor.new
+      @processor_count          = Delay.new(executor: immediate_executor) { compute_processor_count }
+      @physical_processor_count = Delay.new(executor: immediate_executor) { 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 RUBY_PLATFORM == 'java'
+        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
+
+  # create the default ProcessorCounter on load
+  @processor_counter = ProcessorCounter.new
+  singleton_class.send :attr_reader, :processor_counter
+
+  def self.processor_count
+    processor_counter.processor_count
+  end
+
+  def self.physical_processor_count
+    processor_counter.physical_processor_count
+  end
+
+end

data/lib/concurrent/utility/timeout.rb

@@ -0,0 +1,35 @@
+require 'rbconfig'
+require 'thread'
+
+require 'concurrent/errors'
+
+module Concurrent
+
+  # Wait the given number of seconds for the block operation to complete.
+  #
+  # @param [Integer] seconds The number of seconds to wait
+  #
+  # @return [Object] The result of the block operation
+  #
+  # @raise [Concurrent::TimeoutError] when the block operation does not complete
+  #   in the allotted number of seconds.
+  #
+  # @note This method is intended to be a simpler and more reliable replacement
+  # to the Ruby standard library `Timeout::timeout` method.
+  def timeout(seconds)
+
+    thread = Thread.new do
+      Thread.current[:result] = yield
+    end
+    success = thread.join(seconds)
+
+    if success
+      return thread[:result]
+    else
+      raise TimeoutError
+    end
+  ensure
+    Thread.kill(thread) unless thread.nil?
+  end
+  module_function :timeout
+end

data/lib/concurrent/utility/timer.rb

@@ -0,0 +1,21 @@
+require 'concurrent/configuration'
+require 'thread'
+
+module Concurrent
+
+  # Perform the given operation asynchronously after the given number of seconds.
+  #
+  # @param [Fixnum] seconds the interval in seconds to wait before executing the task
+  #
+  # @yield the task to execute
+  #
+  # @return [Boolean] true
+  def timer(seconds, *args, &block)
+    raise ArgumentError.new('no block given') unless block_given?
+    raise ArgumentError.new('interval must be greater than or equal to zero') if seconds < 0
+
+    Concurrent.configuration.global_timer_set.post(seconds, *args, &block)
+    true
+  end
+  module_function :timer
+end