celluloid 0.12.1.pre → 0.12.1.pre2

data/lib/celluloid.rb

@@ -2,6 +2,7 @@ require 'logger'
 require 'thread'
 require 'timeout'
 require 'set'
+require 'facter'
 
 module Celluloid
   extend self # expose all instance methods as singleton methods
@@ -33,11 +34,18 @@ module Celluloid
 
     # Obtain the number of CPUs in the system
     def cores
-      CPUCounter.cores
+      core_count = Facter.fact(:processorcount).value
+      Integer(core_count)
     end
     alias_method :cpus, :cores
     alias_method :ncpus, :cores
 
+    # Perform a stack dump of all actors to the given output object
+    def stack_dump(output = STDERR)
+      Celluloid::StackDumper.dump(output)
+    end
+    alias_method :dump, :stack_dump
+
     # Define an exception handler for actor crashes
     def exception_handler(&block)
       Logger.exception_handler(&block)
@@ -73,7 +81,17 @@ module Celluloid
   end
 
   # Terminate all actors at exit
-  at_exit { shutdown }
+  at_exit do
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
+      # workaround for MRI bug losing exit status in at_exit block
+      # http://bugs.ruby-lang.org/issues/5218
+      exit_status = $!.status if $!.is_a?(SystemExit)
+      shutdown
+      exit exit_status if exit_status
+    else
+      shutdown
+    end
+  end
 
   # Class methods added to classes which include Celluloid
   module ClassMethods
@@ -402,7 +420,6 @@ require 'celluloid/version'
 
 require 'celluloid/calls'
 require 'celluloid/core_ext'
-require 'celluloid/cpu_counter'
 require 'celluloid/fiber'
 require 'celluloid/fsm'
 require 'celluloid/internal_pool'
@@ -414,6 +431,7 @@ require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
 require 'celluloid/signals'
+require 'celluloid/stack_dumper'
 require 'celluloid/system_events'
 require 'celluloid/task'
 require 'celluloid/thread_handle'
@@ -430,5 +448,6 @@ require 'celluloid/pool_manager'
 require 'celluloid/supervision_group'
 require 'celluloid/supervisor'
 require 'celluloid/notifications'
+require 'celluloid/logging'
 
 require 'celluloid/boot'

data/lib/celluloid/actor.rb

@@ -65,11 +65,9 @@ module Celluloid
           raise DeadActorError, "attempted to call a dead actor"
         end
 
-        if Celluloid.actor? and not Celluloid.exclusive?
-          # The current task will be automatically resumed when we get a response
+        if Thread.current[:task]
           Task.suspend(:callwait).value
         else
-          # Otherwise we're inside a normal thread or exclusive, so block
           response = loop do
             message = Thread.mailbox.receive do |msg|
               msg.respond_to?(:call) and msg.call == call
@@ -221,10 +219,16 @@ module Celluloid
 
     # Execute a code block in exclusive mode.
     def exclusive
-      @exclusive = true
-      yield
-    ensure
-      @exclusive = false
+      if @exclusive
+        yield
+      else
+        begin
+          @exclusive = true
+          yield
+        ensure
+          @exclusive = false
+        end
+      end
     end
 
     # Perform a linking request with another actor
@@ -302,12 +306,11 @@ module Celluloid
 
     # Sleep for the given amount of time
     def sleep(interval)
-      if Celluloid.exclusive?
-        Kernel.sleep(interval)
-      else
-        task = Task.current
+      if task = Thread.current[:task]
         @timers.after(interval) { task.resume }
         Task.suspend :sleeping
+      else
+        Kernel.sleep(interval)
       end
     end
 
@@ -389,7 +392,7 @@ module Celluloid
       if @exclusives && (@exclusives == :all || @exclusives.include?(method_name))
         exclusive { block.call }
       else
-        @task_class.new(:message_handler, &block).resume
+        @task_class.new(task_type, &block).resume
       end
     end
   end

data/lib/celluloid/boot.rb

@@ -1,9 +1,11 @@
 # Things to run after Celluloid is fully loaded
 
 # Configure default systemwide settings
-Celluloid.logger     = Logger.new STDERR
 Celluloid.task_class = Celluloid::TaskFiber
 
 # Launch the notifications fanout actor
 # FIXME: We should set up the supervision hierarchy here
-Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
+Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
+
+Celluloid.logger = Celluloid::IncidentLogger.new
+Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR

data/lib/celluloid/fsm.rb

@@ -84,30 +84,71 @@ module Celluloid
     #
     # Note: making additional state transitions will cancel delayed transitions
     def transition(state_name, options = {})
+      new_state = validate_and_sanitize_new_state(state_name)
+      return unless new_state
+
+      if handle_delayed_transitions(new_state, options[:delay])
+        return @delayed_transition
+      end
+
+      transition_with_callbacks!(new_state)
+    end
+
+    # Immediate state transition with no sanity checks, or callbacks. "Dangerous!"
+    def transition!(state_name)
+      @state = state_name
+    end
+
+    protected
+
+    def validate_and_sanitize_new_state(state_name)
       state_name = state_name.to_sym
-      current_state = self.class.states[@state]
 
-      return if current_state && current_state.name == state_name
+      return if current_state_name == state_name
 
       if current_state and not current_state.valid_transition? state_name
         valid = current_state.transitions.map(&:to_s).join(", ")
         raise ArgumentError, "#{self.class} can't change state from '#{@state}' to '#{state_name}', only to: #{valid}"
       end
 
-      new_state = self.class.states[state_name]
+      new_state = states[state_name]
 
       unless new_state
-        return if state_name == self.class.default_state
+        return if state_name == default_state
         raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
       end
 
-      if options[:delay]
+      new_state
+    end
+
+    def transition_with_callbacks!(state_name)
+      transition! state_name.name
+      state_name.call(self)
+    end
+
+    def states
+      self.class.states
+    end
+
+    def default_state
+      self.class.default_state
+    end
+
+    def current_state
+      states[@state]
+    end
+
+    def current_state_name
+      current_state && current_state.name || ''
+    end
+
+    def handle_delayed_transitions(new_state, delay)
+      if delay
         raise UnattachedError, "can't delay unless attached" unless @actor
         @delayed_transition.cancel if @delayed_transition
 
-        @delayed_transition = @actor.after(options[:delay]) do
-          transition! new_state.name
-          new_state.call(self)
+        @delayed_transition = @actor.after(delay) do
+          transition_with_callbacks!(new_state)
         end
 
         return @delayed_transition
@@ -117,14 +158,6 @@ module Celluloid
         @delayed_transition.cancel
         @delayed_transition = nil
       end
-
-      transition! new_state.name
-      new_state.call(self)
-    end
-
-    # Immediate state transition with no sanity checks. "Dangerous!"
-    def transition!(state_name)
-      @state = state_name
     end
 
     # FSM states as declared by Celluloid::FSM.state

data/lib/celluloid/logging.rb

@@ -0,0 +1,5 @@
+require 'celluloid/logging/log_event'
+require 'celluloid/logging/incident'
+require 'celluloid/logging/ring_buffer'
+require 'celluloid/logging/incident_logger'
+require 'celluloid/logging/incident_reporter'

data/lib/celluloid/logging/incident.rb

@@ -0,0 +1,21 @@
+module Celluloid
+  # Wraps all events and context for a single incident.
+  class Incident
+    attr_accessor :pid
+    attr_accessor :events, :triggering_event
+
+    def initialize(events, triggering_event=nil)
+      @events = events
+      @triggering_event = triggering_event
+      @pid = $$
+    end
+
+    # Merge two incidents together. This may be useful if two incidents occur at the same time.
+    def merge(*other_incidents)
+      merged_events = other_incidents.flatten.inject(events) do |events, incident|
+        events += incident.events
+      end
+      Incident.new(merged_events.sort, triggering_event)
+    end
+  end
+end

