comp_tree 1.0.1 → 1.1.0

data/lib/comp_tree.rb

@@ -1,5 +1,5 @@
 # 
-# Copyright (c) 2008, 2009 James M. Lawrence.  All rights reserved.
+# Copyright (c) 2008-2011 James M. Lawrence.  All rights reserved.
 # 
 # Permission is hereby granted, free of charge, to any person
 # obtaining a copy of this software and associated documentation files
@@ -27,4 +27,54 @@ require 'comp_tree/queue/queue'
 require 'comp_tree/node'
 require 'comp_tree/algorithm'
 require 'comp_tree/driver'
-require 'comp_tree/comp_tree'
+
+#
+# CompTree -- Parallel Computation Tree.
+#
+# See README.rdoc.
+#
+module CompTree
+  #
+  # :call-seq:
+  #   build { |driver| ... }
+  #
+  # Build a new computation tree. A Driver instance is passed to the
+  # given block.
+  #
+  # Example:
+  #   CompTree.build do |driver|
+  # 
+  #     # Define a function named 'area' taking these two arguments.
+  #     driver.define(:area, :width, :height) { |width, height|
+  #       width*height
+  #     }
+  #     
+  #     # Define a function 'width' which takes a 'border' argument.
+  #     driver.define(:width, :border) { |border|
+  #       7 + border
+  #     }
+  #     
+  #     # Ditto for 'height'.
+  #     driver.define(:height, :border) { |border|
+  #       5 + border
+  #     }
+  # 
+  #     #    
+  #     # Define a constant function 'border'.
+  #     driver.define(:border) {
+  #       2
+  #     }
+  #     
+  #     # Compute the area using four parallel threads.
+  #     puts driver.compute(:area, 4)
+  #     # => 63
+  # 
+  #     # We've done this computation.
+  #     puts((7 + 2)*(5 + 2))
+  #     # => 63
+  #   end
+  #
+  def self.build(opts = {})
+    yield Driver.new(opts)
+  end
+end

data/lib/comp_tree/algorithm.rb

@@ -3,40 +3,35 @@ module CompTree
   module Algorithm
     module_function
 
-    def compute_parallel(root, num_threads)
+    def compute_parallel(root, max_threads)
+      workers = []
       from_workers = Queue.new
       to_workers = Queue.new
 
-      workers = (1..num_threads).map {
-        Thread.new {
-          worker_loop(from_workers, to_workers)
-        }
-      }
-
-      node = master_loop(root, num_threads, from_workers, to_workers)
+      node = master_loop(root, max_threads, workers, from_workers, to_workers)
 
-      num_threads.times { to_workers.push(nil) }
+      workers.size.times { to_workers.push(nil) }
       workers.each { |t| t.join }
       
-      if node.computed.is_a? Exception
-        raise node.computed
-      else
-        node.result
-      end
+      raise node.computed if node.computed.is_a? Exception
+      node.result
     end
 
-    def worker_loop(from_workers, to_workers)
-      while node = to_workers.pop
-        node.compute
-        from_workers.push(node)
-      end
+    def new_worker(from_workers, to_workers)
+      Thread.new {
+        while node = to_workers.pop
+          node.compute
+          from_workers.push(node)
+        end
+      }
     end
 
-    def master_loop(root, num_threads, from_workers, to_workers)
+    def master_loop(root, arg1, workers, from_workers, to_workers)
+      max_threads = arg1 == 0 ? nil : arg1
       num_working = 0
       node = nil
       while true
-        if num_working == num_threads or !(node = find_node(root))
+        if num_working == max_threads or !(node = find_node(root))
           #
           # maxed out or no nodes available -- wait for results
           #
@@ -44,12 +39,16 @@ module CompTree
           node.unlock
           num_working -= 1
           if node == root or node.computed.is_a? Exception
-            break node
+            return node
           end
         else
           #
-          # found a node
+          # not maxed out and found a node -- compute it
           #
+          if (!max_threads.nil? and workers.size < max_threads) or
+              (max_threads.nil? and num_working == workers.size)
+            workers << new_worker(from_workers, to_workers)
+          end
           num_working += 1
           node.lock
           to_workers.push(node)
@@ -74,9 +73,7 @@ module CompTree
         # locked or children not computed; recurse to children
         #
         node.each_child { |child|
-          if found = find_node(child)
-            return found
-          end
+          found = find_node(child) and return found
         }
         nil
       end

data/lib/comp_tree/driver.rb

@@ -38,30 +38,24 @@ module CompTree
     #
     def define(name, *child_names, &block)
       #
-      # retrieve or create node and children
+      # retrieve or create node
       #
-
-      node = @nodes.fetch(name) {
-        @nodes[name] = @node_class.new(name)
-      }
-      if node.function
-        raise RedefinitionError.new(node.name)
-      end
+      node = @nodes[name] ||= @node_class.new(name)
+      raise RedefinitionError.new(node.name) if node.function
       node.function = block
