ztimer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03ec6525946e2b8674a3f8401082b6eef8536130
-  data.tar.gz: 957b3894fc8259592b9ec4728727ae95bcdec284
+  metadata.gz: d1573340ee3ea2395903700d513da753aafc2195
+  data.tar.gz: a59c67818ca6a04791149dbf708d76db176be04b
 SHA512:
-  metadata.gz: a2f31354371be81f9d5f507f7ca955fdca10b5156d2da1a6583925a562488f50679f3df148282fd5c2d9af56b39c9ddc9a400e5933140f5e47b6fda1de8d3b71
-  data.tar.gz: 0811e83c8d916e4c7a47656a54263b6bda5407d7e01c07265cf099607ac52af4f03faf01727fa4ae3f0566fb840b2cff6210e6996e98a20731f58bfaeaa49a42
+  metadata.gz: 797a50a8523875f1f411706125f2585316cf916f82bc254e545e7dbc727e2a395893a2164a4db6eb6909796bd9b44fce77491feac8f2bd9aaa9ec774e608b357
+  data.tar.gz: f5ef83dea7d7760a681dac4f2160fd8ab5da183054f43d7dbc25bba552800e73d2fba771e4af8d970b616aa8a71baedd8e01f627f13499f92346e424065d4fb7

data/lib/ztimer/slot.rb

@@ -10,6 +10,15 @@ module Ztimer
       @callback    = callback
       @started_at  = nil
       @executed_at = nil
+      @canceled    = false
+    end
+
+    def canceled?
+      return @canceled
+    end
+
+    def cancel!
+      @canceled = true
     end
 
     def <=>(other)

data/lib/ztimer/sorted_store.rb

@@ -0,0 +1,97 @@
+
+module Ztimer
+  class SortedStore
+
+    def initialize
+      @store = []
+    end
+
+    def <<(value)
+      @store.insert(position_for(value), value)
+      return self
+    end
+
+    def delete(value)
+      index = index_of(value)
+      if index
+        @store.delete_at(index)
+      else
+        return nil
+      end
+    end
+
+    def [](index)
+      return @store[index]
+    end
+
+    def first
+      return @store.first
+    end
+
+    def last
+      return @store.last
+    end
+
+    def shift
+      return @store.shift
+    end
+
+    def pop
+      return @store.pop
+    end
+
+    def index_of(value, start = 0, stop = [@store.count - 1, 0].max)
+      if start > stop
+        return nil
+      elsif start == stop
+        return value == @store[start] ? start : nil
+      else
+        position = ((stop + start)/ 2).to_i
+        case value <=> @store[position]
+        when -1 then return index_of(value, start, position)
+        when  0 then return position
+        when  1 then return index_of(value, position + 1, stop)
+        end
+      end
+    end
+
+    def count
+      return @store.count
+    end
+
+    def size
+      return @store.size
+    end
+
+    def empty?
+      return @store.empty?
+    end
+
+    def clear
+      return @store.clear
+    end
+
+    def to_a
+      return @store.dup
+    end
+
+
+    protected
+
+    def position_for(item, start = 0, stop = [@store.count - 1, 0].max)
+      if start > stop
+        raise "Invalid range (#{start}, #{stop})"
+      elsif start == stop
+        element = @store[start]
+        return element.nil? || ((item <=> element) <= 0) ? start : start + 1
+      else
+        position = ((stop + start)/ 2).to_i
+        case item <=> @store[position]
+        when -1 then return position_for(item, start, position)
+        when  0 then return position
+        when  1 then return position_for(item, position + 1, stop)
+        end
+      end
+    end
+  end
+end

data/lib/ztimer/version.rb

@@ -1,3 +1,3 @@
 module Ztimer
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/ztimer/watcher.rb

@@ -0,0 +1,80 @@
+
+module Ztimer
+  class Watcher
+
+    def initialize(&callback)
+      @thread   = nil
+      @idler    = Lounger.new
+      @slots    = Ztimer::SortedStore.new
+      @callback = callback
+      @lock     = Mutex.new
+      @metric   = Hitimes::Metric.new("Notifier")
+      @mutex    = Mutex.new
+    end
+
+    def << (slot)
+      @mutex.synchronize do
+        @slots << slot
+        if @slots.first == slot
+          run
+        end
+      end
+    end
+
+    def jobs
+      return @slots.size
+    end
+
+    protected
+
+    def run
+      if @thread
+        @idler.signal && @thread.run
+      else
+        start
+      end
+    end
+
+    def start
+      @lock.synchronize do
+        return if @thread
+        @thread = Thread.new do
+          loop do
+            delay = get_delay
+            if delay.nil?
+              @idler.wait
+              next
+            end
+
+            select(nil, nil, nil, delay / 1_000_000.to_f) if delay > 1 # 1 microsecond of cranularity
+
+            while get_first_expired do
+            end
+          end
+        end
+        @thread.abort_on_exception = true
+      end
+    end
+
+    def get_delay
+      return @mutex.synchronize { @slots.empty? ? nil : @slots.first.expires_at - @metric.utc_microseconds }
+    end
+
+    def get_first_expired
+      @mutex.synchronize do
+        slot = @slots.first
+        if slot && (slot.expires_at < @metric.utc_microseconds)
+          @slots.shift
+          slot.started_at = @metric.utc_microseconds
+          execute(slot) unless slot.canceled?
+        end
+
+        slot
+      end
+    end
+
+    def execute(slot)
+      @callback.call(slot)
+    end
+  end
+end

