threadz 0.1.1 → 0.1.3

data/Rakefile

@@ -32,7 +32,17 @@ end
 
 desc "Run all test cases"
 task 'spec' do |task|
-  exec 'spec -c spec/*.rb'
+  exec 'spec -c -f n spec/*.rb spec/basic/*.rb'
+end
+
+desc "Run all performance-oriented test cases"
+task 'spec:performance' do |task|
+  exec 'spec -c -f n -t 30.0 spec/spec_helper.rb spec/performance/*.rb'
+end
+
+desc "Run *all* specs"
+task 'spec:all' do |task|
+  exec 'spec -c -f n -t 30.0 spec/spec_helper.rb spec/**/*.rb'
 end
 
 desc "Run all test cases 10 times (or n times)"
@@ -114,8 +124,8 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = "threadz"
-    gemspec.summary = "A Ruby threadpool library to handle threadpools and make batch jobs easier."
-    #gemspec.description = "Longer description?"
+    gemspec.summary = "An easy Ruby threadpool library."
+    gemspec.description = "A Ruby threadpool library to handle threadpools and make batch jobs easier."
     gemspec.email = "nanodeath@gmail.com"
     gemspec.homepage = "http://github.com/nanodeath/threadz"
     gemspec.authors = ["Max Aller"]

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.3

data/lib/threadz/atomic_integer.rb

@@ -1,6 +1,10 @@
 require 'thread'
 
 module Threadz
+	# Related to, or at least named after, Java's AtomicInteger.
+	# Provides a thread-safe integer counter thing.
+	# The code used in this file, while slightly verbose, is to optimize
+	# performance.  Avoiding additional method calls and blocks is preferred.
 	class AtomicInteger
 		def initialize(value)
 			@value = value
@@ -20,9 +24,17 @@ module Threadz
 		end
 
 		def decrement(amount=1)
+			# We could refactor and just call set here, but it's faster just to write
+			# the extra two lines.
 			@mutex.lock
 			@value -= amount
 			@mutex.unlock
 		end
+
+		def set(value)
+			@mutex.lock
+			@value = value
+			@mutex.unlock
+		end
 	end
 end

data/lib/threadz/batch.rb

@@ -55,24 +55,20 @@ module Threadz
       # +:timeout+:: If specified, will only wait for at least this many seconds
       #              for the batch to finish.  Typically used with #completed?
       def wait_until_done(opts={})
-        return if completed?
-
         raise "Threadz: thread deadlocked because batch job was never started" if @latent && !@started
 
         timeout = opts.key?(:timeout) ? opts[:timeout] : 0
-        #raise "Timeout not supported at the moment" if timeout
-
-        @sleeper.wait(timeout)
+        @sleeper.wait(timeout) unless completed?
       end
 
-      # Returns true iff there are no unfinished jobs in the queue.
+      # Returns true iff there are no jobs outstanding.
       def completed?
         return @jobs_count.value == 0
       end
 
       # If this is a latent batch, start processing all of the jobs in the queue.
       def start
-        Thread.exclusive do # in case another thread tries to push new jobs onto the queue while we're starting
+				@job_lock.synchronize {  # in case another thread tries to push new jobs onto the queue while we're starting
           if @latent
             @started = true
             until @job_queue.empty?
@@ -82,19 +78,13 @@ module Threadz
           else
             return false
           end
-        end
+				}
       end
 
       # Execute a given block when the batch has finished processing.  If the batch
       # has already finished executing, execute immediately.
       def when_done(&block)
-        @job_lock.lock
-        if completed?
-          block.call
-        else
-          @when_done_blocks << block
-        end
-        @job_lock.unlock
+        @job_lock.synchronize { completed? ? block.call : @when_done_blocks << block }
       end
 
       private
@@ -110,11 +100,13 @@ module Threadz
         @threadpool.process do
           job.call
           # Lock in case we get two threads at the "fork in the road" at the same time
-          @job_lock.lock
+					# Note: locking here actually creates undesirable behavior.  Still investigating why,
+					# seems like it should be useful.
+          #@job_lock.lock
           @jobs_count.decrement
           # fork in the road
           handle_done if completed?
-          @job_lock.unlock
+          #@job_lock.unlock
         end
       end
     end

data/lib/threadz/thread_pool.rb

@@ -80,7 +80,8 @@ module Threadz
 
     # Kill a thread after it completes its current job
     def kill_thread