-      
+
+      #
+      # retrieve or create children
+      #
       children = child_names.map { |child_name|
-        @nodes.fetch(child_name) {
-          @nodes[child_name] = @node_class.new(child_name)
-        }
+        @nodes[child_name] ||= @node_class.new(child_name)
       }
 
       #
       # link
       #
       node.children = children
-      children.each { |child|
-        child.parents << node
-      }
+      children.each { |child| child.parents << node }
       
       node
     end
@@ -98,7 +92,8 @@ module CompTree
     #
     # _name_ -- unique node identifier (for example a symbol).
     #
-    # _num_threads_ -- number of threads.
+    # _max_threads_ -- maximum number of threads, or +0+ to indicate
+    # no limit.
     #
     # Compute the tree below _name_ and return the result.
     #
@@ -108,24 +103,22 @@ module CompTree
     # It is your responsibility to call reset() before attempting the
     # computation again, otherwise the result will be undefined.
     #
-    def compute(name, num_threads)
+    def compute(name, max_threads)
       begin
-        num_threads = num_threads.to_int
+        max_threads = max_threads.to_int
       rescue NoMethodError
-        raise TypeError, "can't convert #{num_threads.class} into Integer"
+        raise TypeError, "can't convert #{max_threads.class} into Integer"
       end
-      unless num_threads > 0
-        raise RangeError, "number of threads must be greater than zero"
+      if max_threads < 0
+        raise RangeError, "number of threads must be nonnegative"
       end
-      root = @nodes.fetch(name) {
-        raise NoNodeError.new(name)
-      }
+      root = @nodes[name] or raise NoNodeError.new(name)
       if root.computed
         root.result
-      elsif num_threads == 1
+      elsif max_threads == 1
         root.compute_now
       else
-        Algorithm.compute_parallel(root, num_threads)
+        Algorithm.compute_parallel(root, max_threads)
       end
     end
   end

data/lib/comp_tree/queue/queue_18.rb

@@ -14,9 +14,7 @@ module CompTree
     def push(object)
       Thread.critical = true
       @queue.push object
-      if thread = @waiting.shift
-        thread.wakeup
-      end
+      thread = @waiting.shift and thread.wakeup
     ensure
       Thread.critical = false
     end

data/lib/comp_tree/queue/queue_19.rb

@@ -13,9 +13,7 @@ module CompTree
     def push(object)
       @mutex.synchronize {
         @queue.push object
-        if thread = @waiting.shift
-          thread.wakeup
-        end
+        thread = @waiting.shift and thread.wakeup
       }
     end
 

data/lib/comp_tree/version.rb

@@ -0,0 +1,3 @@
+module CompTree
+  VERSION = "1.1.0"
+end

data/test/basic_test.rb

@@ -1,8 +1,8 @@
-require File.dirname(__FILE__) + '/comp_tree_test_base'
+require File.expand_path(File.dirname(__FILE__)) + '/comp_tree_test_base'
 
-class TestBasic < Test::Unit::TestCase
+class BasicTest < CompTreeTest
   def test_define
