frugal_timeout 0.0.12 → 0.0.13

data/TODO

@@ -1,3 +1,4 @@
+# * Add more comments.
 # * Add docs like in null_object gem.
 
 require 'frugal_timeout'

data/frugal_timeout.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'frugal_timeout'
-  s.version     = '0.0.12'
-  s.date        = '2014-01-03'
+  s.version     = '0.0.13'
+  s.date        = '2014-01-08'
   s.summary     = 'Timeout.timeout replacement'
   s.description = 'Timeout.timeout replacement that uses only 1 thread'
   s.authors     = ['Dmitry Maksyoma']

data/lib/frugal_timeout.rb

@@ -31,6 +31,8 @@ require 'timeout'
 #--
 # }}}1
 module FrugalTimeout
+  DO_NOTHING = proc {}
+
   # {{{1 Error
   class Error < Timeout::Error #:nodoc:
   end
@@ -87,75 +89,70 @@ module FrugalTimeout
 
   # {{{1 RequestQueue
   class RequestQueue #:nodoc:
-    extend Forwardable
-
-    def_delegators :@requests, :empty?, :first, :<<
+    include MonitorMixin
 
     def initialize
-      @onNewNearestRequest, @requests, @threadReq =
-	proc {}, SortedQueue.new, {}
+      super
+      @onEnforce, @onNewNearestRequest = DO_NOTHING, DO_NOTHING
+      @requests, @threadIdx = SortedQueue.new, Storage.new
+
+      @requests.onAdd { |r| @threadIdx.set r.thread, r }
+      @requests.onRemove { |r| @threadIdx.delete r.thread, r }
     end
 
-    def defuse_thread! thread
-      @requests.synchronize {
-	stored = @threadReq.delete thread
-	stored.each { |r| r.defuse! } if stored.is_a? Array
+    def handleExpiry
+      synchronize {
+	purgeAndEnforceExpired
+	sendNearestActiveRequest
       }
     end
-    private :defuse_thread!
 
     def onEnforce &b
-      @onEnforce = b
+      synchronize { @onEnforce = b || DO_NOTHING }
     end
 
     def onNewNearestRequest &b
-      @onNewNearestRequest = b
+      synchronize { @onNewNearestRequest = b || DO_NOTHING }
     end
 
-    # Purge and enforce expired timeouts. Only enforce once for each thread,
-    # even if multiple timeouts for that thread expire at once.
-    def purgeExpired
-      filter, now = {}, MonotonicTime.now
-      @requests.synchronize {
-	@onEnforce.call if @onEnforce
-
-	@requests.reject_and_get! { |r| r.at <= now }.each { |r|
-	  next if filter[r.thread]
-
-	  if r.enforceTimeout
-	    defuse_thread! r.thread
-	    filter[r.thread] = true
-	  end
-	}
+    def size
+      synchronize { @requests.size }
+    end
 
-	# It's necessary to call onNewNearestRequest inside synchronize as other
-	# threads may #queue requests.
-	@onNewNearestRequest.call @requests.first unless @requests.empty?
+    def queue sec, klass
+      synchronize {
+	@requests << (request = Request.new(Thread.current,
+	  MonotonicTime.now + sec, klass))
+	@onNewNearestRequest.call(request) if @requests.first == request
+	request
       }
     end
 
-    def storeInIndex request
-      unless stored = @threadReq[request.thread]
-	@threadReq[request.thread] = request
-	return
-      end
+    private
+
+    def defuse_thread! thread
+      return unless stored = @threadIdx[thread]
 
       if stored.is_a? Array
-	stored << request
+	stored.each { |r| r.defuse! }
       else
-	@threadReq[request.thread] = [stored, request]
+	stored.defuse!
       end
     end
-    private :storeInIndex
 
-    def queue sec, klass
-      @requests.synchronize {
-	@requests << (request = Request.new(Thread.current,
-	  MonotonicTime.now + sec, klass))
-	@onNewNearestRequest.call(request) if @requests.first == request
-	storeInIndex request
-	request
-      }
+    # Purge and enforce expired timeouts.
+    def purgeAndEnforceExpired
+      @onEnforce.call
+      now = MonotonicTime.now
+      while !@requests.empty? && @requests.first.at <= now
+	r = @requests.shift
+	r.enforceTimeout && defuse_thread!(r.thread)
+      end
+    end
+
+    def sendNearestActiveRequest
+      @requests.reject_until_mismatch! { |r| r.defused? }
+      @onNewNearestRequest.call @requests.first unless @requests.empty?
     end
   end
 
@@ -171,8 +168,6 @@ module FrugalTimeout
   class SleeperNotifier #:nodoc:
     include MonitorMixin
 
-    DO_NOTHING = proc {}
-
     def initialize
       super()
       @condVar, @expireAt, @onExpiry = new_cond, nil, DO_NOTHING
@@ -232,55 +227,53 @@ module FrugalTimeout
 
   # {{{1 SortedQueue
   class SortedQueue #:nodoc:
-    include MonitorMixin
+    extend Forwardable
+
+    def_delegators :@array, :empty?, :first, :size
 
     def initialize storage=[]
       super()
       @array, @unsorted = storage, false
+      @onAdd = @onRemove = DO_NOTHING
     end
 
-    def each &b
-      synchronize { @array.each &b }
+    def last
+      sort!
+      @array.last
     end
 
-    def empty?
-      synchronize { @array.empty? }
+    def onAdd &b
+      @onAdd = b || DO_NOTHING
     end
 
-    def first
-      synchronize { @array.first }
-    end
-
-    def last
-      synchronize {
-	sort!
-	@array.last
-      }
+    def onRemove &b
+      @onRemove = b || DO_NOTHING
     end
 
     def push *args
-      synchronize {
-	args.each { |arg|
-	  case @array.first <=> arg
-	  when -1, 0, nil
-	    @array.push arg
-	  when 1
-	    @array.unshift arg
-	  end
-	}
-	@unsorted = true
+      args.each { |arg|
+	case @array.first <=> arg
+	when -1, 0, nil
+	  @array.push arg
+	when 1
+	  @array.unshift arg
+	end
       }
+      @unsorted = true
+      args.each { |arg| @onAdd.call arg }
     end
     alias :<< :push
 
     def reject! &b
-      synchronize {
-	sort!
-	@array.reject! &b
+      ar = []
+      sort!
+      @array.reject! { |el|
+	ar << el if b.call el
       }
+      ar.each { |el| @onRemove.call el }
     end
 
-    def reject_and_get! &b
+    def reject_until_mismatch! &b
       res = []
       reject! { |el|
 	break unless b.call el
@@ -290,8 +283,11 @@ module FrugalTimeout
       res
     end
 
-    def size
-      synchronize { @array.size }
+    def shift
+      sort!
+      res = @array.shift
+      @onRemove.call res
+      res
     end
 
     private
@@ -303,20 +299,57 @@ module FrugalTimeout
     end
   end
 
+  # {{{1 Storage
+  class Storage
+    def initialize
+      @storage = {}
+    end
+
+    def delete key, val=nil
+      return unless stored = @storage[key]
+
+      if val.nil? || stored == val
+	@storage.delete key
+	return
+      end
+
+      stored.delete val
+      @storage[key] = stored.first if stored.size == 1
+    end
+
+    def get key
+      @storage[key]
+    end
+    alias :[] :get
+
+    def set key, val
+      unless stored = @storage[key]
+	@storage[key] = val
+	return
+      end
+
+      if stored.is_a? Array
+	stored << val
+      else
+	@storage[key] = [stored, val]
+      end
+    end
+  end
+
   # {{{1 Main code
   @requestQueue = RequestQueue.new
   sleeper = SleeperNotifier.new
   @requestQueue.onNewNearestRequest { |request|
     sleeper.expireAt request.at
   }
-  sleeper.onExpiry { @requestQueue.purgeExpired }
+  sleeper.onExpiry { @requestQueue.handleExpiry }
 
   # {{{2 Methods
 
   # Ensure that calling timeout() will use FrugalTimeout.timeout()
   def self.dropin!
     Object.class_eval \
-      'def timeout t, klass=Error, &b
+      'def timeout t, klass=nil, &b
 	 FrugalTimeout.timeout t, klass, &b
        end'
   end
@@ -330,15 +363,17 @@ module FrugalTimeout
   end
 
   # Same as Timeout.timeout()
-  def self.timeout sec, klass=Error
+  def self.timeout sec, klass=nil
     return yield sec if sec.nil? || sec <= 0
 
-    innerException = Class.new Timeout::ExitException
+    innerException = klass || Class.new(Timeout::ExitException)
     request = @requestQueue.queue(sec, innerException)
     begin
       yield sec
     rescue innerException => e
-      raise klass, e.message, e.backtrace
+      raise if klass
+
+      raise Error, e.message, e.backtrace
     ensure
       @onEnsure.call if @onEnsure
       request.defuse!

data/performance-test

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+
+require './lib/frugal_timeout'
+
+Thread.abort_on_exception = true
+FrugalTimeout.dropin!
+
+def recursive_timeout n
+  start = FrugalTimeout::MonotonicTime.now
+  timeout(1) {
+    if n > 1
+      recursive_timeout n -= 1
+    else
+      sleep
+    end
+  }
+rescue FrugalTimeout::Error
+  @m.synchronize { @ar << FrugalTimeout::MonotonicTime.now - start }
+end
+
+THREAD_COUNT, TIMES = 150, 100
+@ar, @m = [], Mutex.new
+THREAD_COUNT.times {
+  Thread.new {
+    recursive_timeout TIMES
+  }
+}
+sleep 0.1 until @m.synchronize { @ar.size == THREAD_COUNT }
+
+puts "#{THREAD_COUNT*TIMES} calls\navg: #{@ar.inject(:+)/@ar.size}"

data/spec/frugal_timeout_spec.rb

@@ -23,12 +23,10 @@ def multiple_timeouts growing, cnt
 end
 
 def new_timeout_request sec, res, resMutex
-  begin
-    start = MonotonicTime.now
-    timeout(sec) { sleep }
-  rescue FrugalTimeout::Error
-    resMutex.synchronize { res << MonotonicTime.now - start }
-  end
+  start = MonotonicTime.now
+  timeout(sec) { sleep }
+rescue FrugalTimeout::Error
+  resMutex.synchronize { res << MonotonicTime.now - start }
 end
 
 def new_timeout_request_thread sec, res, resMutex
@@ -104,6 +102,14 @@ describe FrugalTimeout do
   end
 
   context 'recursive timeouts' do
+    it 'with the same delay' do
+      expect {
+	timeout(SMALLEST_TIMEOUT) {
+	  timeout(SMALLEST_TIMEOUT) { sleep }
+	}
+      }.to raise_error FrugalTimeout::Error
+    end
+
     it 'works if recursive timeouts rescue thrown exception' do
       # A rescue block will only catch exception for the timeout() block it's
       # written for.
@@ -183,6 +189,17 @@ describe FrugalTimeout do
     expect { timeout(0.1, IOError) { sleep } }.to raise_error IOError
   end
 
+  it 'raises specified exception inside the block' do
+    expect {
+      timeout(0.01, IOError) {
+	begin
+	  sleep
+	rescue IOError
+	end
+      }
+    }.not_to raise_error
+  end
+
   it "doesn't raise exception if there's no need" do
     timeout(1) { }
     sleep 2
@@ -205,6 +222,13 @@ describe FrugalTimeout do
     expect { timeout(SMALLEST_TIMEOUT) { sleep } }.to \
       raise_error Timeout::Error
   end
+
+  it "doesn't enforce defused timeout" do
+    expect {
+      timeout(0.1) { }
+      sleep 0.2
+    }.not_to raise_error
+  end
 end
 
 # {{{1 MonotonicTime
@@ -242,13 +266,73 @@ describe FrugalTimeout::RequestQueue do
     }
   end
 
-  context 'always invokes callback after purging' do
-    [[10, "didn't expire yet"], [0, 'expired']].each { |sec, msg|
-      it "when request #{msg}" do
-	req = @requests.queue(sec, FrugalTimeout::Error)
+  context 'after queueing' do
+    context 'invokes onNewNearestRequest callback' do
+      it 'just once' do
+	@requests.queue(10, FrugalTimeout::Error)
 	@ar.size.should == 1
       end
-    }
+
+      it 'when next request is nearer than prev' do
+	@requests.queue(10, FrugalTimeout::Error)
+	@requests.queue(0, FrugalTimeout::Error)
+	@ar.size.should == 2
+      end
+    end
+
+    it "doesn't invoke onNewNearestRequest if request isn't nearest" do
+      @requests.queue(10, FrugalTimeout::Error)
+      @requests.queue(20, FrugalTimeout::Error)
+      @ar.size.should == 1
+    end
+  end
+
+  context 'after handleExpiry' do
+    it 'invokes onEnforce on handleExpiry' do
+      called = false
+      @requests.onEnforce { called = true }
+      @requests.queue(0, FrugalTimeout::Error)
+      expect { @requests.handleExpiry }.to raise_error
+      called.should == true
+    end
+
+    it 'defuses all requests for the thread' do
+      req = @requests.queue(10, FrugalTimeout::Error)
+      @requests.queue(0, FrugalTimeout::Error)
+      expect {
+	Thread.new {
+	  @requests.handleExpiry
+	}.join
+      }.to raise_error FrugalTimeout::Error
+      req.defused?.should == true
+    end
+
+    context 'onNewNearestRequest' do
+      it 'invokes onNewNearestRequest' do
+	@requests.queue(0, FrugalTimeout::Error)
+	expect { @requests.handleExpiry }.to raise_error
+	@ar.size.should == 1
+      end
+
+      it "doesn't invoke onNewNearestRequest on a defused request" do
+	@requests.queue(0, FrugalTimeout::Error).defuse!
+	expect { @requests.handleExpiry }.not_to raise_error
+	@requests.size.should == 0
+      end
+    end
+
+    it 'no expired requests are left in the queue' do
+      @requests.queue(0, FrugalTimeout::Error)
+      @requests.size.should == 1
+      expect { @requests.handleExpiry }.to raise_error
+      @requests.size.should == 0
+    end
+
+    it 'a non-expired request is left in the queue' do
+      @requests.queue(10, FrugalTimeout::Error)
+      expect { @requests.handleExpiry }.not_to raise_error
+      @requests.size.should == 1
+    end
   end
 end
 
@@ -350,11 +434,93 @@ describe FrugalTimeout::SortedQueue do
     }.not_to raise_error
   end
 
-  it '#reject_and_get!' do
+  it '#reject_until_mismatch!' do
     @queue.push 'a'
     @queue.push 'b'
-    res = @queue.reject_and_get! { |el| el < 'b' }
+    res = @queue.reject_until_mismatch! { |el| el < 'b' }
     res.size.should == 1
     res.first.should == 'a'
   end
+
+  it '#shift calls onRemove' do
+    called = nil
+    @queue.onRemove { |el| called = el }
+    @queue.push 'a'
+    @queue.shift
+    called.should == 'a'
+  end
+
+  it 'calls onAdd callback' do
+    called = nil
+    @queue.onAdd { |el| called = el }
+    @queue.push 'a'
+    called.should == 'a'
+  end
+
+  it 'calls onRemove callback' do
+    called = nil
+    @queue.onRemove { |el| called = el }
+    @queue.push 'a'
+    @queue.reject! { |el| true }
+    called.should  == 'a'
+  end
+end
+
+# {{{1 Storage
+describe FrugalTimeout::Storage do
+  before :each do
+    @storage = FrugalTimeout::Storage.new
+  end
+
+  context 'for a single key' do
+    it 'contains nothing at first' do
+      @storage.get(1).should == nil
+    end
+
+    it 'stores single value as non-array' do
+      @storage.set 1, 2
+      @storage.get(1).should == 2
+    end
+
+    it 'stores 2 values as array' do
+      @storage.set 1, 2
+      @storage.set 1, 3
+      @storage.get(1).should == [2, 3]
+    end
+
+    context 'removes single value' do
+      it 'and nothing is left' do
+	@storage.set 1, 2
+	@storage.delete 1, 2
+	@storage.get(1).should == nil
+      end
+
+      it 'and single value is left' do
+	@storage.set 1, 2
+	@storage.set 1, 3
+	@storage.delete 1, 2
+	@storage.get(1).should == 3
+      end
+
+      it 'and several values left' do
+	@storage.set 1, 2
+	@storage.set 1, 3
+	@storage.set 1, 4
+	@storage.delete 1, 2
+	@storage.get(1).should == [3, 4]
+      end
+    end
+
+    it 'removes everything if no value is given' do
+      @storage.set 1, 2
+      @storage.set 1, 3
+      @storage.delete 1
+      @storage.get(1).should == nil
+    end
+
+    it 'supports #[] as #get' do
+      @storage.set 1, 2
+      @storage[1].should == 2
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: frugal_timeout
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-03 00:00:00.000000000 Z
+date: 2014-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -60,6 +60,7 @@ files:
 - TODO
 - frugal_timeout.gemspec
 - lib/frugal_timeout.rb
+- performance-test
 - spec/frugal_timeout_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ledestin/frugal_timeout