data/lib/celluloid/logging/incident_logger.rb

@@ -0,0 +1,129 @@
+require 'logger'
+module Celluloid
+  # A logger that holds all messages in circular buffers, then flushes the buffers
+  # when an event occurs at a configurable severity threshold.
+  #
+  # Unlike ruby's Logger, this class only supports a single progname.
+  class IncidentLogger
+    module Severity
+      include ::Logger::Severity
+
+      TRACE = -1
+
+      def severity_to_string(severity)
+        case severity
+        when TRACE   then 'TRACE'
+        when DEBUG   then 'DEBUG'
+        when INFO    then 'INFO'
+        when WARN    then 'WARN'
+        when ERROR   then 'ERROR'
+        when FATAL   then 'FATAL'
+        when UNKNOWN then 'UNKNOWN'
+        end
+      end
+
+    end
+    include Severity
+
+    # The progname (facility) for this instance.
+    attr_accessor :progname
+
+    # The logging level. Messages below this severity will not be logged at all.
+    attr_accessor :level
+
+    # The incident threshold. Messages at or above this severity will generate an
+    # incident and be published to incident reporters.
+    attr_accessor :threshold
+
+    # The buffer size limit. Each log level will retain this number of messages
+    # at maximum.
+    attr_accessor :sizelimit
+
+    attr_accessor :buffers
+
+    # Create a new IncidentLogger.
+    def initialize(progname=nil, options={})
+      @progname = progname || "default"
+      @level = options[:level] || DEBUG
+      @threshold = options[:threshold] || ERROR
+      @sizelimit = options[:sizelimit] || 100
+
+      @buffer_mutex = Mutex.new
+      @buffers = Hash.new do |progname_hash, progname| 
+        @buffer_mutex.synchronize do
+          progname_hash[progname] = Hash.new do |severity_hash, severity|
+            severity_hash[severity] = RingBuffer.new(@sizelimit)
+          end
+        end
+      end
+
+      # When the IncidentLogger itself encounters an error, it falls back to logging to stderr
+      @fallback_logger = ::Logger.new(STDERR)
+      @fallback_logger.progname = "FALLBACK"
+    end
+
+    # add an event.
+    def add(severity, message=nil, progname=nil, &block)
+      progname ||= @progname
+      severity ||= UNKNOWN
+
+      if severity < @level
+        return event.id
+      end
+
+      if message.nil? && !block_given?
+        message = progname
+        progname = @progname
+      end
+
+      event = LogEvent.new(severity, message, progname, &block)
+
+      @buffers[progname][severity] << event
+
+      if severity >= @threshold
+        begin
+          Celluloid::Notifications.notifier.async.publish(incident_topic, create_incident(event))
+        rescue => ex
+          @fallback_logger.error(ex)
+        end
+      end
+      event.id
+    end
+    alias :log :add
+
+    # See docs for Logger#info
+    def trace   (progname=nil, &block); add(TRACE,   nil, progname, &block); end
+    def debug   (progname=nil, &block); add(DEBUG,   nil, progname, &block); end
+    def info    (progname=nil, &block); add(INFO,    nil, progname, &block); end
+    def warn    (progname=nil, &block); add(WARN,    nil, progname, &block); end
+    def error   (progname=nil, &block); add(ERROR,   nil, progname, &block); end
+    def fatal   (progname=nil, &block); add(FATAL,   nil, progname, &block); end
+    def unknown (progname=nil, &block); add(UNKNOWN, nil, progname, &block); end
+
+    def flush
+      messages = []
+      @buffer_mutex.synchronize do
+        @buffers.each do |progname, severities|
+          severities.each do |severity, buffer|
+            messages += buffer.flush
+          end
+        end
+      end
+      messages.sort
+    end
+    
+    def clear
+      @buffer_mutex.synchronize do
+        @buffers.each { |buffer| buffer.clear }
+      end
+    end
+
+    def create_incident(event=nil)
+      Incident.new(flush, event)
+    end
+
+    def incident_topic
+      "log.incident.#{@progname}"
+    end
+  end
+end

data/lib/celluloid/logging/incident_reporter.rb

@@ -0,0 +1,48 @@
+require 'logger'
+module Celluloid
+  # Subscribes to log incident topics to report on them.
+  class IncidentReporter
+    include Celluloid
+    include Celluloid::Notifications
+
+    # get the time from the event
+    class Formatter < ::Logger::Formatter
+      def call(severity, time, progname, msg)
+        super(severity, msg.time, progname, msg.message)
+      end
+    end
+
+    def initialize(*args)
+      subscribe(/log\.incident/, :report)
+      @logger = ::Logger.new(*args)
+      @logger.formatter = Formatter.new
+      @silenced = false
+    end
+
+    def report(topic, incident)
+      return if @silenced
+
+      header = "INCIDENT"
+      header << " AT #{incident.triggering_event.time}" if incident.triggering_event
+      @logger << header
+      @logger << "\n"
+      @logger << "====================\n"
+      incident.events.each do |event|
+        @logger.add(event.severity, event, event.progname)
+      end
+      @logger << "====================\n"
+    end
+
+    def silence
+      @silenced = true
+    end
+
+    def unsilence
+      @silenced = false
+    end
+
+    def silenced?
+      @silenced
+    end
+  end
+end

data/lib/celluloid/logging/log_event.rb

@@ -0,0 +1,20 @@
+module Celluloid
+  # Wraps a single log event.
+  class LogEvent
+    attr_accessor :id, :severity, :message, :progname, :time
+
+    def initialize(severity, message, progname, time=Time.now, &block)
+      # This id should be ordered. For now relies on Celluloid::UUID to be ordered.
+      # May want to use a generation/counter strategy for independence of uuid.
+      @id = Celluloid::UUID.generate
+      @severity = severity
+      @message = block_given? ? yield : message
+      @progname = progname
+      @time = time
+    end
+
+    def <=>(other)
+      @id <=> other.id
+    end
+  end
+end

data/lib/celluloid/logging/ring_buffer.rb

@@ -0,0 +1,65 @@
+module Celluloid
+  class RingBuffer
+    def initialize(size)
+      @size = size
+      @start = 0
+      @count = 0
+      @buffer = Array.new(size)
+      @mutex = Mutex.new
+    end
+
+    def full?
+      @count == @size
+    end
+
+    def empty?
+      @count == 0
+    end
+
+    def push(value)
+      @mutex.synchronize do
+        stop = (@start + @count) % @size
+        @buffer[stop] = value
+        if full?
+          @start = (@start + 1) % @size
+        else
+          @count += 1
+        end
+        value
+      end
+    end
+    alias :<< :push
+
+    def shift
+      @mutex.synchronize do
+        remove_element
+      end
+    end
+
+    def flush
+      values = []
+      @mutex.synchronize do
+        while !empty?
+          values << remove_element
+        end
+      end
+      values
+    end
+
+    def clear
+      @buffer = Array.new(@size)
+      @start = 0
+      @count = 0
+    end
+
+    private
+
+    def remove_element
+      return nil if empty?
+      value, @buffer[@start] = @buffer[@start], nil
+      @start = (@start + 1) % @size
+      @count -= 1
+      value
+    end
+  end
+end

data/lib/celluloid/stack_dumper.rb

