concurrent-ruby 0.6.0.pre.2 → 0.6.0

data/lib/concurrent/utility/processor_count.rb

@@ -1,125 +1,150 @@
 require 'rbconfig'
+require 'concurrent/delay'
 
 module Concurrent
 
-  # 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
-    if RUBY_PLATFORM == 'java'
-      java.lang.Runtime.getRuntime.availableProcessors
-    else
-      @@processor_count ||= begin
-                              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
+  class ProcessorCounter
+    def initialize
+      @processor_count          = Delay.new { compute_processor_count }
+      @physical_processor_count = Delay.new { compute_physical_processor_count }
     end
-  rescue
-    return 1
+
+    # 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
-  module_function :processor_count
 
-  # 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 ||= begin
-                                     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
-                                   end
-  rescue
-    return 1
+  def self.physical_processor_count
+    processor_counter.physical_processor_count
   end
-  module_function :physical_processor_count
+
 end

data/lib/concurrent/utility/timeout.rb

@@ -1,18 +1,17 @@
 require 'rbconfig'
 require 'thread'
 
-module Concurrent
+require 'concurrent/errors'
 
-  # Error raised when an operations times out.
-  TimeoutError = Class.new(StandardError)
+module Concurrent
 
   # Wait the given number of seconds for the block operation to complete.
   #
   # @param [Integer] seconds The number of seconds to wait
   #
-  # @return The result of the block operation
+  # @return [Object] The result of the block operation
   #
-  # @raise Concurrent::TimeoutError when the block operation does not complete
+  # @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

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.6.0.pre.2'
+  VERSION = '0.6.0'
 end

data/spec/concurrent/actor/postable_shared.rb

@@ -94,7 +94,7 @@ share_examples_for :postable do
     it 'raises Concurrent::Runnable::LifecycleError when not running' do
       expect {
         subject.post!(1, 'Hello World!')
-      }.to raise_error(Concurrent::Runnable::LifecycleError)
+      }.to raise_error(Concurrent::LifecycleError)
     end
 
     it 'blocks for up to the given number of seconds' do