-      @queue.unshift(Directive::SUICIDE_PILL)
+      # TODO: ideally this would be unshift, but Queues don't have that.  Come up with an alternative.
+      @queue << Directive::SUICIDE_PILL
     end
 
     # This thread watches over the pool and allocated and deallocates threads

data/spec/basic/thread_pool_spec.rb

@@ -0,0 +1,41 @@
+require 'net/http'
+
+describe Threadz::ThreadPool do
+	before(:each) do
+		@T = Threadz::ThreadPool.new
+	end
+
+	it "should perform well for IO jobs" do
+		urls = []
+		urls << "http://www.google.com/" << "http://www.yahoo.com/" << 'http://www.microsoft.com/'
+		urls << "http://www.cnn.com/" << "http://slashdot.org/" << "http://www.mozilla.org/"
+		urls << "http://www.ubuntu.com/" << "http://github.com/"
+		time_single_threaded = Time.now
+
+		begin
+			(urls * 2).each do |url|
+				response = Net::HTTP.get_response(URI.parse(url))
+				body = response.body
+			end
+
+			time_single_threaded = Time.now - time_single_threaded
+
+			time_multi_threaded = Time.now
+			b = @T.new_batch
+			(urls * 2).each do |url|
+				b << Proc.new do
+					response = Net::HTTP.get_response(URI.parse(url))
+					body = response.body
+				end
+			end
+
+			b.wait_until_done
+			time_multi_threaded = Time.now - time_multi_threaded
+
+			time_multi_threaded.should < time_single_threaded
+
+		rescue SocketError
+			pending "pending working internet connection"
+		end
+	end
+end

data/spec/performance/batch_spec.rb

@@ -0,0 +1,29 @@
+require 'timeout'
+
+describe Threadz::Batch do
+	before(:each) do
+		@T = Threadz::ThreadPool.new(:initial_size => 25)
+	end
+
+	it "shouldn't fail under load" do
+		jobs = 1000
+		times_per_job = 1000
+		i = ::Threadz::AtomicInteger.new(0)
+
+		b1 = @T.new_batch(:latent => true)
+		b2 = @T.new_batch(:latent => true)
+
+		jobs.times do
+			b1 << lambda { times_per_job.times { i.increment } }
+			b2 << lambda { times_per_job.times { i.decrement } }
+		end
+
+		b1.start
+		b2.start
+
+		b1.wait_until_done
+		b2.wait_until_done
+
+		i.value.should == 0
+	end
+end

data/spec/threadz_spec.rb

@@ -1,8 +1,6 @@
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
 require 'spec_helper'
 
-require 'net/http'
-
 describe Threadz do
   describe Threadz::ThreadPool do
     before(:each) do
@@ -26,40 +24,6 @@ describe Threadz do
       lambda { @T.new_batch(:latent => true) }.should_not raise_error
     end
 
-    it "should perform well for IO jobs" do
-      urls = []
-      urls << "http://www.google.com/" << "http://www.yahoo.com/" << 'http://www.microsoft.com/'
-      urls << "http://www.cnn.com/" << "http://slashdot.org/" << "http://www.mozilla.org/"
-      urls << "http://www.ubuntu.com/" << "http://github.com/"
-      time_single_threaded = Time.now
-
-      begin
-        (urls * 3).each do |url|
-          response = Net::HTTP.get_response(URI.parse(url))
-          body = response.body
-        end
-
-        time_single_threaded = Time.now - time_single_threaded
-
-        time_multi_threaded = Time.now
-        b = @T.new_batch
-        (urls * 3).each do |url|
-          b << Proc.new do
-            response = Net::HTTP.get_response(URI.parse(url))
-            body = response.body
-          end
-        end
-
-        b.wait_until_done
-        time_multi_threaded = Time.now - time_multi_threaded
-
-        time_multi_threaded.should < time_single_threaded
-
-      rescue SocketError
-        pending "pending working internet connection"
-      end
-    end
-
     describe Threadz::Batch do
       it "should support jobs" do
         i = 0
@@ -108,7 +72,7 @@ describe Threadz do
         @i.should == 3
       end
 
-      it "should support latent option correctly" do
+      it "should support latent option" do
         i = 0
         b = @T.new_batch(:latent => true)
         b << lambda { i += 1 }
@@ -172,11 +136,11 @@ describe Threadz do
       end
 
       it "should support 'when_done'" do
-        i = 0
+        i = ::Threadz::AtomicInteger.new(0)
         when_done_executed = false
         b = @T.new_batch(:latent => true)
 
-        100.times { b << lambda { i += 1 } }
+        100.times { b << lambda { i.increment } }
 
         b.when_done { when_done_executed = true }
 
