omg-threadpool 0.2.4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Igor Gunko
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,28 @@
+=== Introduction
+O HAI! My name is Pool, Thread Pool. Now in Ruby.
+
+=== Installation
+  gem install omg-threadpool --source http://gems.github.com
+
+=== Usage
+  pool = ThreadPool.new
+  ...
+  pool.run(...) do |...|
+    ...
+  end
+  ...
+  pool.close
+
+=== More info in docs
+http://rdoc.info/projects/omg/threadpool
+
+=== Bugs & such
+Please report via Github issue tracking.
+
+=== See also
+* http://github.com/omg/xmlnuts -- Ruby <-> XML mapping
+* http://github.com/omg/statelogic -- A simple state machine for ActiveRecord
+
+
+Free hint: If you liek mudkipz^W^Wfeel like generous today you can tip me at http://tipjoy.com/u/pisuka
+

data/Rakefile

@@ -0,0 +1,27 @@
+$KCODE = 'u'
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+Rake::GemPackageTask.new(Gem::Specification.load('threadpool.gemspec')) do |p|
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.rdoc" # page to start on
+  rdoc.title = "XmlNuts Documentation"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers' << '--inline-source'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end
+

data/lib/omg-threadpool.rb

@@ -0,0 +1 @@
+require 'threadpool'

data/lib/threadpool.rb

@@ -0,0 +1,191 @@
+require 'thread'
+require 'thwait'
+require 'monitor'
+
+# This is unsurprisingly a thread pool.
+# It can run your jobs asynchronously.
+# It can grow and shrink depending on the load.
+# Like any good pool it can be... closed!
+class ThreadPool
+  DEFAULT_CORE_WORKERS = 4
+  DEFAULT_KEEP_ALIVE_TIME = 5
+
+  class Job #:nodoc:
+    def initialize(*args, &handler)
+      @args, @handler = args, handler
+    end
+  
+    def run
+      @handler.call(*@args)
+    end
+  end
+
+  @@controllers = ThreadGroup.new
+
+  #    new([[core_workers[, max_workers[, keep_alive_time]],] options]) [{|pool| ... }]
+  #
+  # === Arguments
+  # [+core_workers+]    Number of core worker threads. The pool will never shrink below this point.
+  # [+max_workers+]     Maximum number of worker threads allowed per this pool.
+  #                     The pool will never expand over this limit.
+  #                     Default is +core_workers * 2+
+  # [+keep_alive_time+] Time to keep non-core workers alive. Default is 5 sec.
+  # [+options+]         +:core =>+ _core_workers_,
+  #                     +:max =>+ _max_workers_,
+  #                     +:keep_alive =>+ _keep_alive_time_,
+  #                     +:init_core => false+ to defer initial setup of core workers.
+  # 
+  # When called with a block the pool will be closed upon exit from the block.
+  # Graceful +close+ will be used, a non-bang version.
+  #
+  # === Example:
+  #   ThreadPool.new 10, 25, 6.7, :init_core => false do |pool|
+  #   ...
+  #   end
+  def initialize(*args)
+    extend MonitorMixin
+    
+    options = args.last.is_a?(Hash) ? args.pop : {}
+
+    @core_workers = (args[0] || options[:core] || DEFAULT_CORE_WORKERS).to_i
+    raise ArgumentError, "core_workers must be a positive integer" if @core_workers <= 0
+    
+    @max_workers = (args[1] || options[:max] || @core_workers * 2).to_i
+    raise ArgumentError, "max_workers must be >= core_workers" if @max_workers < @core_workers
+
+    @keep_alive_time = (args[2] || options[:keep_alive] || DEFAULT_KEEP_ALIVE_TIME).to_f
+    raise ArgumentError, "keep_alive_time must be a non-negative real number" if @keep_alive_time < 0
+
+    @workers, @jobs = [], Queue.new
+
+    @controller = Thread.new do
+      loop do
+        sleep(@keep_alive_time)
+        break if @dead
+        synchronize do
+          n = @jobs.num_waiting - @core_workers
+          stop_workers([n / 2, 1].max) if n >= 0
+        end
+      end
+    end
+    @@controllers.add(@controller)
+    
+    create_workers(@core_workers) if options.fetch(:init_core, true)
+    
+    begin
+      yield self
+    ensure
+      shutdown
+    end if block_given?
+  end
+  
+  #    alive? => boolean
+  #
+  # Pool is live when it's not dead.
+  # Pool is dead when it's closed.
+  def alive?
+    synchronize { !@dead }
+  end
+  
+  #    run([arg1[, arg2[, ...]]]) {|[arg1[, arg2[, ...]]]| ... } -> pool
+  #
+  # Schedule the block to run asynchronously on a worker thread. Return immediately.
+  # Any arguments passed to this method will be passed to the block.
+  #
+  # When there are no idle workers the pool will grow.
+  # When max pool size is reached the job will be queued up until better times.
+  #
+  # === Example:
+  #   pool.run('go to hell') do |greeting|
+  #     puts greeting
+  #   end
+  def run(*args, &block)
+    run_core(true, *args, &block)
+  end
+  
+  #    try_run([arg1[, arg2[, ...]]]) {|[arg1[, arg2[, ...]]]| ... } -> pool or nil
+  #
+  # Try to run the block asynchronously on a worker thread (see +run+).
+  # If there are no idle workers immediately available and the pool reached its maximum size,
+  # then do not enqueue the job and return +nil+.
+  #
+  # === Example:
+  #   puts 'zomg' unless pool.try_run('go to hell') {|greeting| puts greeting }
+  def run?(*args, &block)
+    run_core(false, *args, &block)
+  end
+  
+  #    close
+  #
+  # Rape me gently. Waits until all the jobs are done and destroys the pool.
+  def close
+    _sync do
+      @dead = true
+      @controller.run
+      stop_workers(@workers.size)
+    end
+    ThreadsWait.all_waits(@controller, *@workers)
+    self
+  end
+  
+  #    close!
+  #
+  # Rape me hard. Instantly kills the workers. Ensure blocks will be called though (last prayer on).
+  def close!
+    _sync do
+      @dead = true
+      @controller.run
+      @workers.each {|w| w.kill }
+    end
+    self
+  end
+
+  private
+  
+  def run_core(enqueue, *args, &block) #:nodoc:
+    raise ArgumentError, 'block must be provided' unless block_given?
+    _sync do
+      if @jobs.num_waiting == 0
+        if @workers.size < @max_workers
+          create_worker
+        else
+          return nil unless enqueue
+        end
+      end
+      @jobs.push(Job.new(*args, &block))
+    end
+    self
+  end
+  
+  def _sync #:nodoc:
+    synchronize do
+      check_state
+      yield
+    end
+  end
+
+  def check_state #:nodoc:
+    raise "pool's closed" if @dead
+  end
+
+  def create_worker #:nodoc:
+    @workers << Thread.new(&method(:worker_routine))
+  end
+
+  def create_workers(n) #:nodoc:
+    n.times { create_worker }
+  end
+
+  def stop_workers(n) #:nodoc:
+    n.times { @jobs << nil }
+  end
+  
+  def worker_routine #:nodoc:
+    while job = @jobs.pop
+      job.run rescue nil
+    end
+  ensure
+    synchronize { @workers.delete(Thread.current) unless @dead }
+  end
+end
+

data/test/threadpool_test.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'lib/threadpool'
+
+
+class ThreadPoolTest < Test::Unit::TestCase
+  def setup
+  end
+
+  def test_me
+    @pool = ThreadPool.new(2, 15, 1)
+    n = 0
+    p = proc {|x| n += x }
+    100.times {|i| @pool.run(i, &p) }
+    @pool.close
+    assert_equal 4950, n
+  end
+end
+

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+name: omg-threadpool
+version: !ruby/object:Gem::Version 
+  version: 0.2.4
+platform: ruby
+authors: 
+- Igor Gunko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-21 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: tekmon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- README.rdoc
+- MIT-LICENSE
+- Rakefile
+- lib/threadpool.rb
+- lib/omg-threadpool.rb
+has_rdoc: true
+homepage: http://github.com/omg/threadpool
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Thread pool for Ruby
+test_files: 
+- test/threadpool_test.rb