concurrent-ruby 0.8.0 → 0.9.0.pre2

data/lib/concurrent/executor/ruby_thread_pool_worker.rb

@@ -1,73 +0,0 @@
-require 'thread'
-require 'concurrent/logging'
-
-module Concurrent
-
-  # @!visibility private
-  class RubyThreadPoolWorker
-    include Logging
-
-    # @!visibility private
-    def initialize(queue, parent)
-      @queue = queue
-      @parent = parent
-      @mutex = Mutex.new
-      @last_activity = Time.now.to_f
-      @thread = nil
-    end
-
-    # @!visibility private
-    def dead?
-      return @mutex.synchronize do
-        @thread.nil? ? false : ! @thread.alive?
-      end
-    end
-
-    # @!visibility private
-    def last_activity
-      @mutex.synchronize { @last_activity }
-    end
-
-    def status
-      @mutex.synchronize do
-        return 'not running' if @thread.nil?
-        @thread.status
-      end
-    end
-
-    # @!visibility private
-    def kill
-      @mutex.synchronize do
-        Thread.kill(@thread) unless @thread.nil?
-        @thread = nil
-      end
-    end
-
-    # @!visibility private
-    def run(thread = Thread.current)
-      @mutex.synchronize do
-        raise StandardError.new('already running') unless @thread.nil?
-        @thread = thread
-      end
-
-      loop do
-        task = @queue.pop
-        if task == :stop
-          @thread = nil
-          @parent.on_worker_exit(self)
-          break
-        end
-
-        begin
-          task.last.call(*task.first)
-        rescue => ex
-          # let it fail
-          log DEBUG, ex
-        ensure
-          @last_activity = Time.now.to_f
-          @parent.on_end_task
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/logging.rb

@@ -1,20 +0,0 @@
-require 'logger'
-
-module Concurrent
-  # Include where logging is needed
-  module Logging
-    include Logger::Severity
-
-    # Logs through {Configuration#logger}, it can be overridden by setting @logger
-    # @param [Integer] level one of Logger::Severity constants
-    # @param [String] progname e.g. a path of an Actor
-    # @param [String, nil] message when nil block is used to generate the message
-    # @yieldreturn [String] a message
-    def log(level, progname, message = nil, &block)
-      (@logger || Concurrent.configuration.logger).call level, progname, message, &block
-    rescue => error
-      $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
-          "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
-    end
-  end
-end

data/lib/concurrent/obligation.rb

@@ -1,171 +0,0 @@
-require 'thread'
-require 'timeout'
-
-require 'concurrent/dereferenceable'
-require 'concurrent/atomic/event'
-
-module Concurrent
-
-  module Obligation
-    include Dereferenceable
-
-    # Has the obligation been fulfilled?
-    # @return [Boolean]
-    def fulfilled?
-      state == :fulfilled
-    end
-    alias_method :realized?, :fulfilled?
-
-    # Has the obligation been rejected?
-    # @return [Boolean]
-    def rejected?
-      state == :rejected
-    end
-
-    # Is obligation completion still pending?
-    # @return [Boolean]
-    def pending?
-      state == :pending
-    end
-
-    # Is the obligation still unscheduled?
-    # @return [Boolean]
-    def unscheduled?
-      state == :unscheduled
-    end
-
-    def completed?
-      [:fulfilled, :rejected].include? state
-    end
-
-    def incomplete?
-      [:unscheduled, :pending].include? state
-    end
-
-    # @return [Object] see Dereferenceable#deref
-    def value(timeout = nil)
-      wait timeout
-      deref
-    end
-
-    # wait until Obligation is #complete?
-    # @param [Numeric] timeout the maximum time in second to wait.
-    # @return [Obligation] self
-    def wait(timeout = nil)
-      event.wait(timeout) if timeout != 0 && incomplete?
-      self
-    end
-
-    # wait until Obligation is #complete?
-    # @param [Numeric] timeout the maximum time in second to wait.
-    # @return [Obligation] self
-    # @raise [Exception] when #rejected? it raises #reason
-    def no_error!(timeout = nil)
-      wait(timeout).tap { raise self if rejected? }
-    end
-
-    # @raise [Exception] when #rejected? it raises #reason
-    # @return [Object] see Dereferenceable#deref
-    def value!(timeout = nil)
-      wait(timeout)
-      if rejected?
-        raise self
-      else
-        deref
-      end
-    end
-
-    def state
-      mutex.lock
-      @state
-    ensure
-      mutex.unlock
-    end
-
-    def reason
-      mutex.lock
-      @reason
-    ensure
-      mutex.unlock
-    end
-
-    # @example allows Obligation to be risen
-    #   rejected_ivar = Ivar.new.fail
-    #   raise rejected_ivar
-    def exception(*args)
-      raise 'obligation is not rejected' unless rejected?
-      reason.exception(*args)
-    end
-
-    protected
-
-    # @!visibility private
-    def init_obligation # :nodoc:
-      init_mutex
-      @event = Event.new
-    end
-
-    # @!visibility private
-    def event # :nodoc:
-      @event
-    end
-
-    # @!visibility private
-    def set_state(success, value, reason) # :nodoc:
-      if success
-        @value = value
-        @state = :fulfilled
-      else
-        @reason = reason
-        @state  = :rejected
-      end
-    end
-
-    # @!visibility private
-    def state=(value) # :nodoc:
-      mutex.lock
-      @state = value
-    ensure
-      mutex.unlock
-    end
-
-    # atomic compare and set operation
-    # state is set to next_state only if current state is == expected_current
-    #
-    # @param [Symbol] next_state
-    # @param [Symbol] expected_current
-    # 
-    # @return [Boolean] true is state is changed, false otherwise
-    #
-    # @!visibility private
-    def compare_and_set_state(next_state, expected_current) # :nodoc:
-      mutex.lock
-      if @state == expected_current
-        @state = next_state
-        true
-      else
-        false
-      end
-    ensure
-      mutex.unlock
-    end
-
-    # executes the block within mutex if current state is included in expected_states
-    #
-    # @return block value if executed, false otherwise
-    #
-    # @!visibility private
-    def if_state(*expected_states) # :nodoc:
-      mutex.lock
-      raise ArgumentError.new('no block given') unless block_given?
-
-      if expected_states.include? @state
-        yield
-      else
-        false
-      end
-    ensure
-      mutex.unlock
-    end
-  end
-end

data/lib/concurrent/observable.rb

@@ -1,73 +0,0 @@
-require 'concurrent/atomic/copy_on_notify_observer_set'
-require 'concurrent/atomic/copy_on_write_observer_set'
-
-module Concurrent
-
-  # The [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern) is one of the most useful design pattern.
-  # 
-  # The workflow is very simple:
-  # - an `observer` can register itself to a `subject` via a callback
-  # - many `observers` can be registered to the same `subject`
-  # - the `subject` notifies all registered observers when its status changes
-  # - an `observer` can deregister itself when is no more interested to receive event notifications
-  # 
-  # In a single threaded environment the whole pattern is very easy: the `subject` can use a simple data structure to manage all its subscribed `observer`s and every `observer` can react directly to every event without caring about synchronization.
-  # 
-  # In a multi threaded environment things are more complex.
-  # The `subject` must synchronize the access to its data structure and to do so currently we're using two specialized ObserverSet: CopyOnWriteObserverSet and CopyOnNotifyObserverSet.
-  # 
-  # When implementing and `observer` there's a very important rule to remember: **there are no guarantees about the thread that will execute the callback**
-  # 
-  # Let's take this example
-  # ```
-  # class Observer
-  #   def initialize
-  #     @count = 0
-  #   end
-  # 
-  #   def update
-  #     @count += 1
-  #   end
-  # end
-  # 
-  # obs = Observer.new
-  # [obj1, obj2, obj3, obj4].each { |o| o.add_observer(obs) }
-  # # execute [obj1, obj2, obj3, obj4]
-  # ```
-  # 
-  # `obs` is wrong because the variable `@count` can be accessed by different threads at the same time, so it should be synchronized (using either a Mutex or an AtomicFixum)
-  module Observable
-
-    # @return [Object] the added observer
-    def add_observer(*args, &block)
-      observers.add_observer(*args, &block)
-    end
-
-    # as #add_observer but it can be used for chaining
-    # @return [Observable] self
-    def with_observer(*args, &block)
-      add_observer(*args, &block)
-      self
-    end
-
-    # @return [Object] the deleted observer
-    def delete_observer(*args)
-      observers.delete_observer(*args)
-    end
-
-    # @return [Observable] self
-    def delete_observers
-      observers.delete_observers
-      self
-    end
-
-    # @return [Integer] the observers count
-    def count_observers
-      observers.count_observers
-    end
-
-    protected
-
-    attr_accessor :observers
-  end
-end

data/lib/concurrent/options_parser.rb

@@ -1,52 +0,0 @@
-module Concurrent
-
-  # A mixin module for parsing options hashes related to gem-level configuration.
-  module OptionsParser
-
-    # Get the requested `Executor` based on the values set in the options hash.
-    #
-    # @param [Hash] opts the options defining the requested executor
-    # @option opts [Executor] :executor (`nil`) when set use the given `Executor` instance
-    # @option opts [Boolean] :operation (`false`) when true use the global operation pool
-    # @option opts [Boolean] :task (`true`) when true use the global task pool
-    #
-    # @return [Executor, nil] the requested thread pool, or nil when no option specified
-    def get_executor_from(opts = {})
-      if opts[:executor]
-        opts[:executor]
-      elsif opts[:operation] == true || opts[:task] == false
-        Concurrent.configuration.global_operation_pool
-      elsif opts[:operation] == false || opts[:task] == true
-        Concurrent.configuration.global_task_pool
-      else
-        nil
-      end
-    end
-
-    def get_arguments_from(opts = {})
-      [*opts.fetch(:args, [])]
-    end
-
-    # Get the requested `Executor` based on the values set in the options hash.
-    #
-    # @param [Hash] opts the options defining the requested executor
-    # @option opts [Executor] :task_executor (`nil`) when set use the given `Executor` instance
-    #
-    # @return [Executor] the requested thread pool (default: global task pool)
-    def get_task_executor_from(opts = {})
-      opts[:task_executor] || opts[:executor] || Concurrent.configuration.global_task_pool
-    end
-
-    # Get the requested `Executor` based on the values set in the options hash.
-    #
-    # @param [Hash] opts the options defining the requested executor
-    # @option opts [Executor] :task_executor (`nil`) when set use the given `Executor` instance
-    #
-    # @return [Executor] the requested thread pool (default: global operation pool)
-    def get_operation_executor_from(opts = {})
-      opts[:operation_executor] || opts[:executor] || Concurrent.configuration.global_operation_pool
-    end
-
-    extend self
-  end
-end

data/lib/concurrent/utility/processor_count.rb

@@ -1,152 +0,0 @@
-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