@@ -184,8 +148,12 @@ describe Threadz do
 
         b.start
 
-        sleep(0.1)
+				Timeout::timeout(10) do
+					sleep(0.1) until i.value == 100
+				end
 
+				i.value.should == 100
+				
         b.completed?.should be_true
         when_done_executed.should be_true
       end
@@ -193,11 +161,11 @@ describe Threadz do
       it "should call 'when_done' immediately when batch is already done" do
         i = 0
         when_done_executed = false
-        b = @T.new_batch
+        b = @T.new_batch :latent => true
 
-        Thread.exclusive do
-          100.times { b << lambda { i += 1 } }
-        end
+				100.times { b << lambda { i += 1 } }
+
+				b.start
 
         b.wait_until_done
 
@@ -211,42 +179,19 @@ describe Threadz do
       it "should support multiple 'when_done' blocks" do
         i = 0
         when_done_executed = 0
-        b = @T.new_batch
+        b = @T.new_batch :latent => true
 
-        # We're not testing what happens when 'when_done' is called and
-        # the batch is already finished, so wrapping in Thread#exclusive
-        Thread.exclusive do
-          100.times { b << lambda { i += 1 } }
-        end
+				100.times { b << lambda { i += 1 } }
 
-        3.times { b.when_done { when_done_executed += 1 } }
+        10.times { b.when_done { when_done_executed += 1 } }
 
-        sleep(0.1)
 
-        b.completed?.should be_true
-        when_done_executed.should == 3
-      end
+				b.start
 
-      it "shouldn't fail under load" do
-        jobs = 1000
-        times_per_job = 100
-        i = ::Threadz::AtomicInteger.new(0)
-
-        b1 = @T.new_batch(:latent => true)
-        b2 = @T.new_batch(:latent => true)
-
-        jobs.times do
-          b1 << lambda { times_per_job.times { i.increment } }
-          b2 << lambda { times_per_job.times { i.decrement } }
-        end
-
-        b1.start
-        b2.start
-
-        b1.wait_until_done
-        b2.wait_until_done
+        b.wait_until_done
 
-        i.value.should == 0
+        b.completed?.should be_true
+        when_done_executed.should == 10
       end
     end
   end

data/threadz.gemspec

@@ -5,11 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{threadz}
-  s.version = "0.1.1"
+  s.version = "0.1.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Max Aller"]
-  s.date = %q{2009-12-19}
+  s.date = %q{2010-02-01}
+  s.description = %q{A Ruby threadpool library to handle threadpools and make batch jobs easier.}
   s.email = %q{nanodeath@gmail.com}
   s.extra_rdoc_files = [
     "README.rdoc"
@@ -28,6 +29,8 @@ Gem::Specification.new do |s|
      "lib/threadz/sleeper.rb",
      "lib/threadz/thread_pool.rb",
      "spec/atomic_integer_spec.rb",
+     "spec/basic/thread_pool_spec.rb",
+     "spec/performance/batch_spec.rb",
      "spec/spec_helper.rb",
      "spec/threadz_spec.rb",
      "threadz.gemspec"
@@ -36,11 +39,13 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.5}
-  s.summary = %q{A Ruby threadpool library to handle threadpools and make batch jobs easier.}
+  s.summary = %q{An easy Ruby threadpool library.}
   s.test_files = [
     "spec/atomic_integer_spec.rb",
      "spec/threadz_spec.rb",
-     "spec/spec_helper.rb"
+     "spec/performance/batch_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/basic/thread_pool_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: threadz
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors: 
 - Max Aller
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-19 00:00:00 -08:00
+date: 2010-02-01 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
-description: 
+description: A Ruby threadpool library to handle threadpools and make batch jobs easier.
 email: nanodeath@gmail.com
 executables: []
 
@@ -35,6 +35,8 @@ files:
 - lib/threadz/sleeper.rb
 - lib/threadz/thread_pool.rb
 - spec/atomic_integer_spec.rb
+- spec/basic/thread_pool_spec.rb
+- spec/performance/batch_spec.rb
 - spec/spec_helper.rb
 - spec/threadz_spec.rb
 - threadz.gemspec
@@ -65,8 +67,10 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: A Ruby threadpool library to handle threadpools and make batch jobs easier.
+summary: An easy Ruby threadpool library.
 test_files: 
 - spec/atomic_integer_spec.rb
 - spec/threadz_spec.rb
+- spec/performance/batch_spec.rb
 - spec/spec_helper.rb
+- spec/basic/thread_pool_spec.rb