@@ -0,0 +1,45 @@
+module Celluloid
+  module StackDumper
+    def self.dump(output = STDERR)
+      actors  = {}
+      threads = []
+
+      Thread.list.each do |thread|
+        if actor = thread[:actor]
+          actors[actor.subject.object_id] = actor
+        else
+          threads << thread
+        end
+      end
+
+      actors.each do |_, actor|
+        output << "Celluloid::Actor 0x#{actor.subject.object_id.to_s(16)}: #{actor.subject.class}"
+        output << " [#{actor.name}]" if actor.name
+        output << "\n"
+
+        tasks = actor.tasks
+        if tasks.empty?
+          output << "State: Idle (waiting for messages)\n"
+        else
+          output << "State: Running (executing tasks)\n"
+          output << "Tasks:\n"
+
+          tasks.each_with_index do |task, i|
+            output << "  #{i+1}) #{task.class}: #{task.status}\n"
+          end
+        end
+
+        display_backtrace actor.thread, output
+      end
+
+      threads.each do |thread|
+        output << "Thread 0x#{object_id.to_s(16)}:\n"
+        display_backtrace thread, output
+      end
+    end
+
+    def self.display_backtrace(thread, output)
+      output << "\t" << thread.backtrace.join("\n\t") << "\n\n"
+    end
+  end
+end

data/lib/celluloid/task.rb

@@ -2,6 +2,9 @@ require 'celluloid/tasks/task_fiber'
 require 'celluloid/tasks/task_thread'
 
 module Celluloid
+  # Asked to do task-related things outside a task
+  class NotTaskError < StandardError; end
+
   # Trying to resume a dead task
   class DeadTaskError < StandardError; end
 
@@ -11,7 +14,7 @@ module Celluloid
 
     # Obtain the current task
     def self.current
-      Thread.current[:task] or raise "not within a task context"
+      Thread.current[:task] or raise NotTaskError, "not within a task context"
     end
 
     # Suspend the running task, deferring to the scheduler

data/lib/celluloid/thread_handle.rb

@@ -1,8 +1,13 @@
+require 'forwardable'
+
 module Celluloid
   # An abstraction around threads from the InternalPool which ensures we don't
   # accidentally do things to threads which have been returned to the pool,
   # such as, say, killing them
   class ThreadHandle
+    extend Forwardable
+    def_delegators :@thread, :backtrace
+
     def initialize
       @mutex = Mutex.new
       @join  = ConditionVariable.new

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.12.1.pre'
+  VERSION = '0.12.1.pre2'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -422,12 +422,20 @@ shared_context "a Celluloid Actor" do |included_module|
           exclusive?
         end
         exclusive :exclusive_example
+
+        def nested_exclusive_example
+          exclusive { exclusive { nil }; Celluloid.exclusive? }
+        end
       end.new
     end
 
     it "supports exclusive methods" do
       subject.exclusive_example.should be_true
     end
+
+    it "remains in exclusive mode inside nested blocks" do
+      subject.nested_exclusive_example.should be_true
+    end
   end
 
   context "exclusive classes" do

metadata

@@ -1,62 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.12.1.pre
   prerelease: 7
+  version: 0.12.1.pre2
 platform: ruby
 authors:
 - Tony Arcieri
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-09-16 00:00:00.000000000 Z
+date: 2012-10-10 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
-  requirement: &70119222902540 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: &2056 !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
+    none: false
+  requirement: *2056
+  prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: facter
+  version_requirements: &2074 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.12
+    none: false
+  requirement: *2074
   prerelease: false
-  version_requirements: *70119222902540
+  type: :runtime
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70119222902160 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: &2090 !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+    none: false
+  requirement: *2090
   prerelease: false
-  version_requirements: *70119222902160
+  type: :development
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70119222901700 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: &2108 !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+    none: false
+  requirement: *2108
   prerelease: false
-  version_requirements: *70119222901700
+  type: :development
 - !ruby/object:Gem::Dependency
   name: benchmark_suite
-  requirement: &70119222901280 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: &2124 !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+    none: false
+  requirement: *2124
   prerelease: false
