thread_storm 0.5.1 → 0.7.0

data/test/test_thread_storm.rb

@@ -2,75 +2,159 @@ require 'helper'
 
 class TestThreadStorm < Test::Unit::TestCase
   
-  def test_no_concurrency
-    storm = ThreadStorm.new :size => 1
-    storm.execute{ sleep(0.01); "one" }
-    storm.execute{ sleep(0.01); "two" }
-    storm.execute{ sleep(0.01); "three" }
-    assert_equal %w[one two three], storm.values
-    assert_all_threads_worked(storm)
+  def new_storm(options = {})
+    @storm = ThreadStorm.new(options)
   end
   
-  def test_partial_concurrency
-    storm = ThreadStorm.new :size => 2
-    storm.execute{ sleep(0.01); "one" }
-    storm.execute{ sleep(0.01); "two" }
-    storm.execute{ sleep(0.01); "three" }
-    assert_equal %w[one two three], storm.values
-    assert_all_threads_worked(storm)
+  def storm
+    @storm
   end
   
-  def test_full_concurrency
-    storm = ThreadStorm.new :size => 3
-    storm.execute{ sleep(0.01); "one" }
-    storm.execute{ sleep(0.01); "two" }
-    storm.execute{ sleep(0.01); "three" }
-    assert_equal %w[one two three], storm.values
-    assert_all_threads_worked(storm)
+  def new_execution(*args, &block)
+    @storm.new_execution(*args, &block)
   end
   
-  def test_timeout_no_concurrency
-    storm = ThreadStorm.new :size => 1, :timeout => 0.015
-    storm.execute{ sleep(0.01); "one" }
-    storm.execute{ sleep(0.02); "two" }
-    storm.execute{ sleep(0.01); "three" }
-    assert_equal ["one", nil, "three"], storm.values
-    assert storm.executions[1].timed_out?
-    assert_all_threads_worked(storm)
+  def new_controlled_execution(start, finish, value = nil)
+    @controls ||= {}
+    
+    execution = new_execution{ nil }
+    proc = Proc.new do
+      send_sign(execution, start)
+      wait_sign(execution, finish)
+      value
+    end
+    execution.instance_variable_set(:@block, proc)
+    
+    sign = nil
+    lock = Monitor.new
+    cond = lock.new_cond
+    @controls[execution] = [sign, lock, cond]
+    
+    execution
   end
   
-  # Tricky...
-  # 1 0.01s  ----
-  # 2 0.015s ------
-  # 3 0.01s      ----
-  def test_timeout_partial_concurrency
-    storm = ThreadStorm.new :size => 2, :timeout => 0.015
-    storm.execute{ sleep(0.01); "one" }
-    storm.execute{ sleep(0.02); "two" }
-    storm.execute{ sleep(0.01); "three" }
-    assert_equal ["one", nil, "three"], storm.values
-    assert storm.executions[1].timed_out?
-    assert_all_threads_worked(storm)
+  def wait_sign(execution, sign)
+    _sign, lock, cond = @controls[execution]
+    lock.synchronize{ cond.wait_until{ @controls[execution][0] == sign } }
   end
   
-  def test_timeout_full_concurrency
-    storm = ThreadStorm.new :size => 3, :timeout => 0.015
-    storm.execute{ sleep(0.01); "one" }
-    storm.execute{ sleep(0.02); "two" }
-    storm.execute{ sleep(0.01); "three" }
-    assert_equal ["one", nil, "three"], storm.values
-    assert storm.executions[1].timed_out?
-    assert_all_threads_worked(storm)
+  def send_sign(execution, sign)
+    _sign, lock, cond = @controls[execution]
+    lock.synchronize{ @controls[execution][0] = sign; cond.broadcast }
+  end
+  
+  def test_no_concurrency
+    new_storm :size => 1
+    e1 = new_controlled_execution(1, 2)
+    e2 = new_controlled_execution(1, 2)
+    e3 = new_controlled_execution(1, 2)
+    storm.execute(e1)
+    storm.execute(e2)
+    storm.execute(e3)
+    
+    wait_sign(e1, 1)
+    assert_equal :started, e1.state(:sym)
+    assert_equal :queued,  e2.state(:sym)
+    assert_equal :queued,  e3.state(:sym)
+    
+    send_sign(e1, 2); e1.join
+    wait_sign(e2, 1)
+    assert_equal :finished, e1.state(:sym)
+    assert_equal :started,  e2.state(:sym)
+    assert_equal :queued,   e3.state(:sym)
+    
+    send_sign(e2, 2); e2.join
+    wait_sign(e3, 1)
+    assert_equal :finished, e1.state(:sym)
+    assert_equal :finished, e2.state(:sym)
+    assert_equal :started,  e3.state(:sym)
+    
+    send_sign(e3, 2); e3.join
+    assert_equal :finished, e1.state(:sym)
+    assert_equal :finished, e2.state(:sym)
+    assert_equal :finished, e3.state(:sym)
+  end
+  
+  def test_partial_concurrency
+    new_storm :size => 2
+    e1 = new_controlled_execution(1, 2)
+    e2 = new_controlled_execution(1, 2)
+    e3 = new_controlled_execution(1, 2)
+    storm.execute(e1)
+    storm.execute(e2)
+    storm.execute(e3)
+    
+    wait_sign(e1, 1)
+    wait_sign(e2, 1)
+    assert_equal :started, e1.state(:sym)
+    assert_equal :started, e2.state(:sym)
+    assert_equal :queued,  e3.state(:sym)
+    
+    send_sign(e1, 2); e1.join
+    send_sign(e2, 2); e2.join
+    wait_sign(e3, 1)
+    assert_equal :finished, e1.state(:sym)
+    assert_equal :finished, e2.state(:sym)
+    assert_equal :started,  e3.state(:sym)
+    
+    send_sign(e3, 2); e3.join
+    assert_equal :finished, e1.state(:sym)
+    assert_equal :finished, e2.state(:sym)
+    assert_equal :finished, e3.state(:sym)
+  end
+  
+  def test_full_concurrency
+    new_storm :size => 3
+    e1 = new_controlled_execution(1, 2)
+    e2 = new_controlled_execution(1, 2)
+    e3 = new_controlled_execution(1, 2)
+    storm.execute(e1)
+    storm.execute(e2)
+    storm.execute(e3)
+    
+    wait_sign(e1, 1)
+    wait_sign(e2, 1)
+    wait_sign(e3, 1)
+    assert_equal :started, e1.state(:sym)
+    assert_equal :started, e2.state(:sym)
+    assert_equal :started, e3.state(:sym)
+    
+    send_sign(e1, 2); e1.join
+    send_sign(e2, 2); e2.join
+    send_sign(e3, 2); e3.join
+    assert_equal :finished, e1.state(:sym)
+    assert_equal :finished, e2.state(:sym)
+    assert_equal :finished, e3.state(:sym)
+  end
+  
+  def test_timeout
+    ThreadStorm.new :size => 1, :timeout => 0.01 do |storm|
+      storm.execute{ sleep(0.02) }
+      storm.join
+      assert_equal true, storm.executions[0].timeout?
+      assert_equal nil, storm.executions[0].value
+    end
   end
   
   def test_timeout_with_default_value
-    storm = ThreadStorm.new :size => 1, :timeout => 0.015, :default_value => "timed out"
-    storm.execute{ sleep(0.01); "one" }
-    storm.execute{ sleep(0.02); "two" }
-    storm.execute{ sleep(0.01); "three" }
-    assert_equal ["one", "timed out", "three"], storm.values
-    assert storm.executions[1].timed_out?
-    assert_all_threads_worked(storm)
+    ThreadStorm.new :size => 1, :timeout => 0.01, :default_value => "timed out" do |storm|
+      storm.execute{ sleep(0.02) }
+      storm.join
+      assert_equal true, storm.executions[0].timeout?
+      assert_equal "timed out", storm.executions[0].value
+    end
+  end
+  
+  def test_exception
+    ThreadStorm.new :size => 1 do |storm|
+      storm.execute{ raise ArgumentError, "test" }
+      assert_raise(ArgumentError){ storm.join }
+      assert_equal true, storm.executions[0].exception?
+      assert_equal ArgumentError, storm.executions[0].exception.class
+      assert_equal "test", storm.executions[0].exception.message
+      storm.clear_executions # We have to clear executions here or the exception will get
+                             # raised again when ThreadStorm#new eventually calls join.
+    end
   end
   
   def test_shutdown
@@ -147,16 +231,112 @@ class TestThreadStorm < Test::Unit::TestCase
     storm.shutdown
   end
   
-  def test_for_deadlocks
-    ThreadStorm.new :size => 10, :execute_blocks => true do |storm|
-      20.times do
-        storm.execute do
-          ThreadStorm.new :size => 10, :timeout => 0.5 do |storm2|
-            20.times{ storm2.execute{ sleep(rand) } }
-          end
-        end
+  def test_duration
+    ThreadStorm.new do |s|
+      e = s.execute{ sleep(0.2) }
+      e.join
+      assert e.duration >= 0.2
+    end
+  end
+  
+  def test_states
+    lock = Monitor.new
+    cond = lock.new_cond
+    sign = 1
+    
+    storm = ThreadStorm.new :size => 1
+    storm.execute do
+      lock.synchronize do
+        cond.wait_until{ sign == 2 }
+      end
+    end
+    
+    execution = storm.new_execution do
+      lock.synchronize do
+        sign = 3
+        cond.signal
+        cond.wait_until{ sign == 4 }
       end
     end
+    assert_equal :initialized, execution.state(:sym)
+    
+    storm.execute(execution)
+    assert_equal :queued, execution.state(:sym)
+    
+    lock.synchronize{ sign = 2; cond.broadcast }
+    lock.synchronize{ cond.wait_until{ sign == 3 } }
+    assert_equal :started, execution.state(:sym)
+    
+    lock.synchronize{ sign = 4; cond.signal }
+    execution.join
+    assert_equal :finished, execution.state(:sym)
+    
+    assert_equal false, execution.exception?
+    
+    assert execution.initialized_at < execution.queued_at
+    assert execution.queued_at < execution.started_at
+    assert execution.started_at < execution.finished_at
+    
+    assert execution.duration(:initialized) > 0
+    assert execution.duration(:queued) > 0
+    assert execution.duration(:started) > 0
+    assert execution.duration(:finished) > 0
+    
+    storm.shutdown
+  end
+  
+  def test_global_options
+    storm = ThreadStorm.new
+    assert_equal ThreadStorm::DEFAULTS, storm.options
+    
+    ThreadStorm.options[:size] = 5
+    ThreadStorm.options[:timeout] = 10
+    ThreadStorm.options[:default_value] = "new_default_value"
+    storm = ThreadStorm.new
+    assert_not_equal ThreadStorm::DEFAULTS, storm.options
+    assert_equal 5, storm.options[:size]
+    assert_equal 10, storm.options[:timeout]
+    assert_equal "new_default_value", storm.options[:default_value]
+    
+    # !IMPORTANT! So the rest of the tests work...
+    ThreadStorm.options.replace(ThreadStorm::DEFAULTS)
+  end
+  
+  def test_execution_options
+    storm = ThreadStorm.new :timeout => 0.3
+    e1 = storm.new_execution{ sleep }
+    e2 = storm.new_execution{ sleep }
+    e3 = storm.new_execution{ sleep }
+    e1.options[:timeout] = 0.1
+    e2.options[:timeout] = 0.2
+    
+    storm.run do
+      storm.execute(e1)
+      storm.execute(e2)
+      storm.execute(e3)
+    end
+    assert [e1, e2, e3].all?{ |e| e.timeout? }
+    
+    # Yes, I know the following is a bad test...
+    assert e1.duration < 0.2
+    assert e2.duration < 0.3
+    assert e3.duration < 0.4
+    
+    assert_raises(RuntimeError, TypeError){ e1.options[:timeout] = 0.4 }
+  end
+  
+  def test_new_execution_with_options
+    storm = ThreadStorm.new :timeout => 1
+    
+    execution = storm.new_execution
+    assert_equal nil, ThreadStorm.options[:timeout]
+    assert_equal 1, storm.options[:timeout]
+    assert_equal 1, execution.options[:timeout]
+    
+    execution = storm.new_execution :timeout => 2
+    assert_equal nil, ThreadStorm.options[:timeout]
+    assert_equal 1, storm.options[:timeout]
+    assert_equal 2, execution.options[:timeout]
   end
   
 end

data/thread_storm.gemspec

@@ -1,46 +1,50 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{thread_storm}
-  s.version = "0.5.1"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Christopher J. Bottaro"]
-  s.date = %q{2010-06-24}
+  s.date = %q{2011-02-02}
   s.description = %q{Simple thread pool with timeouts, default values, error handling, state tracking and unit tests.}
   s.email = %q{cjbottaro@alumni.cs.utexas.edu}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+    "README.rdoc",
+    "TODO"
   ]
   s.files = [
     ".document",
-     ".gitignore",
-     "CHANGELOG",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/thread_storm.rb",
-     "lib/thread_storm/active_support.rb",
-     "lib/thread_storm/execution.rb",
-     "lib/thread_storm/sentinel.rb",
-     "lib/thread_storm/worker.rb",
-     "test/helper.rb",
-     "test/test_thread_storm.rb",
-     "thread_storm.gemspec"
+    "CHANGELOG",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "TODO",
+    "VERSION",
+    "lib/thread_storm.rb",
+    "lib/thread_storm/active_support.rb",
+    "lib/thread_storm/execution.rb",
+    "lib/thread_storm/queue.rb",
+    "lib/thread_storm/worker.rb",
+    "test/helper.rb",
+    "test/test_callbacks.rb",
+    "test/test_execution.rb",
+    "test/test_thread_storm.rb",
+    "thread_storm.gemspec"
   ]
   s.homepage = %q{http://github.com/cjbottaro/thread_storm}
-  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Simple thread pool with a few advanced features.}
   s.test_files = [
     "test/helper.rb",
-     "test/test_thread_storm.rb"
+    "test/test_callbacks.rb",
+    "test/test_execution.rb",
+    "test/test_thread_storm.rb"
   ]
 
   if s.respond_to? :specification_version then

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: thread_storm
 version: !ruby/object:Gem::Version 
-  hash: 9
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 1
-  version: 0.5.1
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Christopher J. Bottaro
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-24 00:00:00 -05:00
+date: 2011-02-02 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -28,20 +27,23 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
+- TODO
 files: 
 - .document
-- .gitignore
 - CHANGELOG
 - LICENSE
 - README.rdoc
 - Rakefile
+- TODO
 - VERSION
 - lib/thread_storm.rb
 - lib/thread_storm/active_support.rb
 - lib/thread_storm/execution.rb
-- lib/thread_storm/sentinel.rb
+- lib/thread_storm/queue.rb
 - lib/thread_storm/worker.rb
 - test/helper.rb
+- test/test_callbacks.rb
+- test/test_execution.rb
 - test/test_thread_storm.rb
 - thread_storm.gemspec
 has_rdoc: true
@@ -49,8 +51,8 @@ homepage: http://github.com/cjbottaro/thread_storm
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -58,7 +60,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -67,7 +68,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -80,4 +80,6 @@ specification_version: 3
 summary: Simple thread pool with a few advanced features.
 test_files: 
 - test/helper.rb
+- test/test_callbacks.rb
+- test/test_execution.rb
 - test/test_thread_storm.rb

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC

data/lib/thread_storm/sentinel.rb

@@ -1,18 +0,0 @@
-require "monitor"
-
-class ThreadStorm
-  class Sentinel
-    attr_reader :e_cond, :p_cond
-    
-    def initialize
-      @lock = Monitor.new
-      @e_cond = @lock.new_cond # execute condition
-      @p_cond = @lock.new_cond # pop condition
-    end
-    
-    def synchronize
-      @lock.synchronize{ yield(@e_cond, @p_cond) }
-    end
-    
-  end
-end