-    (1..20).each { |threads|
+    (0..20).each { |threads|
       CompTree.build { |driver|
         driver.define(:area, :width, :height, :offset) { |width, height, offset|
           width*height - offset
@@ -33,7 +33,7 @@ class TestBasic < Test::Unit::TestCase
     [nil, false, true, 33].each { |result|
       CompTree.build { |driver|
         driver.define(:a) { result }
-        (1..3).each { |n|
+        (0..6).each { |n|
           assert_equal(result, driver.compute(:a, n))
         }
       }
@@ -41,7 +41,7 @@ class TestBasic < Test::Unit::TestCase
   end
 
   def test_threads_opt
-    (1..20).each { |threads|
+    (0..20).each { |threads|
       CompTree.build do |driver|
         driver.define(:a) { 33 }
         assert_equal(33, driver.compute(:a, threads))
@@ -51,11 +51,11 @@ class TestBasic < Test::Unit::TestCase
 
   def test_malformed
     CompTree.build { |driver|
-      assert_raise(ArgumentError) {
+      assert_raises(ArgumentError) {
         driver.define {
         }
       }
-      error = assert_raise(CompTree::RedefinitionError) {
+      error = assert_raises(CompTree::RedefinitionError) {
         driver.define(:a) {
         }
         driver.define(:a) {
@@ -89,8 +89,11 @@ class TestBasic < Test::Unit::TestCase
         7
       }
       
-      assert_raise(test_error) {
-        driver.compute(:area, 6)
+      (0..20).each { |n|
+        assert_raises(test_error) {
+          driver.compute(:area, n)
+        }
+        driver.reset(:area)
       }
     }
   end
@@ -111,7 +114,7 @@ class TestBasic < Test::Unit::TestCase
   def test_non_symbols
     width_id = Object.new
     height_id = 272727
-    (1..3).each { |threads|
+    (0..6).each { |threads|
       CompTree.build { |driver|
         driver.define("area", width_id, height_id, :offset) {
           |width, height, offset|
@@ -142,7 +145,7 @@ class TestBasic < Test::Unit::TestCase
   def test_node_name_equality_comparison
     CompTree.build { |driver|
       driver.define("hello") { }
-      assert_raise(CompTree::RedefinitionError) {
+      assert_raises(CompTree::RedefinitionError) {
         driver.define("hello") { }
       }
     }
@@ -150,7 +153,7 @@ class TestBasic < Test::Unit::TestCase
   
   def test_result_variety
     [true, false, nil, Object.new, 33].each { |result|
-      (1..20).each { |threads|
+      (0..20).each { |threads|
         CompTree.build { |driver|
           driver.define(:area, :width, :height, :offset) {
             |width, height, offset|

data/test/circular_test.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) + '/comp_tree_test_base'
+require File.expand_path(File.dirname(__FILE__)) + '/comp_tree_test_base'
 
-class TestCircular < Test::Unit::TestCase
+class CircularTest < CompTreeTest
   def test_circular
     CompTree.build { |driver|
       driver.define(:area, :width, :height, :offset) { |width, height, offset|

data/test/comp_tree_test_base.rb

@@ -1,10 +1,11 @@
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../devel'
 
-require 'test/unit'
+require 'minitest/unit'
+require 'minitest/autorun' unless defined? Rake
 require 'comp_tree'
 
-module TestBase
+class CompTreeTest < MiniTest::Unit::TestCase
   if ARGV.include?("--bench")
     require 'benchmark'
 

data/test/drain_test.rb

@@ -1,8 +1,6 @@
-require File.dirname(__FILE__) + '/comp_tree_test_base'
-
-class TestDrain < Test::Unit::TestCase
-  include TestBase
+require File.expand_path(File.dirname(__FILE__)) + '/comp_tree_test_base'
 
+class DrainTest < CompTreeTest
   def drain
     500000.times { }
   end
@@ -24,7 +22,7 @@ class TestDrain < Test::Unit::TestCase
   end
 
   def each_drain
-    (1..10).each { |threads|
+    (0..10).each { |threads|
       yield threads
     }
   end

data/test/exception_test.rb

@@ -1,11 +1,11 @@
-require File.dirname(__FILE__) + '/comp_tree_test_base'
+require File.expand_path(File.dirname(__FILE__)) + '/comp_tree_test_base'
 
-class TestException < Test::Unit::TestCase
+class ExceptionTest < CompTreeTest
   def test_exception
     test_error = Class.new StandardError
     [true, false].each { |define_all|
       [true, false].each { |abort_on_exception|
-        (1..20).each { |num_threads|
+        (0..20).each { |num_threads|
           error = (
             begin
               CompTree.build { |driver|
@@ -63,7 +63,6 @@ class TestException < Test::Unit::TestCase
   def test_num_threads
     CompTree.build do |driver|
       driver.define(:root) { }
-      assert_raises(RangeError) { driver.compute(:root, 0) }
       assert_raises(RangeError) { driver.compute(:root, -1) }
       assert_raises(RangeError) { driver.compute(:root, -11) }
 
@@ -76,12 +75,10 @@ class TestException < Test::Unit::TestCase
   end
 
   def test_invalid_node
-    (1..20).each { |num_threads|
+    (0..20).each { |num_threads|
       CompTree.build do |driver|
         driver.define(:root) { }
-        assert_nothing_raised {
-          driver.compute(:root, num_threads)
-        }
+        driver.compute(:root, num_threads)
 
         error = assert_raises(CompTree::NoNodeError) {
           driver.compute(:a, num_threads)
@@ -100,7 +97,7 @@ class TestException < Test::Unit::TestCase
   end
 
   def test_missing_function
-    (1..20).each { |num_threads|
+    (0..20).each { |num_threads|
       CompTree.build { |driver|
         driver.define(:f, :x) { |x|
           x + 33

data/test/flood_test.rb

@@ -1,8 +1,8 @@
-require File.dirname(__FILE__) + '/comp_tree_test_base'
+require File.expand_path(File.dirname(__FILE__)) + '/comp_tree_test_base'
 
-class TestFlood < Test::Unit::TestCase
+class FloodTest < CompTreeTest
   def test_thread_flood
-    (1..200).each { |num_threads|
+    (0..200).each { |num_threads|
       CompTree.build { |driver|
         noop = lambda { |*args| true }
         driver.define(:a, :b, &noop)