frugal_timeout 0.0.7 → 0.0.8

data/lib/frugal_timeout.rb

@@ -1,13 +1,15 @@
 # Copyright (C) 2013 by Dmitry Maksyoma <ledestin@gmail.com>
 
 require 'hitimes'
+require 'monitor'
+require 'null_object'
 require 'thread'
 require 'timeout'
 
 #--
 # {{{1 Rdoc
 #++
-# Timeout.timeout() replacement using only 2 threads
+# Timeout.timeout() replacement using only 1 thread
 # = Example
 #
 #   require 'frugal_timeout'
@@ -34,7 +36,7 @@ module FrugalTimeout
   class Error < Timeout::Error; end # :nodoc:
 
   # {{{1 MonotonicTime
-  class MonotonicTime
+  class MonotonicTime # :nodoc:
     NANOS_IN_SECOND = 1_000_000_000
 
     def self.measure
@@ -47,49 +49,97 @@ module FrugalTimeout
       Hitimes::Interval.now.start_instant.to_f/NANOS_IN_SECOND
     end
   end
+
   # {{{1 Request
   class Request # :nodoc:
     include Comparable
     @@mutex = Mutex.new
 
-    attr_reader :at, :thread
+    attr_reader :at, :exception, :klass, :thread
 
     def initialize thread, at, klass
       @thread, @at, @klass = thread, at, klass
+      @defused, @exception = false, Class.new(Timeout::ExitException)
     end
 
     def <=>(other)
       @at <=> other.at
     end
 
-    def done!
-      @@mutex.synchronize { @done = true }
+    # Timeout won't be enforced if you defuse a request.
+    def defuse!
+      @@mutex.synchronize { @defused = true }
     end
 
-    def done?
-      @@mutex.synchronize { @done }
+    def defused?
+      @@mutex.synchronize { @defused }
     end
 
-    def enforceTimeout
-      @thread.raise @klass || Error, 'execution expired' unless done?
+    def enforceTimeout filter=NullObject.new {}
+      @@mutex.synchronize {
+	return if @defused || filter.has_key?(@thread)
+
+	filter[@thread] = true
+	@thread.raise @exception, 'execution expired'
+      }
+    end
+  end
+
+  # {{{1 RequestQueue
+  class RequestQueue # :nodoc:
+    extend Forwardable
+
+    def_delegators :@requests, :empty?, :first, :<<
+
+    def initialize
+      @onNewNearestRequest, @requests = proc {}, SortedQueue.new
+    end
+
+    def onNewNearestRequest &b
+      @onNewNearestRequest = b
+    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.reject_and_get! { |r| r.at <= now }.each { |r|
+	r.enforceTimeout filter
+      }
+
+      @requests.synchronize {
+	@onNewNearestRequest.call(@requests.first) unless @requests.empty?
+      }
+    end
+
+    def queue sec, klass
+      @requests.synchronize {
+	@requests << (request = Request.new(Thread.current,
+	  MonotonicTime.now + sec, klass))
+	@onNewNearestRequest.call(request) if @requests.first == request
+	request
+      }
     end
   end
 
   # {{{1 SleeperNotifier
   class SleeperNotifier # :nodoc:
