celluloid 0.16.0.pre2 → 0.16.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9c58eede0a8ebeb315bf6f2fa925e19173dd5e9
-  data.tar.gz: 525f0ae4823a55ca1e23bf1ff5b6c8493592551f
+  metadata.gz: 4f7aa9e5aa8ef9c2cd0aaabdde975d786214410b
+  data.tar.gz: 993cfb53e3ec7f1c24308bf2339e2e60b63f21df
 SHA512:
-  metadata.gz: 2ac75588d4accd17305ea04b6329563783db6972262584898e3143bdf6086ba47dc8bcf8c93ad6c7a8b44115c2c718fbcc615219da968ffdfa8a7a5f17b5f908
-  data.tar.gz: e1185014388060dcd75a41b583a6df01f7bcbb37e21e1619091e364374cb861a31df7c7110b371887540c2482ff54cfae0cf7a3df534fc188157e220d5f8cd12
+  metadata.gz: 50e59017b92d0f00ff20d1f6a9e8ec436ca751e126df040d3f232d6e96bce43b532e666288f664b5cf2fc19c9bc12ccb45abcac0a6c09c72f0fc33eeb813ccbc
+  data.tar.gz: 95ec24381ebc52700045ecd4aeca559b7f2e4a304526d06198222eb357082dae0c1615afc9612741ca86b2308ff2f3dd0e2f77fae39078387eb3ae2901ba424c

data/lib/celluloid.rb

@@ -7,7 +7,7 @@ module Celluloid
   # Expose all instance methods as singleton methods
   extend self
 
-  VERSION = '0.16.0.pre2'
+  VERSION = '0.16.0.pre3'
 
   # Linking times out after 5 seconds
   LINKING_TIMEOUT = 5

data/lib/celluloid/actor.rb

@@ -112,8 +112,8 @@ module Celluloid
       @tasks     = TaskSet.new
       @links     = Links.new
       @signals   = Signals.new
-      @receivers = Receivers.new
       @timers    = Timers::Group.new
+      @receivers = Receivers.new(@timers)
       @handlers  = Handlers.new
       @running   = false
       @name      = nil
@@ -147,11 +147,15 @@ module Celluloid
     def run
       while @running
         begin
-          message = @mailbox.receive(timeout_interval)
-          handle_message message
-        rescue TimeoutError
-          @timers.fire
-          @receivers.fire_timers
+          @timers.wait do |interval|
+            interval = 0 if interval and interval < 0
+            
+            if message = @mailbox.check(interval)
+              handle_message(message)
+
+              break unless @running
+            end
+          end
         rescue MailboxShutdown
           @running = false
         end
@@ -171,12 +175,10 @@ module Celluloid
     # Perform a linking request with another actor
     def linking_request(receiver, type)
       Celluloid.exclusive do
-        linking_timeout = Timers::Timeout.new(LINKING_TIMEOUT)
-
         receiver.mailbox << LinkingRequest.new(Actor.current, type)
         system_events = []
 
-        linking_timeout.while_time_remaining do |remaining|
+        Timers::Wait.for(LINKING_TIMEOUT) do |remaining|
           begin
             message = @mailbox.receive(remaining) do |msg|
               msg.is_a?(LinkingResponse) &&
@@ -229,20 +231,6 @@ module Celluloid
       end
     end
 
-    # How long to wait until the next timer fires
-    def timeout_interval
-      i1 = @timers.wait_interval
-      i2 = @receivers.wait_interval
-
-      if i1 and i2
-        i1 < i2 ? i1 : i2
-      elsif i1
-        i1
-      else
-        i2
-      end
-    end
-
     # Schedule a block to run at the given time
     def after(interval, &block)
       @timers.after(interval) { task(:timer, &block) }

data/lib/celluloid/evented_mailbox.rb

@@ -37,17 +37,18 @@ module Celluloid
     end
 
     # Receive a message from the Mailbox
-    def receive(timeout = nil, &block)
+    def check(timeout = nil, &block)
       # Get a message if it is available and process it immediately if possible:
       if message = next_message(block)
         return message
       end
 
-      # ... otherwise, run the reactor once, either blocking or will return after the given timeout.
+      # ... otherwise, run the reactor once, either blocking or will return
+      # after the given timeout:
       @reactor.run_once(timeout)
 
-      # This is a hack to get the main Actor#run loop to recompute the timeout:
-      raise TimeoutError
+      # No message was received:
+      return nil
     rescue IOError
       raise MailboxShutdown, "mailbox shutdown called during receive"
     end

data/lib/celluloid/internal_pool.rb

@@ -7,7 +7,10 @@ module Celluloid
 
     def initialize
       @mutex = Mutex.new
-      @threads = []
+      @idle_threads = []
+      @all_threads  = []
+      @busy_size = 0
+      @idle_size = 0
 
       # TODO: should really adjust this based on usage
       @max_idle = 16
@@ -15,17 +18,15 @@ module Celluloid
     end
 
     def busy_size
-      @threads.select(&:busy).size
+      @busy_size
     end
 
     def idle_size
-      @threads.reject(&:busy).size
+      @idle_size
     end
 
     def assert_running
-      unless running?
-        raise Error, "Thread pool is not running"
-      end
+      raise Error, "Thread pool is not running" unless running?
     end
 
     def assert_inactive
@@ -44,17 +45,15 @@ module Celluloid
     end
 
     def active?
-      to_a.any?
+      busy_size + idle_size > 0
     end
 
     def each
-      @threads.each do |thread|
-        yield thread
-      end
+      to_a.each {|thread| yield thread }
     end
 
     def to_a
-      @threads
+      @mutex.synchronize { @all_threads.dup }
     end
 
     # Get a thread from the pool, running the given block
@@ -63,15 +62,16 @@ module Celluloid
         assert_running
 
         begin
-          idle = @threads.reject(&:busy)
-          if idle.empty?
+          if @idle_threads.empty?
             thread = create
           else
-            thread = idle.first
+            thread = @idle_threads.pop
+            @idle_size = @idle_threads.length
           end
         end until thread.status # handle crashed threads
 
         thread.busy = true
+        @busy_size += 1
         thread[:celluloid_queue] << block
         thread
       end
@@ -81,15 +81,46 @@ module Celluloid
     def put(thread)
       @mutex.synchronize do
         thread.busy = false
-        if idle_size >= @max_idle
+        if idle_size + 1 >= @max_idle
           thread[:celluloid_queue] << nil
-          @threads.delete(thread)
+          @busy_size -= 1
+          @all_threads.delete(thread)
         else
+          @idle_threads.push thread
+          @busy_size -= 1
+          @idle_size = @idle_threads.length
           clean_thread_locals(thread)
         end
       end
     end
 
+    def shutdown
+      @mutex.synchronize do
+        finalize
+        @all_threads.each do |thread|
+          thread[:celluloid_queue] << nil
+        end
+        @all_threads.clear
+        @idle_threads.clear
+        @busy_size = 0
+        @idle_size = 0
+      end
+    end
+
+    def kill
+      @mutex.synchronize do
+        finalize
+        @running = false
+
+        @all_threads.shift.kill until @all_threads.empty?
+        @idle_threads.clear
+        @busy_size = 0
+        @idle_size = 0
+      end
+    end
+
+    private
+
     # Create a new thread with an associated queue of procs to run
     def create
       queue = Queue.new
@@ -106,7 +137,8 @@ module Celluloid
       end
 
       thread[:celluloid_queue] = queue
-      @threads << thread
+      # @idle_threads << thread
+      @all_threads << thread
       thread
     end
 
@@ -120,26 +152,6 @@ module Celluloid
       end
     end
 
-    def shutdown
-      @mutex.synchronize do
-        finalize
-        @threads.each do |thread|
-          thread[:celluloid_queue] << nil
-        end
-      end
-    end
-
-    def kill
-      @mutex.synchronize do
-        finalize
-        @running = false
-
-        @threads.shift.kill until @threads.empty?
-      end
-    end
-
-    private
-
     def finalize
       @max_idle = 0
     end

data/lib/celluloid/mailbox.rb

@@ -45,36 +45,39 @@ module Celluloid
       end
     end
 
-    # Receive a message from the Mailbox
-    def receive(timeout = nil, &block)
+    # Receive a message from the Mailbox. May return nil and may return before
+    # the specified timeout.
+    def check(timeout = nil, &block)
       message = nil
 
       @mutex.lock
       begin
         raise MailboxDead, "attempted to receive from a dead mailbox" if @dead
 
-        begin
+        Timers::Wait.for(timeout) do |remaining|
           message = next_message(&block)
 
-          unless message
-            if timeout
-              # TODO: use hitimes/timers instead of Time.now
-              now = Time.now
-              wait_until ||= now + timeout
-              wait_interval = wait_until - now
-              raise(TimeoutError, "mailbox timeout exceeded", nil) if wait_interval <= 0
-            else
-              wait_interval = nil
-            end
-
-            @condition.wait(@mutex, wait_interval)
-          end
-        end until message
-
-        message
+          break message if message
+
+          @condition.wait(@mutex, remaining)
+        end
       ensure
         @mutex.unlock rescue nil
       end
+      
+      return message
+    end
+
+    # Receive a letter from the mailbox. Guaranteed to return a message. If
+    # timeout is exceeded, raise a TimeoutError.
+    def receive(timeout = nil, &block)
+      Timers::Wait.for(timeout) do |remaining|
+        if message = check(timeout, &block)
+          return message
+        end
+      end
+      
+      raise TimeoutError.new("receive timeout exceeded")
     end
 
     # Shut down this mailbox and clean up its contents

data/lib/celluloid/receivers.rb

@@ -5,9 +5,9 @@ require 'timers'
 module Celluloid
   # Allow methods to directly interact with the actor protocol
   class Receivers
-    def initialize
+    def initialize(timers)
       @receivers = Set.new
-      @timers = Timers::Group.new
+      @timers = timers
     end
 
     # Receive an asynchronous message
@@ -29,23 +29,13 @@ module Celluloid
       end
     end
 
-    # How long to wait until the next timer fires
-    def wait_interval
-      @timers.wait_interval
-    end
-
-    # Fire any pending timers
-    def fire_timers
-      @timers.fire
-    end
-
     # Handle incoming messages
     def handle_message(message)
       receiver = @receivers.find { |r| r.match(message) }
       return unless receiver
 
       @receivers.delete receiver
-      @timers.cancel receiver.timer if receiver.timer
+      receiver.timer.cancel if receiver.timer
       receiver.resume message
       message
     end

data/lib/celluloid/tasks.rb

@@ -48,6 +48,8 @@ module Celluloid
           @status = :running
           actor.setup_thread
 
+          name_current_thread thread_metadata
+
           Thread.current[:celluloid_task] = self
           CallChain.current_id = @chain_id
 
@@ -56,6 +58,7 @@ module Celluloid
         rescue Task::TerminatedError
           # Task was explicitly terminated
         ensure
+          name_current_thread nil
           @status = :dead
           actor.tasks.delete self
         end
@@ -147,6 +150,25 @@ module Celluloid
         raise message if $CELLULOID_DEBUG
       end
     end
+
+    private
+
+    def name_current_thread(new_name)
+      return unless RUBY_PLATFORM == "java"
+      if new_name.nil?
+        new_name = Thread.current[:celluloid_original_thread_name]
+        Thread.current[:celluloid_original_thread_name] = nil
+      else
+        Thread.current[:celluloid_original_thread_name] = Thread.current.to_java.getNativeThread.get_name
+      end
+      Thread.current.to_java.getNativeThread.set_name(new_name)
+    end
+
+    def thread_metadata
+      method = @meta && @meta[:method_name] || "<no method>"
+      klass = Thread.current[:celluloid_actor] && Thread.current[:celluloid_actor].behavior.subject.bare_object.class || "<no actor>"
+      format("[Celluloid] %s#%s", klass, method)
+    end
   end
 end
 

data/spec/celluloid/timer_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class EveryActor
+  include Celluloid
+
+  def initialize
+    @trace = []
+    @times = []
+    @start = Time.now
+    
+    every(1) { log(1) }
+    every(2) { log(2) }
+    every(1) { log(11) }
+    every(2) { log(22) }
+  end
+  
+  def log(t)
+    @trace << t
+    
+    offset = Time.now - @start
+    @times << offset
+    
+    # puts "log(#{t}) @ #{offset}"
+  end
+  
+  attr :trace
+  attr :times
+end
+
+describe Celluloid::Actor do
+  it "run every(t) task several times" do
+    Celluloid.boot
+    
+    every_actor = EveryActor.new
+    
+    sleep 5.5
+    
+    times = every_actor.times
+    trace = every_actor.trace
+    
+    Celluloid.shutdown
+    
+    expect(trace.count(1)).to be == 5
+    expect(trace.count(11)).to be == 5
+    expect(trace.count(2)).to be == 2
+    expect(trace.count(22)).to be == 2
+  end
+end

data/spec/support/actor_examples.rb

@@ -285,6 +285,31 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     actor.send('foo').should eq('oof')
   end
 
+  context "when executing under JRuby" do
+    let(:klass) {
+      Class.new do
+        include included_module
+        task_class task_klass
+
+        def current_thread_name
+          java_thread.get_name
+        end
+
+        def java_thread
+          Thread.current.to_java.getNativeThread
+        end
+      end
+    }
+
+    it "sets execution info" do
+      klass.new.current_thread_name.should == "Class#current_thread_name"
+    end
+
+    it "unsets execution info after task completion" do
+      klass.new.java_thread.get_name.should == "<unused>"
+    end
+  end if RUBY_PLATFORM == "java"
+
   context "mocking methods" do
     let(:actor) { actor_class.new "Troy McClure" }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.16.0.pre2
+  version: 0.16.0.pre3
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-23 00:00:00.000000000 Z
+date: 2014-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -184,6 +184,7 @@ files:
 - spec/celluloid/tasks/task_fiber_spec.rb
 - spec/celluloid/tasks/task_thread_spec.rb
 - spec/celluloid/thread_handle_spec.rb
+- spec/celluloid/timer_spec.rb
 - spec/celluloid/uuid_spec.rb
 - spec/spec_helper.rb
 - spec/support/actor_examples.rb
@@ -215,3 +216,4 @@ signing_key:
 specification_version: 4
 summary: Actor-based concurrent object framework for Ruby
 test_files: []
+has_rdoc: