dat-worker-pool 0.5.0 → 0.6.0

data/Gemfile

@@ -3,4 +3,4 @@ source "https://rubygems.org"
 gemspec
 
 gem 'rake'
-gem 'pry'
+gem 'pry', "~> 0.9.0"

data/bench/report.rb

@@ -0,0 +1,130 @@
+require 'benchmark'
+require 'thread'
+
+require 'dat-worker-pool'
+require 'dat-worker-pool/default_queue'
+
+class BenchRunner
+
+  NUM_WORKERS   = 4
+  TIME_MODIFIER = 10 ** 4 # 4 decimal places
+
+  LOGGER = if ENV['DEBUG']
+    Logger.new(File.expand_path("../../log/bench.log", __FILE__)).tap do |l|
+      l.datetime_format = '' # don't show datetime in the logs
+    end
+  end
+
+  def initialize
+    output_file_path = if ENV['OUTPUT_FILE']
+      File.expand_path(ENV['OUTPUT_FILE'])
+    else
+      File.expand_path('../report.txt', __FILE__)
+    end
+    @output = Output.new(File.open(output_file_path, 'w'))
+
+    @number_of_work_items = ENV['NUM_WORK_ITEMS'] || 100_000
+
+    @mutex    = Mutex.new
+    @cond_var = ConditionVariable.new
+    @finished = LockedInteger.new(0)
+
+    @result = nil
+  end
+
+  def run
+    output "Running benchmark report..."
+    output("\n", false)
+
+    benchmark_processing_work_items
+
+    output "\n", false
+    output "Processing #{@number_of_work_items} Work Items: #{@result}ms"
+
+    output "\n"
+    output "Done running benchmark report"
+  end
+
+  private
+
+  def benchmark_processing_work_items
+    queue = DatWorkerPool::DefaultQueue.new.tap(&:dwp_start)
+    @number_of_work_items.times.each{ |n| queue.dwp_push(n + 1) }
+
+    worker_pool = DatWorkerPool.new(BenchWorker, {
+      :num_workers   => NUM_WORKERS,
+      :logger        => LOGGER,
+      :queue         => queue,
+      :worker_params => {
+        :mutex    => @mutex,
+        :cond_var => @cond_var,
+        :finished => @finished,
+        :output   => @output
+      }
+    })
+    benchmark = Benchmark.measure do
+      worker_pool.start
+      while @finished.value != @number_of_work_items
+        @mutex.synchronize{ @cond_var.wait(@mutex) }
+      end
+      worker_pool.shutdown
+    end
+
+    @result = round_and_display(benchmark.real * 1000.to_f)
+    output "\n", false
+  end
+
+  private
+
+  def output(message, puts = true)
+    @output.log(message, puts)
+  end
+
+  def round_and_display(time_in_ms)
+    display_time(round_time(time_in_ms))
+  end
+
+  def round_time(time_in_ms)
+    (time_in_ms * TIME_MODIFIER).to_i / TIME_MODIFIER.to_f
+  end
+
+  def display_time(time)
+    integer, fractional = time.to_s.split('.')
+    [integer, fractional.ljust(4, '0')].join('.')
+  end
+
+  class BenchWorker
+    include DatWorkerPool::Worker
+
+    on_available{ signal_main_thread }
+
+    on_error{ params[:output].log('F', false) }
+
+    def work!(n)
+      params[:finished].increment
+      params[:output].log('.', false) if ((n - 1) % 100 == 0)
+    end
+
+    private
+
+    def signal_main_thread
+      params[:mutex].synchronize{ params[:cond_var].signal }
+    end
+  end
+
+  class Output < Struct.new(:file)
+    def log(message, puts = true)
+      method = puts ? :puts : :print
+      self.send(method, message)
+      self.file.send(method, message)
+      STDOUT.flush if method == :print
+    end
+  end
+
+  class LockedInteger < DatWorkerPool::LockedObject
+    def increment; @mutex.synchronize{ @object = @object + 1 }; end
+  end
+
+end
+
+BenchRunner.new.run

data/bench/report.txt

@@ -0,0 +1,7 @@
+Running benchmark report...
+
+........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
+
+Processing 100000 Work Items: 3388.7569ms
+
+Done running benchmark report

data/dat-worker-pool.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency("SystemTimer", ["~> 1.2"])
 
-  gem.add_development_dependency("assert", ["~> 2.14"])
+  gem.add_development_dependency("assert", ["~> 2.15"])
 
 end

data/lib/dat-worker-pool.rb

@@ -1,220 +1,71 @@
 require 'logger'
-require 'system_timer'
-require 'thread'
 
 require 'dat-worker-pool/version'
 require 'dat-worker-pool/queue'
+require 'dat-worker-pool/runner'
 require 'dat-worker-pool/worker'
 
 class DatWorkerPool
 
-  attr_reader :logger, :spawned
+  DEFAULT_NUM_WORKERS = 1
+  MIN_WORKERS         = 1
+
   attr_reader :queue
-  attr_reader :on_worker_error_callbacks
-  attr_reader :on_worker_start_callbacks, :on_worker_shutdown_callbacks
-  attr_reader :on_worker_sleep_callbacks, :on_worker_wakeup_callbacks
-  attr_reader :before_work_callbacks, :after_work_callbacks
-
-  def initialize(min = 0, max = 1, debug = false, &do_work_proc)
-    @min_workers  = min
-    @max_workers  = max
-    @debug        = debug
-    @logger       = Logger.new(@debug)
-    @do_work_proc = do_work_proc
-
-    @queue           = Queue.new
-    @workers_waiting = WorkersWaiting.new
-
-    @mutex   = Mutex.new
-    @workers = []
-    @spawned = 0
-
-    @on_worker_error_callbacks    = []
-    @on_worker_start_callbacks    = []
-    @on_worker_shutdown_callbacks = [proc{ |worker| despawn_worker(worker) }]
-    @on_worker_sleep_callbacks    = [proc{ @workers_waiting.increment }]
-    @on_worker_wakeup_callbacks   = [proc{ @workers_waiting.decrement }]
-    @before_work_callbacks        = []
-    @after_work_callbacks         = []
-
-    @started = false
+
+  def initialize(worker_class, options = nil)
+    if !worker_class.kind_of?(Class) || !worker_class.include?(DatWorkerPool::Worker)
+      raise ArgumentError, "worker class must include `#{DatWorkerPool::Worker}`"
+    end
+
+    options ||= {}
+    num_workers = (options[:num_workers] || DEFAULT_NUM_WORKERS).to_i
+    if num_workers < MIN_WORKERS
+      raise ArgumentError, "number of workers must be at least #{MIN_WORKERS}"
+    end
+
+    @queue = options[:queue] || begin
+      require 'dat-worker-pool/default_queue'
+      DatWorkerPool::DefaultQueue.new
+    end
+
+    @runner = DatWorkerPool::Runner.new({
+      :num_workers   => num_workers,
+      :logger        => options[:logger],
+      :queue         => @queue,
+      :worker_class  => worker_class,
+      :worker_params => options[:worker_params]
+    })
   end
 
   def start
-    @started = true
-    @queue.start
-    @min_workers.times{ spawn_worker }
+    @runner.start
   end
 
-  # * All work on the queue is left on the queue. It's up to the controlling
-  #   system to decide how it should handle this.
   def shutdown(timeout = nil)
-    @started = false
-    begin
-      OptionalTimeout.new(timeout){ graceful_shutdown }
-    rescue TimeoutError
-      force_shutdown(timeout, caller)
-    end
+    @runner.shutdown(timeout, caller)
   end
 
-  # * Always check if all workers are busy before pushing the work because
-  #   `@queue.push` can wakeup a worker. If you check after, you can see all
-  #   workers are busy because one just wokeup to handle what was just pushed.
-  #   This would cause it to spawn a worker when one isn't needed.
   def add_work(work_item)
     return if work_item.nil?
-    new_worker_needed = self.all_spawned_workers_are_busy?
-    @queue.push work_item
-    spawn_worker if @started && new_worker_needed && !reached_max_workers?
+    @queue.dwp_push work_item
   end
+  alias :push :add_work
 
   def work_items
     @queue.work_items
   end
 
-  def queue_empty?
-    @queue.empty?
-  end
-
-  def waiting
-    @workers_waiting.count
+  def available_worker_count
+    @runner.available_worker_count
   end
 
   def worker_available?
-    !reached_max_workers? || @workers_waiting.count > 0
-  end
-
-  def all_spawned_workers_are_busy?
-    @workers_waiting.count <= 0
-  end
-
-  def reached_max_workers?
-    @mutex.synchronize{ @spawned >= @max_workers }
-  end
-
-  def on_queue_pop_callbacks;  @queue.on_pop_callbacks;  end
-  def on_queue_push_callbacks; @queue.on_push_callbacks; end
-
-  def on_queue_pop(&block);  @queue.on_pop_callbacks  << block; end
-  def on_queue_push(&block); @queue.on_push_callbacks << block; end
-
-  def on_worker_error(&block);    @on_worker_error_callbacks    << block; end
-  def on_worker_start(&block);    @on_worker_start_callbacks    << block; end
-  def on_worker_shutdown(&block); @on_worker_shutdown_callbacks << block; end
-  def on_worker_sleep(&block);    @on_worker_sleep_callbacks    << block; end
-  def on_worker_wakeup(&block);   @on_worker_wakeup_callbacks   << block; end
-
-  def before_work(&block); @before_work_callbacks << block; end
-  def after_work(&block);  @after_work_callbacks  << block; end
-
-  private
-
-  def do_work(work_item)
-    @do_work_proc.call(work_item)
-  end
-
-  # * Always shutdown workers before the queue. `@queue.shutdown` wakes up the
-  #   workers. If you haven't told them to shutdown before they wakeup then they
-  #   won't start their shutdown when they are woken up.
-  # * Use `@workers.first.join until @workers.empty?` instead of `each` to join
-  #   all the workers. While we are joining a worker a separate worker can
-  #   shutdown and remove itself from the `@workers` array.
-  def graceful_shutdown
-    @workers.each(&:shutdown)
-    @queue.shutdown
-    @workers.first.join until @workers.empty?
-  end
-
-  # * Use `@workers.first until @workers.empty?` pattern instead of `each` to
-  #   raise and join all the workers. While we are raising and joining a worker
-  #   a separate worker can shutdown and remove itself from the `@workers`
-  #   array.
-  # * `rescue false` when joining the workers. Ruby will raise any exceptions
-  #   that aren't handled by a thread when its joined. This ensures if the hard
-  #   shutdown is raised and not rescued (for example, in the workers ensure),
-  #   then it won't cause the forced shutdown to end prematurely.
-  def force_shutdown(timeout, backtrace)
-    error = ShutdownError.new "Timed out shutting down the worker pool " \
-                              "(#{timeout} seconds)."
-    error.set_backtrace(backtrace)
-    until @workers.empty?
-      worker = @workers.first
-      worker.raise(error)
-      worker.join rescue false
-    end
-    raise error if @debug
+    @runner.worker_available?
   end
 
-  def spawn_worker
-    @mutex.synchronize{ spawn_worker! }
-  end
-
-  def spawn_worker!
-    Worker.new(@queue).tap do |w|
-      w.on_work = proc{ |worker, work_item| do_work(work_item) }
-
-      w.on_error_callbacks    = @on_worker_error_callbacks
-      w.on_start_callbacks    = @on_worker_start_callbacks
-      w.on_shutdown_callbacks = @on_worker_shutdown_callbacks
-      w.on_sleep_callbacks    = @on_worker_sleep_callbacks
-      w.on_wakeup_callbacks   = @on_worker_wakeup_callbacks
-      w.before_work_callbacks = @before_work_callbacks
-      w.after_work_callbacks  = @after_work_callbacks
-
-      @workers << w
-      @spawned += 1
-
-      w.start
-    end
-  end
-
-  def despawn_worker(worker)
-    @mutex.synchronize{ despawn_worker!(worker) }
-  end
-
-  def despawn_worker!(worker)
-    @spawned -= 1
-    @workers.delete worker
-  end
-
-  class WorkersWaiting
-    attr_reader :count
-
-    def initialize
-      @mutex = Mutex.new
-      @count = 0
-    end
-
-    def increment
-      @mutex.synchronize{ @count += 1 }
-    end
-
-    def decrement
-      @mutex.synchronize{ @count -= 1 }
-    end
-  end
-
-  module OptionalTimeout
-    def self.new(seconds, &block)
-      if seconds
-        SystemTimer.timeout(seconds, TimeoutError, &block)
-      else
-        block.call
-      end
-    end
-  end
-
-  module Logger
-    def self.new(debug)
-      debug ? ::Logger.new(STDOUT) : ::Logger.new(File.open('/dev/null', 'w'))
-    end
-  end
-
-  TimeoutError = Class.new(RuntimeError)
-
-  # * This error should never be "swallowed". If it is caught be sure to
-  #   re-raise it so the workers shutdown. Otherwise workers will get killed
-  #   (`Thread#kill`) by ruby which causes lots of issues.
+  # this error should never be "swallowed", if it is caught be sure to re-raise
+  # it so the workers shutdown; otherwise workers will get killed
+  # (`Thread#kill`) by ruby which can cause a problems
   ShutdownError = Class.new(Interrupt)
 
 end

data/lib/dat-worker-pool/default_queue.rb

@@ -0,0 +1,60 @@
+require 'thread'
+require 'dat-worker-pool/locked_object'
+require 'dat-worker-pool/queue'
+
+class DatWorkerPool
+
+  class DefaultQueue
+    include DatWorkerPool::Queue
+
+    attr_reader :on_push_callbacks, :on_pop_callbacks
+
+    def initialize
+      @work_items = LockedArray.new
+      @cond_var   = ConditionVariable.new
+
+      @on_push_callbacks = []
+      @on_pop_callbacks  = []
+    end
+
+    def work_items; @work_items.values; end
+    def empty?;     @work_items.empty?; end
+
+    def on_push(&block); @on_push_callbacks << block; end
+    def on_pop(&block);  @on_pop_callbacks  << block; end
+
+    private
+
+    # wake up workers (`@cond_var.broadcast`) who are sleeping because of `pop`
+    def shutdown!
+      @work_items.with_lock{ @cond_var.broadcast }
+    end
+
+    # add the work item and wakeup (`@cond_var.signal`) the first sleeping
+    # worker (from calling `pop`)
+    def push!(work_item)
+      @work_items.with_lock do |mutex, work_items|
+        work_items << work_item
+        @cond_var.signal
+      end
+      @on_push_callbacks.each{ |p| p.call(self, work_item) }
+    end
+
+    # check if the queue is empty, if so sleep (`@cond_var.wait(@mutex)`) until
+    # signaled (via `push!` or `shutdown!`); once a work item is available pop
+    # it from the front and return it; if shutdown, return `nil` which the
+    # workers will ignore
+    def pop!
+      work_item = @work_items.with_lock do |mutex, work_items|
+        while !self.shutdown? && work_items.empty?
+          @cond_var.wait(mutex)
+        end
+        work_items.shift unless self.shutdown?
+      end
+      @on_pop_callbacks.each{ |p| p.call(self, work_item) } if !work_item.nil?
+      work_item
+    end
+
+  end
+
+end