data/spec/concurrent/actress_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+require 'concurrent/actress'
+
+module Concurrent
+  module Actress
+    describe 'Concurrent::Actress' do
+
+      class Ping
+        include Context
+
+        def initialize(queue)
+          @queue = queue
+        end
+
+        def on_message(message)
+          case message
+          when :terminate
+            terminate!
+          when :child
+            AdHoc.spawn(:pong, @queue) { |queue| -> m { queue << m } }
+          else
+            @queue << message
+            message
+          end
+        end
+      end
+
+      # def trace!
+      #   set_trace_func proc { |event, file, line, id, binding, classname|
+      #     # thread = eval('Thread.current', binding).object_id.to_s(16)
+      #     printf "%8s %20s %20s %s %s:%-2d\n", event, id, classname, nil, file, line
+      #   }
+      #   yield
+      # ensure
+      #   set_trace_func nil
+      # end
+
+      #describe 'stress test' do
+        #pending('may cause deadlock which prevents test run from completing.')
+        #1.times do |i|
+          #it format('run %3d', i) do
+            ## puts format('run %3d', i)
+            #Array.new(10).map do
+              #Thread.new do
+                #10.times do
+                  ## trace! do
+                  #queue = Queue.new
+                  #actor = Ping.spawn :ping, queue
+
+                  ## when spawn returns children are set
+                  #Concurrent::Actress::ROOT.send(:core).instance_variable_get(:@children).should include(actor)
+
+                  #actor << 'a' << 1
+                  #queue.pop.should eq 'a'
+                  #actor.ask(2).value.should eq 2
+
+                  #actor.parent.should eq Concurrent::Actress::ROOT
+                  #Concurrent::Actress::ROOT.path.should eq '/'
+                  #actor.path.should eq '/ping'
+                  #child = actor.ask(:child).value
+                  #child.path.should eq '/ping/pong'
+                  #queue.clear
+                  #child.ask(3)
+                  #queue.pop.should eq 3
+
+                  #actor << :terminate
+                  #actor.ask(:blow_up).wait.should be_rejected
+                #end
+              #end
+            #end.each(&:join)
+          #end
+        #end
+      #end
+
+      describe 'spawning' do
+        #describe 'Actress#spawn' do
+          #behaviour = -> v { -> _ { v } }
+          #subjects  = { spawn:                 -> { Actress.spawn(AdHoc, :ping, 'arg', &behaviour) },
+                        #context_spawn:         -> { AdHoc.spawn(:ping, 'arg', &behaviour) },
+                        #spawn_by_hash:         -> { Actress.spawn(class: AdHoc, name: :ping, args: ['arg'], &behaviour) },
+                        #context_spawn_by_hash: -> { AdHoc.spawn(name: :ping, args: ['arg'], &behaviour) } }
+
+          #subjects.each do |desc, subject_definition|
+            #describe desc do
+              #subject &subject_definition
+              #its(:path) { pending('may cause deadlock which prevents test run from completing.'); should eq '/ping' }
+              #its(:parent) { pending('may cause deadlock which prevents test run from completing.'); should eq ROOT }
+              #its(:name) { pending('may cause deadlock which prevents test run from completing.'); should eq 'ping' }
+              #its(:executor) { pending('may cause deadlock which prevents test run from completing.'); should eq Concurrent.configuration.global_task_pool }
+              #its(:reference) { pending('may cause deadlock which prevents test run from completing.'); should eq subject }
+              #it 'returns ars' do
+                #subject.ask!(:anything).should eq 'arg'
+              #end
+            #end
+          #end
+        #end
+
+        it 'terminates on failed initialization' do
+          pending('may cause deadlock which prevents test run from completing.')
+          a = AdHoc.spawn(name: :fail, logger: Concurrent.configuration.no_logger) { raise }
+          a.ask(nil).wait.rejected?.should be_true
+          a.terminated?.should be_true
+        end
+
+        it 'terminates on failed initialization and raises with spawn!' do
+          pending('may cause deadlock which prevents test run from completing.')
+          expect do
+            AdHoc.spawn!(name: :fail, logger: Concurrent.configuration.no_logger) { raise 'm' }
+          end.to raise_error(StandardError, 'm')
+        end
+
+        it 'terminates on failed message processing' do
+          pending('may cause deadlock which prevents test run from completing.')
+          a = AdHoc.spawn(name: :fail, logger: Concurrent.configuration.no_logger) { -> _ { raise } }
+          a.ask(nil).wait.rejected?.should be_true
+          a.terminated?.should be_true
+        end
+      end
+
+      describe 'messaging' do
+        subject { AdHoc.spawn(:add) { c = 0; -> v { c = c + v } } }
+        specify do
+          pending('may cause deadlock which prevents test run from completing.')
+          subject.tell(1).tell(1)
+          subject << 1 << 1
+          subject.ask(0).value!.should eq 4
+        end
+      end
+
+      describe 'children' do
+        let(:parent) do
+          AdHoc.spawn(:parent) do
+            -> message do
+              if message == :child
+                AdHoc.spawn(:child) { -> _ { parent } }
+              else
+                children
+              end
+            end
+          end
+        end
+
+        it 'has children set after a child is created' do
+          pending('may cause deadlock which prevents test run from completing.')
+          child = parent.ask!(:child)
+          parent.ask!(nil).should include(child)
+          child.ask!(nil).should eq parent
+        end
+      end
+
+      describe 'envelope' do
+        subject { AdHoc.spawn(:subject) { -> _ { envelope } } }
+        specify do
+          pending('may cause deadlock which prevents test run from completing.')
+          envelope = subject.ask!('a')
+          envelope.should be_a_kind_of Envelope
+          envelope.message.should eq 'a'
+          envelope.ivar.should be_completed
+          envelope.ivar.value.should eq envelope
+          envelope.sender.should eq Thread.current
+        end
+      end
+
+      describe 'termination' do
+        subject do
+          AdHoc.spawn(:parent) do
+            child = AdHoc.spawn(:child) { -> v { v } }
+            -> v do
+              if v == :terminate
+                terminate!
+              else
+                child
+              end
+            end
+          end
+        end
+
+        it 'terminates with all its children' do
+          pending('may cause deadlock which prevents test run from completing.')
+          child = subject.ask! :child
+          subject.terminated?.should be_false
+          subject.ask(:terminate).wait
+          subject.terminated?.should be_true
+          child.terminated.wait
+          child.terminated?.should be_true
+        end
+      end
+
+    end
+  end
+end