data/lib/ztimer.rb

@@ -1,32 +1,37 @@
 require 'set'
 require 'hitimes'
+require 'pqueue'
+require 'lounger'
+
 require "ztimer/version"
 require "ztimer/slot"
+require "ztimer/sorted_store"
+require "ztimer/watcher"
 
 module Ztimer
-  @concurrency = 20
-  @slots       = SortedSet.new
-  @metric      = Hitimes::Metric.new("Notifier")
-  @monitor     = nil
-  @running     = 0
-  @lock        = Mutex.new
-  @mutex       = Mutex.new
-  @queue       = Queue.new
+  @concurrency  = 20
+  @watcher      = Ztimer::Watcher.new(){|slot| execute(slot) }
+  @metric       = Hitimes::Metric.new("Notifier")
+  @workers_lock = Mutex.new
+  @queue        = Queue.new
+  @running      = 0
+  @count        = 0
 
   class << self
-    attr_reader :concurrency, :running
+    attr_reader :concurrency, :running, :count
 
     def after(milliseconds, &callback)
       enqueued_at = @metric.utc_microseconds
       expires_at  = enqueued_at + milliseconds * 1000
       slot        = Slot.new(enqueued_at, expires_at, &callback)
+
       add(slot)
 
       return slot
     end
 
     def jobs_count
-      return @slots.count
+      return @watcher.jobs
     end
 
     def concurrency=(new_value)
@@ -37,51 +42,30 @@ module Ztimer
     protected
 
     def add(slot)
-      @mutex.synchronize do
-        @slots << slot
-        restart_monitor if @slots.first == slot || @monitor.nil? || !@monitor.alive?
-      end
+      @count += 1
+      @watcher << slot
     end
 
-    def restart_monitor
-      @monitor.kill if @monitor
-
-      @monitor = Thread.new do
-        loop do
-          break if @slots.empty?
-
-          delay = @slots.first.expires_at - @metric.utc_microseconds
-          select(nil, nil, nil, delay / 1_000_000.to_f) if delay > 1 # 1 microsecond of cranularity
-
-          while @slots.first && (@slots.first.expires_at < @metric.utc_microseconds) do
-            @mutex.synchronize do
-              slot = @slots.first
-              slot.started_at = @metric.utc_microseconds
-              execute(slot)
-              @slots.delete slot
-            end
-          end
-        end
-      end
-      @monitor.abort_on_exception = true
-    end
 
     def execute(slot)
-      @queue.push slot
+      @queue << slot
 
-      @lock.synchronize do
+      @workers_lock.synchronize do
         [@concurrency - @running, @queue.size].min.times do
           @running += 1
           worker = Thread.new do
             begin
-              while !@queue.empty? && (slot = @queue.pop(true))
+              while !@queue.empty? && @queue.pop(true) do
                 slot.executed_at = @metric.utc_microseconds
                 slot.callback.call(slot) unless slot.callback.nil?
               end
+            rescue ThreadError
+              # queue is empty
+              puts "queue is empty"
             rescue => e
               STDERR.puts e.inspect + (e.backtrace ? "\n" + e.backtrace.join("\n") : "")
             end
-            @lock.synchronize { @running -= 1 }
+            @workers_lock.synchronize { @running -= 1 }
           end
           worker.abort_on_exception = true
         end

data/ztimer.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake",    "~> 10.0"
   spec.add_development_dependency "rspec",   "~> 3.0"
   spec.add_dependency             "hitimes", "~> 1.2"
+  spec.add_dependency             "lounger", "~> 0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ztimer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Groza Sergiu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-04 00:00:00.000000000 Z
+date: 2016-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: lounger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description: Ruby asyncrhonous timer that allows you to enqueue tasks to be executed
   asyncrhonously after a delay
 email:
@@ -85,7 +99,9 @@ files:
 - bin/setup
 - lib/ztimer.rb
 - lib/ztimer/slot.rb
+- lib/ztimer/sorted_store.rb
 - lib/ztimer/version.rb
+- lib/ztimer/watcher.rb
 - ztimer.gemspec
 homepage: https://github.com/serioja90/ztimer
 licenses:
@@ -107,9 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: An asyncrhonous timer
 test_files: []
-has_rdoc: