concurrent-ruby 0.7.0.rc0-x86-solaris-2.11

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,150 @@
+require 'rbconfig'
+require 'concurrent/delay'
+
+module Concurrent
+
+  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 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

data/lib/concurrent/version.rb

@@ -0,0 +1,3 @@
+module Concurrent
+  VERSION = '0.7.0.rc0'
+end

data/lib/concurrent_ruby.rb

@@ -0,0 +1 @@
+require 'concurrent'

data/lib/extension_helper.rb

@@ -0,0 +1,9 @@
+require 'rbconfig'
+
+module Concurrent
+  def self.use_c_extensions?
+    host_os = RbConfig::CONFIG['host_os']
+    ruby_name = RbConfig::CONFIG['ruby_install_name']
+    (ruby_name =~ /^ruby$/i || host_os =~ /mswin32/i || host_os =~ /mingw32/i)
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: concurrent-ruby
+version: !ruby/object:Gem::Version
+  version: 0.7.0.rc0
+platform: x86-solaris-2.11
+authors:
+- Jerry D'Antonio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-18 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
+      Inspired by Erlang, Clojure, Go, JavaScript, actors, and classic concurrency patterns.
+email: jerry.dantonio@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.txt
+files:
+- LICENSE.txt
+- README.md
+- ext/concurrent_ruby_ext/atomic_reference.c
+- ext/concurrent_ruby_ext/atomic_reference.h
+- ext/concurrent_ruby_ext/extconf.rb
+- ext/concurrent_ruby_ext/rb_concurrent.c
+- lib/concurrent.rb
+- lib/concurrent/actress.rb
+- lib/concurrent/actress/ad_hoc.rb
+- lib/concurrent/actress/context.rb
+- lib/concurrent/actress/core.rb
+- lib/concurrent/actress/core_delegations.rb
+- lib/concurrent/actress/envelope.rb
+- lib/concurrent/actress/errors.rb
+- lib/concurrent/actress/reference.rb
+- lib/concurrent/actress/type_check.rb
+- lib/concurrent/agent.rb
+- lib/concurrent/async.rb
+- lib/concurrent/atomic.rb
+- lib/concurrent/atomic/atomic_boolean.rb
+- lib/concurrent/atomic/atomic_fixnum.rb
+- lib/concurrent/atomic/condition.rb
+- lib/concurrent/atomic/copy_on_notify_observer_set.rb
+- lib/concurrent/atomic/copy_on_write_observer_set.rb
+- lib/concurrent/atomic/count_down_latch.rb
+- lib/concurrent/atomic/cyclic_barrier.rb
+- lib/concurrent/atomic/event.rb
+- lib/concurrent/atomic/thread_local_var.rb
+- lib/concurrent/atomic_reference/concurrent_update_error.rb
+- lib/concurrent/atomic_reference/delegated_update.rb
+- lib/concurrent/atomic_reference/direct_update.rb
+- lib/concurrent/atomic_reference/jruby.rb
+- lib/concurrent/atomic_reference/mutex_atomic.rb
+- lib/concurrent/atomic_reference/numeric_cas_wrapper.rb
+- lib/concurrent/atomic_reference/rbx.rb
+- lib/concurrent/atomic_reference/ruby.rb
+- lib/concurrent/atomics.rb
+- lib/concurrent/channel/buffered_channel.rb
+- lib/concurrent/channel/channel.rb
+- lib/concurrent/channel/unbuffered_channel.rb
+- lib/concurrent/channel/waitable_list.rb
+- lib/concurrent/channels.rb
+- lib/concurrent/collection/blocking_ring_buffer.rb
+- lib/concurrent/collection/priority_queue.rb
+- lib/concurrent/collection/ring_buffer.rb
+- lib/concurrent/collections.rb
+- lib/concurrent/configuration.rb
+- lib/concurrent/dataflow.rb
+- lib/concurrent/delay.rb
+- lib/concurrent/dereferenceable.rb
+- lib/concurrent/errors.rb
+- lib/concurrent/exchanger.rb
+- lib/concurrent/executor/cached_thread_pool.rb
+- lib/concurrent/executor/executor.rb
+- lib/concurrent/executor/fixed_thread_pool.rb
+- lib/concurrent/executor/immediate_executor.rb
+- lib/concurrent/executor/java_cached_thread_pool.rb
+- lib/concurrent/executor/java_fixed_thread_pool.rb
+- lib/concurrent/executor/java_single_thread_executor.rb
+- lib/concurrent/executor/java_thread_pool_executor.rb
+- lib/concurrent/executor/per_thread_executor.rb
+- lib/concurrent/executor/ruby_cached_thread_pool.rb
+- lib/concurrent/executor/ruby_fixed_thread_pool.rb
+- lib/concurrent/executor/ruby_single_thread_executor.rb
+- lib/concurrent/executor/ruby_thread_pool_executor.rb
+- lib/concurrent/executor/ruby_thread_pool_worker.rb
+- lib/concurrent/executor/safe_task_executor.rb
+- lib/concurrent/executor/serialized_execution.rb
+- lib/concurrent/executor/single_thread_executor.rb
+- lib/concurrent/executor/thread_pool_executor.rb
+- lib/concurrent/executor/timer_set.rb
+- lib/concurrent/executors.rb
+- lib/concurrent/future.rb
+- lib/concurrent/ivar.rb
+- lib/concurrent/logging.rb
+- lib/concurrent/mvar.rb
+- lib/concurrent/obligation.rb
+- lib/concurrent/observable.rb
+- lib/concurrent/options_parser.rb
+- lib/concurrent/promise.rb
+- lib/concurrent/scheduled_task.rb
+- lib/concurrent/supervisor.rb
+- lib/concurrent/timer_task.rb
+- lib/concurrent/tvar.rb
+- lib/concurrent/utilities.rb
+- lib/concurrent/utility/processor_count.rb
+- lib/concurrent/utility/timeout.rb
+- lib/concurrent/utility/timer.rb
+- lib/concurrent/version.rb
+- lib/concurrent_ruby.rb
+- lib/concurrent_ruby_ext.so
+- lib/extension_helper.rb
+homepage: http://www.concurrent-ruby.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
+  F#, C#, Java, and classic concurrency patterns.
+test_files: []