timers 3.0.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b1ffcb7b42d35c2139deec0e9c80e51de965726
-  data.tar.gz: 16f73387c90dcc417750ddd350e99dd99488d6cc
+  metadata.gz: aa56588795590f6b0772c42830b2969d4c18c31b
+  data.tar.gz: 203a266076597db814652c1b1e8d25fdca6808b2
 SHA512:
-  metadata.gz: 8a6fe65d356cdf4ff49e68bc6a566c73f8b0028cbd7ffe9f9acafc677326d5d671e018baaf2b457c44add0cb4fb68ff1b2233df77f6e87ff1d6e036dab7637da
-  data.tar.gz: 87196f70fcfbca7cac3b97d73daaab1cad153b2a8485ecd234bf0654fc1284466bacbaef0a8fe991a8b7fd050ab7fad763d7df9dabec388c019a1c283000e61d
+  metadata.gz: cf717b2718394941dc03bd9bd4184a790116fff7e936b07227fe64cec0d7801ff84903ba23efd5332751919d3a9acbbff95c3a1b53f8c150cd67a94c78531763
+  data.tar.gz: 26d41eddf5f924ac26860a09daba9af79203f32f0f7cefc93cafc5a46ffd95ad959f0281c6dbe619ca3ad8087c63e16c87ef1e860d297f6c30e98da3562c5be0

data/CHANGES.md

@@ -1,8 +1,16 @@
-3.0.1 (2013-06-27)
+4.0.0 (2014-07-27)
+------------------
+* Replace Timers::Timeout with Timers::Wait
+* Timers::Group#wait_interval now returns nil when no timers, a postive or
+  negative interval which if positive is the amount of time required to wait
+  and if negative, how far in the past the latest timer should have fired
+* Performance improvements
+
+3.0.1 (2014-06-27)
 ------------------
 * Require 'set' automatically
 
-3.0.0 (2013-06-14)
+3.0.0 (2014-06-14)
 ------------------
 * Refactor `Timers` class into `Timers::Group`
 * Add `Timers::Timeout` class for implementing timeouts

data/Gemfile

@@ -4,3 +4,7 @@ gem 'coveralls', :require => false
 
 # Specify your gem's dependencies in timers.gemspec
 gemspec
+
+unless RUBY_PLATFORM =~ /java/ 
+  gem "ruby-prof", :group => :development
+end

data/README.md