-    def initialize notifyQueue
-      @notifyQueue = notifyQueue
-      @latestDelay, @mutex = nil, Mutex.new
+    include MonitorMixin
+
+    def initialize
+      super()
+      @condVar, @onExpiry, @request = new_cond, proc {}, nil
 
       @thread = Thread.new {
 	loop {
-	  unless sleepFor = latestDelay
-	    sleep
-	  else
-	    sleptFor = MonotonicTime.measure { sleep(sleepFor) }
-	  end
-	  synchronize {
-	    @notifyQueue.push :expired if sleepFor && sleptFor >= sleepFor
+	  @onExpiry.call if synchronize {
+	    sleepFor = latestDelay
+	    sleptFor = MonotonicTime.measure { @condVar.wait sleepFor }
+
+	    if sleepFor && sleptFor >= sleepFor
+	      @request = nil
+	      true
+	    end
 	  }
 	}
       }
@@ -98,98 +148,134 @@ module FrugalTimeout
 
     def latestDelay
       synchronize {
-	tmp = @latestDelay
-	@latestDelay = nil
-	tmp
+	return unless @request
+
+	delay = @request.at - MonotonicTime.now
+	delay < 0 ? 0 : delay
       }
     end
     private :latestDelay
 
-    def notifyAfter sec
+    def notify
+      @condVar.signal
+    end
+    private :notify
+
+    def onExpiry &b
+      @onExpiry = b
+    end
+
+    # 1. Send any request.
+    # 2. Send only nearer (than the first request) expiration times.
+    # 3. The latest passed request expires and @onExpiry is called. Goto 1.
+    def sleepUntilExpires request
+      synchronize {
+	@request = request
+	notify
+      }
+    end
+  end
+
+  # {{{1 SortedQueue
+  class SortedQueue # :nodoc:
+    include MonitorMixin
+
+    def initialize storage=[]
+      super()
+      @array, @unsorted = storage, false
+    end
+
+    def empty?
+      synchronize { @array.empty? }
+    end
+
+    def first
+      synchronize { @array.first }
+    end
+
+    def last
       synchronize {
-	sleep 0.01 until @thread.status == 'sleep'
-	@latestDelay = sec
-	@thread.wakeup
+	sort!
+	@array.last
       }
     end
 
-    def synchronize &b
-      @mutex.synchronize &b
+    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
+      }
+    end
+    alias :<< :push
+
+    def reject! &b
+      synchronize {
+	sort!
+	@array.reject! &b
+      }
+    end
+
+    def reject_and_get! &b
+      res = []
+      reject! { |el|
+	break unless b.call el
+
+	res << el
+      }
+      res
+    end
+
+    def size
+      synchronize { @array.size }
+    end
+
+    private
+    def sort!
+      return unless @unsorted
+
+      @array.sort!
+      @unsorted = false
     end
-    private :synchronize
   end
 
   # {{{1 Main code
-  @in = Queue.new
-  @sleeper = SleeperNotifier.new @in
-
-  # {{{2 Timeout request and expiration processing thread
-  Thread.new {
-    nearestTimeout, requests = nil, []
-    loop {
-      request = @in.shift
-      now = MonotonicTime.now
-
-      if request == :expired
-	# Enforce all expired timeouts.
-	requests.sort!
-	requests.each_with_index { |r, i|
-	  break if r.at > now
-
-	  r.enforceTimeout
-	  requests[i] = nil
-	}
-	requests.compact!
-
-	# Activate the nearest non-expired timeout.
-	nearestTimeout = unless requests.first
-	  nil
-	else
-	  @sleeper.notifyAfter requests.first.at - now
-	  requests.first.at
-	end
-
-	next
-      end
-
-      # New timeout request.
-      # Already expired, enforce right away.
-      if request.at <= now
-	request.enforceTimeout
-	next
-      end
-
-      # Queue new timeout for later enforcing. Activate if it's nearest to
-      # enforce.
-      requests << request
-      next if nearestTimeout && request.at > nearestTimeout
-
-      @sleeper.notifyAfter request.at - now
-      nearestTimeout = request.at
-    }
+  @requestQueue = RequestQueue.new
+  sleeper = SleeperNotifier.new
+  @requestQueue.onNewNearestRequest { |request|
+    sleeper.sleepUntilExpires request
   }
-
+  sleeper.onExpiry { @requestQueue.purgeExpired }
 
   # {{{2 Methods
 
   # Ensure that calling timeout() will use FrugalTimeout.timeout()
   def self.dropin!
     Object.class_eval \
-      'def timeout t, klass=nil, &b
+      'def timeout t, klass=Error, &b
 	 FrugalTimeout.timeout t, klass, &b
        end'
   end
 
   # Same as Timeout.timeout()
-  def self.timeout sec, klass=nil
-    return yield sec if sec == nil || sec <= 0
+  def self.timeout sec, klass=Error
+    return yield sec if sec.nil? || sec <= 0
 
-    @in.push request = Request.new(Thread.current, MonotonicTime.now + sec,
-      klass)
+    request = @requestQueue.queue(sec, klass)
     begin
       yield sec
+    rescue request.exception => e
+      raise unless e.is_a? Timeout::ExitException
+
+      raise request.klass, e.message, e.backtrace
     ensure
-      request.done! unless $!.is_a? FrugalTimeout::Error
+      request.defuse!
     end
   end
   # }}}1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: frugal_timeout
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-20 00:00:00.000000000 Z
+date: 2013-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -43,7 +43,23 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.2'
-description: Timeout.timeout replacement that uses only 2 threads
+- !ruby/object:Gem::Dependency
+  name: null_object
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+description: Timeout.timeout replacement that uses only 1 thread
 email: ledestin@gmail.com
 executables: []
 extensions: []