-  version_requirements: *70119222901280
-description: Celluloid enables people to build concurrent programs out of concurrent
-  objects just as easily as they build sequential programs out of sequential objects
+  type: :development
+description: Celluloid enables people to build concurrent programs out of concurrent objects just as easily as they build sequential programs out of sequential objects
 email:
 - tony.arcieri@gmail.com
 executables: []
@@ -64,40 +74,46 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/celluloid.rb
 - lib/celluloid/actor.rb
 - lib/celluloid/boot.rb
 - lib/celluloid/calls.rb
 - lib/celluloid/core_ext.rb
-- lib/celluloid/cpu_counter.rb
 - lib/celluloid/fiber.rb
 - lib/celluloid/fsm.rb
 - lib/celluloid/future.rb
 - lib/celluloid/internal_pool.rb
 - lib/celluloid/links.rb
 - lib/celluloid/logger.rb
+- lib/celluloid/logging.rb
 - lib/celluloid/mailbox.rb
 - lib/celluloid/method.rb
 - lib/celluloid/notifications.rb
 - lib/celluloid/pool_manager.rb
-- lib/celluloid/proxies/abstract_proxy.rb
-- lib/celluloid/proxies/actor_proxy.rb
-- lib/celluloid/proxies/async_proxy.rb
-- lib/celluloid/proxies/future_proxy.rb
 - lib/celluloid/receivers.rb
 - lib/celluloid/registry.rb
 - lib/celluloid/responses.rb
 - lib/celluloid/rspec.rb
 - lib/celluloid/signals.rb
+- lib/celluloid/stack_dumper.rb
 - lib/celluloid/supervision_group.rb
 - lib/celluloid/supervisor.rb
 - lib/celluloid/system_events.rb
 - lib/celluloid/task.rb
-- lib/celluloid/tasks/task_fiber.rb
-- lib/celluloid/tasks/task_thread.rb
 - lib/celluloid/thread_handle.rb
 - lib/celluloid/uuid.rb
 - lib/celluloid/version.rb
-- lib/celluloid.rb
+- lib/celluloid/logging/incident.rb
+- lib/celluloid/logging/incident_logger.rb
+- lib/celluloid/logging/incident_reporter.rb
+- lib/celluloid/logging/log_event.rb
+- lib/celluloid/logging/ring_buffer.rb
+- lib/celluloid/proxies/abstract_proxy.rb
+- lib/celluloid/proxies/actor_proxy.rb
+- lib/celluloid/proxies/async_proxy.rb
+- lib/celluloid/proxies/future_proxy.rb
+- lib/celluloid/tasks/task_fiber.rb
+- lib/celluloid/tasks/task_thread.rb
 - spec/support/actor_examples.rb
 - spec/support/example_actor_class.rb
 - spec/support/mailbox_examples.rb
@@ -105,27 +121,28 @@ files:
 homepage: https://github.com/celluloid/celluloid
 licenses:
 - MIT
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.2
-required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
+  none: false
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.10
-signing_key: 
+rubyforge_project:
+rubygems_version: 1.8.15
+signing_key:
 specification_version: 3
 summary: Actor-based concurrent object framework for Ruby
 test_files: []
-has_rdoc: 
+has_rdoc:
+...

data/lib/celluloid/cpu_counter.rb

@@ -1,18 +0,0 @@
-require 'rbconfig'
-
-module Celluloid
-  module CPUCounter
-    case RbConfig::CONFIG['host_os'][/^[A-Za-z]+/]
-    when 'darwin'
-      @cores = Integer(`sysctl hw.ncpu`[/\d+/])
-    when 'linux'
-      @cores = File.read("/proc/cpuinfo").scan(/core id\s+: \d+/).uniq.size
-    when 'mingw', 'mswin'
-      @cores = Integer(`SET NUMBER_OF_PROCESSORS`[/\d+/])
-    else
-      @cores = nil
-    end
-
-    def self.cores; @cores; end
-  end
-end