@@ -5,8 +5,8 @@ Timers
 [![Code Climate](https://codeclimate.com/github/celluloid/timers.png)](https://codeclimate.com/github/celluloid/timers)
 [![Coverage Status](https://coveralls.io/repos/celluloid/timers/badge.png?branch=master)](https://coveralls.io/r/celluloid/timers)
 
-Pure Ruby timer collections. Schedule several procs to fire after configurable
-delays or at periodic intervals.
+Ruby timer collections. Schedule several procs to fire after configurable delays
+or at periodic intervals.
 
 This gem is especially useful when you are faced with an API that accepts a
 single timeout but you want to run multiple timers on top of it. An example of
@@ -16,15 +16,15 @@ Ruby library for using system calls like epoll and kqueue.
 Usage
 -----
 
-Create a new timer group with `Timers.new`:
+Create a new timer group with `Timers::Group.new`:
 
 ```ruby
 require 'timers'
 
-timers = Timers.new
+timers = Timers::Group.new
 ```
 
-Schedule a proc to run after 5 seconds with `Timers#after`:
+Schedule a proc to run after 5 seconds with `Timers::Group#after`:
 
 ```ruby
 five_second_timer = timers.after(5) { puts "Take five" }
@@ -33,7 +33,7 @@ five_second_timer = timers.after(5) { puts "Take five" }
 The `five_second_timer` variable is now bound to a Timers::Timer object. To
 cancel a timer, use `Timers::Timer#cancel`
 
-Once you've scheduled a timer, you can wait until the next timer fires with `Timers#wait`:
+Once you've scheduled a timer, you can wait until the next timer fires with `Timers::Group#wait`:
 
 ```ruby
 # Waits 5 seconds
@@ -42,7 +42,7 @@ timers.wait
 # The script will now print "Take five"
 ```
 
-You can schedule a block to run periodically with `Timers#every`:
+You can schedule a block to run periodically with `Timers::Group#every`:
 
 ```ruby
 every_five_seconds = timers.every(5) { puts "Another 5 seconds" }
@@ -51,8 +51,8 @@ loop { timers.wait }
 ```
 
 If you'd like another method to do the waiting for you, e.g. `Kernel.select`,
-you can use `Timers#wait_interval` to obtain the amount of time to wait. When
-a timeout is encountered, you can fire all pending timers with `Timers#fire`:
+you can use `Timers::Group#wait_interval` to obtain the amount of time to wait. When
+a timeout is encountered, you can fire all pending timers with `Timers::Group#fire`:
 
 ```ruby
 loop do
@@ -77,13 +77,13 @@ paused_timer = timers.every(5) { puts "I was paused" }
 paused_timer.pause
 10.times { timers.wait } # will not fire paused timer
 
-paused_timer.continue
+paused_timer.resume
 10.times { timers.wait } # will fire timer
 
 timers.pause
 10.times { timers.wait } # will not fire any timers
 
-timers.continue
+timers.resume
 10.times { timers.wait } # will fire all timers
 ```
 

data/lib/timers.rb

@@ -1,10 +1,5 @@
 
-# Workaround for thread safety issues in SortedSet initialization
-# See: https://github.com/celluloid/timers/issues/20
-require 'set'
-SortedSet.new
-
 require 'timers/version'
 
 require 'timers/group'
-require 'timers/timeout'
+require 'timers/wait'

data/lib/timers/events.rb

@@ -0,0 +1,115 @@
+
+require 'forwardable'
+require 'hitimes'
+
+require 'timers/timer'
+
+module Timers
+  # Maintains an ordered list of events, which can be cancelled.
+  class Events
+    # Represents a cancellable handle for a specific timer event.
+    class Handle
+      def initialize(time, callback)
+        @time = time
+        @callback = callback
+      end
+      
+      # The absolute time that the handle should be fired at.
+      attr :time
+      
+      # Cancel this timer, O(1).
+      def cancel!
+        # The simplest way to keep track of cancelled status is to nullify the
+        # callback. This should also be optimal for garbage collection.
+        @callback = nil
+      end
+      
+      # Has this timer been cancelled? Cancelled timer's don't fire.
+      def cancelled?
+        @callback.nil?
+      end
+      
+      def > other
+        @time > other.to_f
+      end
+      
+      def to_f
+        @time
+      end
+      
+      # Fire the callback if not cancelled with the given time parameter.
+      def fire(time)
+        if @callback
+          @callback.call(time)
+        end
+      end
+    end
+    
+    def initialize
+      # A sequence of handles, maintained in sorted order, future to present.
+      # @sequence.last is the next event to be fired.
+      @sequence = []
+    end
+    
+    # Add an event at the given time.
+    def schedule(time, callback)
+      handle = Handle.new(time.to_f, callback)
+      
+      index = bisect_left(@sequence, handle)
+      
+      # Maintain sorted order, O(logN) insertion time.
+      @sequence.insert(index, handle)
+      
+      return handle
+    end
+    
+    # Returns the first non-cancelled handle.
+    def first
+      while handle = @sequence.last
+        if handle.cancelled?
+          @sequence.pop
+        else
+          return handle
+        end
+      end
+    end
+    
+    # Returns the number of pending (possibly cancelled) events.
+    def size
+      @sequence.size
+    end
+    
+    # Fire all handles for which Handle#time is less than the given time.
+    def fire(time)
+      pop(time).reverse_each do |handle|
+        handle.fire(time)
+      end
+    end
+
+    private
+
+    # Efficiently take k handles for which Handle#time is less than the given 
+    # time.
+    def pop(time)
+      index = bisect_left(@sequence, time)
+      
+      return @sequence.pop(@sequence.size - index)
+    end
+    
+    # Return the left-most index where to insert item e, in a list a, assuming 
+    # a is sorted in descending order.
+    def bisect_left(a, e, l = 0, u = a.length)
+      while l < u
+        m = l + (u-l)/2
+        
+        if a[m] > e
+          l = m+1
+        else
+          u = m
+        end
+      end
+      
+      return l
+    end
+  end
+end

data/lib/timers/group.rb

@@ -4,103 +4,115 @@ require 'forwardable'
 require 'hitimes'
 
 require 'timers/timer'
+require 'timers/events'
 
 module Timers
   class Group
     include Enumerable
-    extend  Forwardable
-    def_delegators :@timers, :delete, :each, :empty?
+
+    extend Forwardable
+    def_delegators :@timers, :each, :empty?
 
     def initialize
-      @timers = SortedSet.new
-      @paused_timers = SortedSet.new
+      @events = Events.new
+      
+      @timers = Set.new
+      @paused_timers = Set.new
+      
       @interval = Hitimes::Interval.new
       @interval.start
     end
 
-    # Call the given block after the given interval
+    # Scheduled events:
+    attr :events
+    
+    # Active timers:
+    attr :timers
+    
+    # Paused timers:
+    attr :paused_timers
+
+    # Call the given block after the given interval. The first argument will be
+    # the time at which the group was asked to fire timers for.
     def after(interval, &block)
       Timer.new(self, interval, false, &block)
     end
 
-    # Call the given block after the given interval has expired. +interval+
-    # is measured in milliseconds.
-    #
-    #  Timer.new.after_milliseconds(25) { puts "fired!" }
-    #
-    def after_milliseconds(interval, &block)
-      after(interval / 1000.0, &block)
-    end
-    alias_method :after_ms, :after_milliseconds
-
-    # Call the given block periodically at the given interval
-    def every(interval, &block)
-      Timer.new(self, interval, true, &block)
+    # Call the given block periodically at the given interval. The first 
+    # argument will be the time at which the group was asked to fire timers for.
+    def every(interval, recur = true, &block)
+      Timer.new(self, interval, recur, &block)
     end
 
-    # Wait for the next timer and fire it
-    def wait
-      # Repeatedly call sleep until there is no longer any wait_interval:
-      while i = wait_interval
-        # We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
-        sleep i
+    # Wait for the next timer and fire it. Can take a block, which should behave
+    # like sleep(n), except that n may be nil (sleep forever) or a negative
+    # number (fire immediately after return).
+    def wait(&block)
+      if block_given?
+        yield wait_interval
+        
+        while interval = wait_interval and interval > 0
+          yield interval
+        end
+      else
+        while interval = wait_interval and interval > 0
+          # We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
+          sleep interval
+        end
       end
-      
+
       fire
     end
 
-    # Interval to wait until when the next timer will fire
+    # Interval to wait until when the next timer will fire.
+    # - nil: no timers
+    # - -ve: timers expired already
+    # -   0: timers ready to fire
+    # - +ve: timers waiting to fire
     def wait_interval(offset = self.current_offset)
-      timer = @timers.first
-      return unless timer
-      interval = timer.offset - Float(offset)
-      interval > 0 ? interval : nil
-    end
-
-    # Fire all timers that are ready
-    def fire(offset = self.current_offset)
-      time = Float(offset)
-      while (timer = @timers.first) && (time >= timer.offset)
-        @timers.delete timer
-        timer.fire(offset)
+      if handle = @events.first
+        return handle.time - Float(offset)
       end
     end
 
-    def add(timer)
-      raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
-      @timers.add(timer)
+    # Fire all timers that are ready.
+    def fire(offset = self.current_offset)
+      @events.fire(offset)
     end
 
-    def pause(timer = nil)
-      return pause_all if timer.nil?
-      raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
-      @timers.delete timer
-      @paused_timers.add timer
+    # Pause all timers.
+    def pause
+      @timers.dup.each do |timer|
+        timer.pause
+      end
     end
 
-    def pause_all
-      @timers.each {|timer| timer.pause}
+    # Resume all timers.
+    def resume
+      @paused_timers.dup.each do |timer|
+        timer.resume
+      end
     end
 
-    def continue(timer = nil)
-      return continue_all if timer.nil?
-      raise TypeError, "not a Timers::Timer" unless timer.is_a? Timers::Timer
-      @paused_timers.delete timer
-      @timers.add timer
-    end
-
-    def continue_all
-      @paused_timers.each {|timer| timer.continue}
-    end
+    alias_method :continue, :resume
 
+    # Delay all timers.
     def delay(seconds)
-      @timers.each {|timer| timer.delay(seconds)}
+      @timers.each do |timer|
+        timer.delay(seconds)
+      end
     end
 
-    alias_method :cancel, :delete
+    # Cancel all timers.
+    def cancel
+      @timers.dup.each do |timer|
+        timer.cancel
+      end
+    end
 
+    # The group's current time.
     def current_offset
       @interval.to_f
     end
   end
-end
+end

data/lib/timers/timer.rb

@@ -5,68 +5,99 @@ module Timers
     include Comparable
     attr_reader :interval, :offset, :recurring
 
-    def initialize(timers, interval, recurring = false, &block)
-      @timers, @interval, @recurring = timers, interval, recurring
-      @block  = block
-      @offset = nil
+    def initialize(group, interval, recurring = false, offset = nil, &block)
+      @group = group
+      
+      @group.timers << self
+      
+      @interval = interval
+      @recurring = recurring
+      @block = block
+      @offset = offset
+      
+      @handle = nil
+      
+      # If a start offset was supplied, use that, otherwise use the current timers offset.
+      reset(@offset || @group.current_offset)
+    end
 
-      reset
+    def paused?
+      @group.paused_timers.include? self
     end
 
-    def <=>(other)
-      @offset <=> other.offset
+    def pause
+      return if paused?
+      
+      @group.timers.delete self
+      @group.paused_timers.add self
+      
+      @handle.cancel! if @handle
+      @handle = nil
     end
 
-    # Cancel this timer
-    def cancel
-      @timers.cancel self
+    def resume
+      return unless paused?
+      
+      @group.timers.add self
+      @group.paused_timers.delete self
+      
+      reset
     end
 
+    alias_method :continue, :resume
+
     # Extend this timer
     def delay(seconds)
-      @timers.delete self
+      @handle.cancel! if @handle
+      
       @offset += seconds
-      @timers.add self
+      
+      @handle = @group.events.schedule(@offset, self)
+    end
+
+    # Cancel this timer
+    def cancel
+      @handle.cancel! if @handle
+      @handle = nil
+      
+      # This timer is no longer valid:
+      @group.timers.delete self
+      @group = nil
     end
 
     # Reset this timer
-    def reset(offset = @timers.current_offset)
-      @timers.cancel self if @offset
+    def reset(offset = @group.current_offset)
+      @handle.cancel! if @handle
+      
       @offset = Float(offset) + @interval
-      @timers.add self
+      
+      @handle = @group.events.schedule(@offset, self)
     end
 
     # Fire the block
-    def fire(offset = @timers.current_offset)
-      if recurring
+    def fire(offset = @group.current_offset)
+      if recurring == :strict
+        # ... make the next interval strictly the last offset + the interval:
+        reset(@offset)
+      elsif recurring
         reset(offset)
       else
         @offset = offset
       end
-      
-      @block.call
-    end
-    alias_method :call, :fire
 
-    # Pause this timer
-    def pause
-      @timers.pause self
+      @block.call(offset)
     end
 
-    # Continue this timer
-    def continue
-      @timers.continue self
-    end
+    alias_method :call, :fire
 
     # Number of seconds until next fire / since last fire
     def fires_in
-      @offset - @timers.current_offset if @offset
+      @offset - @group.current_offset if @offset
     end
 
     # Inspect a timer
     def inspect
       str = "#<Timers::Timer:#{object_id.to_s(16)} "
-      offset = @timers.current_offset
 
       if @offset
         if fires_in >= 0
@@ -83,4 +114,4 @@ module Timers
       str << ">"
     end
   end
-end
+end

data/lib/timers/version.rb

@@ -1,3 +1,3 @@
 module Timers
-  VERSION = "3.0.1"
+  VERSION = "4.0.0"
 end

data/lib/timers/{timeout.rb → wait.rb}

@@ -3,7 +3,19 @@ require 'hitimes'
 
 module Timers
   # An exclusive, monotonic timeout class.
-  class Timeout
+  class Wait
+    def self.for(duration, &block)
+      if duration
+        timeout = self.new(duration)
+        
+        timeout.while_time_remaining(&block)
+      else
+        while true
+          yield(nil)
+        end
+      end
+    end
+    
     def initialize(duration)
       @duration = duration
       @remaining = true

data/spec/events_spec.rb

@@ -0,0 +1,57 @@
+
+require 'spec_helper'
+
+RSpec.describe Timers::Events do
+  it "should register an event" do
+    fired = false
+    
+    callback = proc do |time|
+      fired = true
+    end
+    
+    handle = subject.schedule(0.1, callback)
+    
+    expect(subject.size).to be == 1
+    
+    subject.fire(0.15)
+    
+    expect(subject.size).to be == 0
+    
+    expect(fired).to be true
+  end
+  
+  it "should register events in order" do
+    fired = []
+    
+    times = [0.95, 0.1, 0.3, 0.5, 0.4, 0.2, 0.01, 0.9]
+    
+    times.each do |requested_time|
+      callback = proc do |time|
+        fired << requested_time
+      end
+      
+      subject.schedule(requested_time, callback)
+    end
+    
+    subject.fire(0.5)
+    expect(fired).to be == times.sort.first(6)
+    
+    subject.fire(1.0)
+    expect(fired).to be == times.sort
+  end
+  
+  it "should fire events with the time they were fired at" do
+    fired_at = :not_fired
+    
+    callback = proc do |time|
+      # The time we actually were fired at:
+      fired_at = time
+    end
+    
+    subject.schedule(0.5, callback)
+    
+    subject.fire(1.0)
+    
+    expect(fired_at).to be == 1.0
+  end
+end

data/spec/every_spec.rb

@@ -0,0 +1,19 @@
+
+require 'spec_helper'
+
+RSpec.describe Timers::Group do
+  it "should fire several times" do
+    result = []
+
+    subject.every(0.7) { result << :a }
+    subject.every(2.3) { result << :b }
+    subject.every(1.3) { result << :c }
+    subject.every(2.4) { result << :d }
+
+    Timers::Wait.for(2.5) do |remaining|
+      subject.wait if subject.wait_interval < remaining
+    end
+
+    expect(result).to be == [:a, :c, :a, :a, :b, :d]
+  end
+end

data/spec/group_spec.rb

@@ -2,6 +2,35 @@
 require 'spec_helper'
 
 RSpec.describe Timers::Group do
+  describe "#wait" do
+    it "calls the wait block with nil" do
+      called = false
+      
+      subject.wait do |interval|
+        expect(interval).to be == nil
+        called = true
+      end
+      
+      expect(called).to be true
+    end
+  
+    it "calls the wait block with an interval" do
+      called = false
+      fired = false
+
+      subject.after(0.1) { fired = true }
+
+      subject.wait do |interval|
+        expect(interval).to be_within(TIMER_QUANTUM).of(0.1)
+        called = true
+        sleep 0.2
+      end
+
+      expect(called).to be true
+      expect(fired).to be true
+    end
+  end
+  
   it "sleeps until the next timer" do
     interval   = TIMER_QUANTUM * 2
     started_at = Time.now
@@ -30,7 +59,7 @@ RSpec.describe Timers::Group do
     expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of interval
 
     sleep(interval)
-    expect(subject.wait_interval).to be(nil)
+    expect(subject.wait_interval).to be <= 0
   end
 
   it "fires timers in the correct order" do
@@ -68,26 +97,22 @@ RSpec.describe Timers::Group do
     end
   end
 
-  describe "millisecond timers" do
-    it "calculates the proper interval to wait until firing" do
-      interval_ms = 25
+  it "calculates the proper interval to wait until firing" do
+    interval_ms = 25
 
-      subject.after_milliseconds(interval_ms)
-      expected_elapse = subject.wait_interval
+    subject.after(interval_ms / 1000.0)
 
-      expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of(interval_ms / 1000.0)
-    end
+    expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of(interval_ms / 1000.0)
   end
 
   describe "pause and continue timers" do
     before(:each) do
       @interval   = TIMER_QUANTUM * 2
-      started_at = Time.now
 
       @fired = false
-      @timer = subject.every(@interval) { @fired = true }
+      @timer = subject.after(@interval) { @fired = true }
       @fired2 = false
-      @timer2 = subject.every(@interval) { @fired2 = true }
+      @timer2 = subject.after(@interval) { @fired2 = true }
     end
 
     it "does not fire when paused" do
@@ -99,8 +124,11 @@ RSpec.describe Timers::Group do
     it "fires when continued after pause" do
       @timer.pause
       subject.wait
-      @timer.continue
+      @timer.resume
+      
+      sleep @timer.interval
       subject.wait
+      
       expect(@fired).to be true
     end
 
@@ -114,8 +142,12 @@ RSpec.describe Timers::Group do
     it "can continue all timers at once" do
       subject.pause
       subject.wait
-      subject.continue
+      subject.resume
+      
+      # We need to wait until we are sure both timers will fire, otherwise highly accurate clocks (e.g. JVM) may only fire the first timer, but not the second, because they are actually schedueled at different times.
+      sleep TIMER_QUANTUM * 2
       subject.wait
+      
       expect(@fired).to be true
       expect(@fired2).to be true
     end
@@ -126,7 +158,7 @@ RSpec.describe Timers::Group do
       timer.pause
       subject.wait
       expect(fired).not_to be true
-      timer.continue
+      timer.resume
       expect(fired).not_to be true
       timer.fire
       expect(fired).to be true
@@ -156,8 +188,8 @@ RSpec.describe Timers::Group do
     it "fires timers in the correct order" do
       result = []
 
-      second = subject.after(TIMER_QUANTUM * 2) { result << :two }
-      third = subject.after(TIMER_QUANTUM * 3) { result << :three }
+      subject.after(TIMER_QUANTUM * 2) { result << :two }
+      subject.after(TIMER_QUANTUM * 3) { result << :three }
       first = subject.after(TIMER_QUANTUM * 1) { result << :one }
       first.delay(TIMER_QUANTUM * 3)
 

data/spec/performance_spec.rb

@@ -0,0 +1,83 @@
+
+require 'spec_helper'
+require 'ruby-prof' unless RUBY_PLATFORM =~ /java/
+
+# Event based timers:
+
+# Serviced 31812 events in 2.39075272 seconds, 13306.320832794887 e/s.
+# Thread ID: 7336700
+# Fiber ID: 30106340
+# Total: 2.384043
+# Sort by: self_time
+
+# %self      total      self      wait     child     calls  name
+# 13.48      0.510     0.321     0.000     0.189    369133  Timers::Events::Handle#<=>
+#  8.12      0.194     0.194     0.000     0.000    427278  Timers::Events::Handle#to_f
+#  4.55      0.109     0.109     0.000     0.000    427278  Float#<=>
+#  4.40      1.857     0.105     0.000     1.752    466376 *Timers::Events#bsearch
+#  4.30      0.103     0.103     0.000     0.000    402945  Float#to_f
+#  2.65      0.063     0.063     0.000     0.000     33812  Array#insert
+#  2.64      1.850     0.063     0.000     1.787     33812  Timers::Events#schedule
+#  2.40      1.930     0.057     0.000     1.873     33812  Timers::Timer#reset
+#  1.89      1.894     0.045     0.000     1.849     31812  Timers::Timer#fire
+#  1.69      1.966     0.040     0.000     1.926     31812  Timers::Events::Handle#fire
+#  1.35      0.040     0.032     0.000     0.008     33812  Timers::Events::Handle#initialize
+#  1.29      0.044     0.031     0.000     0.013     44451  Timers::Group#current_offset
+
+# SortedSet based timers:
+
+# Serviced 32516 events in 66.753277275 seconds, 487.1072288781219 e/s.
+# Thread ID: 15995640
+# Fiber ID: 38731780
+# Total: 66.716394
+# Sort by: self_time
+
+# %self      total      self      wait     child     calls  name
+# 54.73     49.718    36.513     0.000    13.205  57084873  Timers::Timer#<=>
+# 23.74     65.559    15.841     0.000    49.718     32534  Array#sort!
+# 19.79     13.205    13.205     0.000     0.000  57084873  Float#<=>
+
+# Max out events performance (on my computer):
+# Serviced 1142649 events in 11.194903921 seconds, 102068.70405115146 e/s.
+
+RSpec.describe Timers::Group do
+  if defined? RubyProf
+    before(:each) do
+      # Running RubyProf makes the code slightly slower.
+      RubyProf.start
+      puts "*** Running with RubyProf reduces performance ***"
+    end
+
+    after(:each) do |arg|
+      if RubyProf.running?
+        # file = arg.metadata[:description].gsub(/\s+/, '-')
+      
+        result = RubyProf.stop
+      
+        printer = RubyProf::FlatPrinter.new(result)
+        printer.print($stderr, min_percent: 1.0)
+      end
+    end
+  end
+  
+  it "run efficiently" do
+    result = []
+    range = (1..500)
+    duration = 2.0
+
+    total = 0
+    range.each do |index|
+      offset = index.to_f / range.max
+      total += (duration / offset).floor
+      
+      subject.every(index.to_f / range.max, :strict) { result << index }
+    end
+    
+    subject.wait while result.size < total
+    
+    rate = result.size.to_f / subject.current_offset
+    puts "Serviced #{result.size} events in #{subject.current_offset} seconds, #{rate} e/s."
+    
+    expect(subject.current_offset).to be_within(TIMER_QUANTUM).of(duration)
+  end
+end

data/spec/strict_spec.rb

@@ -0,0 +1,37 @@
+
+require 'spec_helper'
+
+RSpec.describe Timers::Group do
+	it "should not diverge too much" do
+		fired = :not_fired_yet
+		count = 0
+		quantum = 0.01
+		
+		start_offset = subject.current_offset
+		Timers::Timer.new(subject, quantum, :strict, start_offset) do |offset|
+			fired = offset
+			count += 1
+		end
+		
+		iterations = 1000
+		subject.wait while count < iterations
+		
+		# In my testing on the JVM, without the :strict recurring, I noticed 60ms of error here.
+		expect(fired - start_offset).to be_within(quantum).of(iterations * quantum)
+	end
+	
+	it "should only fire once" do
+		fired = :not_fired_yet
+		count = 0
+
+		start_offset = subject.current_offset
+		Timers::Timer.new(subject, 0, :strict, start_offset) do |offset|
+			fired = offset
+			count += 1
+		end
+		
+		subject.wait
+		
+		expect(count).to be == 1
+	end
+end

data/spec/timeout_spec.rb

@@ -1,10 +1,10 @@
 
 require 'spec_helper'
-require 'timers/timeout'
+require 'timers/wait'
 
-RSpec.describe Timers::Timeout do
+RSpec.describe Timers::Wait do
   it "repeats until timeout expired" do
-    timeout = Timers::Timeout.new(5)
+    timeout = Timers::Wait.new(5)
     count = 0
     
     timeout.while_time_remaining do |remaining|
@@ -18,7 +18,7 @@ RSpec.describe Timers::Timeout do
   end
   
   it "yields results as soon as possible" do
-    timeout = Timers::Timeout.new(5)
+    timeout = Timers::Wait.new(5)
     
     result = timeout.while_time_remaining do |remaining|
       break :done

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timers
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 4.0.0
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-27 00:00:00.000000000 Z
+date: 2014-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hitimes
@@ -70,12 +70,17 @@ files:
 - README.md
 - Rakefile
 - lib/timers.rb
+- lib/timers/events.rb
 - lib/timers/group.rb
-- lib/timers/timeout.rb
 - lib/timers/timer.rb
 - lib/timers/version.rb
+- lib/timers/wait.rb
+- spec/events_spec.rb
+- spec/every_spec.rb
 - spec/group_spec.rb
+- spec/performance_spec.rb
 - spec/spec_helper.rb
+- spec/strict_spec.rb
 - spec/timeout_spec.rb
 - timers.gemspec
 homepage: https://github.com/celluloid/timers
@@ -104,6 +109,10 @@ specification_version: 4
 summary: Schedule procs to run after a certain time, or at periodic intervals, using
   any API that accepts a timeout
 test_files:
+- spec/events_spec.rb
+- spec/every_spec.rb
 - spec/group_spec.rb
+- spec/performance_spec.rb
 - spec/spec_helper.rb
+- spec/strict_spec.rb
 - spec/timeout_spec.rb