comp_tree 0.7.6 → 1.0.0

data/install.rb

@@ -1,3 +1,2 @@
-$LOAD_PATH.unshift 'devel'
-require 'jumpstart/simple_installer'
+load './devel/jumpstart.rb'
 Jumpstart::SimpleInstaller.new.run

data/lib/comp_tree/algorithm.rb

@@ -1,60 +1,61 @@
 
-require 'comp_tree/queue'
-
 module CompTree
   module Algorithm
     module_function
 
     def compute_parallel(root, num_threads)
-      to_workers = Queue.new
       from_workers = Queue.new
-      final_node = nil
+      to_workers = Queue.new
 
       workers = (1..num_threads).map {
         Thread.new {
-          until (node = to_workers.pop) == nil
-            node.compute
-            from_workers.push node
-          end
+          worker_loop(from_workers, to_workers)
         }
       }
 
-      Thread.new {
-        node_to_worker = nil
-        node_from_worker = nil
-        num_working = 0
-        while true
-          if num_working == num_threads or
-              (not (node_to_worker = find_node(root)))
-            #
-            # maxed out or no nodes available -- wait for results
-            #
-            node_from_worker = from_workers.pop
-            node_from_worker.unlock
-            num_working -= 1
-            if node_from_worker == root or
-                node_from_worker.computed.is_a? Exception
-              final_node = node_from_worker
-              break
-            end
-          elsif node_to_worker
-            #
-            # found a node
-            #
-            to_workers.push node_to_worker
-            num_working += 1
-            node_to_worker = nil
-          end
-        end
-        num_threads.times { to_workers.push nil }
-      }.join
+      node = Thread.new {
+        master_loop(root, num_threads, from_workers, to_workers)
+      }.value
 
+      num_threads.times { to_workers.push(nil) }
       workers.each { |t| t.join }
       
-      if final_node.computed.is_a? Exception
-        raise final_node.computed
+      if node.computed.is_a? Exception
+        raise node.computed
       else
-        final_node.result
+        node.result
+      end
+    end
+
+    def worker_loop(from_workers, to_workers)
+      while node = to_workers.pop
+        node.compute
+        from_workers.push(node)
+      end
+    end
+
+    def master_loop(root, num_threads, from_workers, to_workers)
+      num_working = 0
+      node = nil
+      while true
+        if num_working == num_threads or !(node = find_node(root))
+          #
+          # maxed out or no nodes available -- wait for results
+          #
+          node = from_workers.pop
+          node.unlock
+          num_working -= 1
+          if node == root or node.computed.is_a? Exception
+            break node
+          end
+        else
+          #
+          # found a node
+          #
+          num_working += 1
+          node.lock
+          to_workers.push(node)
+        end
       end
     end
 
@@ -67,18 +68,17 @@ module CompTree
       elsif not node.locked? and node.children_results
         #
         # Node is not computed, not locked, and its children are
-        # computed; Ready to compute.
+        # computed; ready to compute.
         #
-        node.lock
         node
       else
         #
         # locked or children not computed; recurse to children
         #
         node.each_child { |child|
-          found = find_node(child) and (
+          if found = find_node(child)
             return found
-          )
+          end
         }
         nil
       end

data/lib/comp_tree/comp_tree.rb

@@ -0,0 +1,55 @@
+
+#
+# CompTree -- Parallel Computation Tree.
+#
+# See README.rdoc.
+#
+module CompTree
+  VERSION = "1.0.0"
+
+  class << self
+    #
+    # :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 build(opts = {})
+      yield Driver.new(opts)
+    end
+  end
+end

data/lib/comp_tree/driver.rb

@@ -1,26 +1,15 @@
 
-require 'comp_tree/algorithm'
-require 'comp_tree/node'
-require 'comp_tree/error'
-
 module CompTree
   #
   # Driver is the main interface to the computation tree.  It is
   # responsible for defining nodes and running computations.
   #
   class Driver
-    include Algorithm
-
     #
     # See CompTree.build
     #
-    def initialize(opts = nil)  #:nodoc:
-      @node_class =
-        if opts and opts[:node_class]
-          opts[:node_class]
-        else
-          Node
-        end
+    def initialize(opts = {})  #:nodoc:
+      @node_class = opts[:node_class] || Node
       @nodes = Hash.new
     end
 
@@ -49,16 +38,16 @@ module CompTree
     #
     def define(name, *child_names, &block)
       #
-      # retrieve or create parent and children
+      # retrieve or create node and children
       #
 
-      parent = @nodes.fetch(name) {
+      node = @nodes.fetch(name) {
         @nodes[name] = @node_class.new(name)
       }
-      if parent.function
-        raise RedefinitionError, "node `#{parent.name.inspect}' redefined"
+      if node.function
+        raise RedefinitionError.new(node.name)
       end
-      parent.function = block
+      node.function = block
       
       children = child_names.map { |child_name|
         @nodes.fetch(child_name) {
@@ -69,12 +58,12 @@ module CompTree
       #
       # link
       #
-      parent.children = children
+      node.children = children
       children.each { |child|
-        child.parents << parent
+        child.parents << node
       }
       
-      parent
+      node
     end
 
     #
@@ -106,35 +95,37 @@ module CompTree
       nil
     end
 
-    #
-    # :call-seq:
-    #   compute(name, threads)
-    #   compute(name, :threads => threads)
     #
     # _name_ -- unique node identifier (for example a symbol).
     #
-    # _threads_ -- number of threads.
+    # _num_threads_ -- number of threads.
     #
-    # Compute this node, returning its result.
+    # Compute the tree below _name_ and return the result.
     #
-    # Any uncomputed children are computed first.
+    # If a node's computation raises an exception, the exception will
+    # be transferred to the caller of compute().  The tree will be
+    # left in a dirty state so that individual nodes may be examined.
+    # It is your responsibility to call reset() before attempting the
+    # computation again, otherwise the result will be undefined.
     #
-    def compute(name, opts)
-      threads = (opts.is_a?(Hash) ? opts[:threads] : opts).to_i
-      unless threads > 0
-        raise CompTree::ArgumentError,
-        "number of threads must be greater than zero"
+    def compute(name, num_threads)
+      begin
+        num_threads = num_threads.to_int
+      rescue NoMethodError
+        raise TypeError, "can't convert #{num_threads.class} into Integer"
+      end
+      unless num_threads > 0
+        raise RangeError, "number of threads must be greater than zero"
       end
       root = @nodes.fetch(name) {
-        raise CompTree::ArgumentError,
-        "no such node named `#{name.inspect}'"
+        raise NoNodeError.new(name)
       }
       if root.computed
         root.result
-      elsif threads == 1
-        root.result = root.compute_now
+      elsif num_threads == 1
+        root.compute_now
       else
-        compute_parallel(root, threads)
+        Algorithm.compute_parallel(root, num_threads)
       end
     end
   end

data/lib/comp_tree/error.rb

@@ -1,19 +1,53 @@
 
 module CompTree
+  #
   # Base class for CompTree errors.
-  class Error < StandardError ; end
+  #
+  class Error < StandardError
+    def inspect  #:nodoc:
+      "#<#{self.class.name}: #{message}>"
+    end
+  end
+
+  #
+  # Base class for node errors.
+  #
+  class NodeError < Error
+    attr_reader :node_name
+    
+    def initialize(node_name)  #:nodoc:
+      super()
+      @node_name = node_name
+    end
+  end
     
   #
-  # Attempt to redefine a Node.
+  # An attempt was made to redefine a node.
   #
   # If you wish to only replace the function, set
   #   driver.nodes[name].function = lambda { ... }
   #
-  class RedefinitionError < Error ; end
+  class RedefinitionError < NodeError
+    def message  #:nodoc:
+      "attempt to redefine node `#{node_name.inspect}'"
+    end
+  end
   
+  #
   # Encountered a node without a function during a computation.
-  class NoFunctionError < Error ; end
+  #
+  class NoFunctionError < NodeError
+    def message  #:nodoc:
+      "no function was defined for node `#{node_name.inspect}'"
+    end
+  end
 
-  # Missing or malformed method arguments
-  class ArgumentError < Error ; end
+  #
+  # Requested node does not exist.
+  #
+  class NoNodeError < NodeError
+    def message  #:nodoc:
+      "no node named `#{node_name.inspect}'"
+    end
+  end
 end

data/lib/comp_tree/node.rb

@@ -1,24 +1,24 @@
 
-require 'thread'
-
 module CompTree
   #
   # Base class for nodes in the computation tree.
   # 
   class Node
-    attr_reader :name                   #:nodoc:
+    attr_reader :name
 
-    attr_accessor :parents              #:nodoc:
-    attr_accessor :children             #:nodoc:
-    attr_accessor :function             #:nodoc:
-    attr_accessor :result               #:nodoc:
-    attr_accessor :computed             #:nodoc:
-    attr_accessor :lock_level           #:nodoc:
+    attr_accessor(
+      :parents,
+      :children,
+      :function,
+      :result,
+      :computed,
+      :lock_level
+    )
 
     #
     # Create a node
     #
-    def initialize(name) #:nodoc:
+    def initialize(name)
       @name = name
       @parents = []
       @children = []
@@ -29,7 +29,7 @@ module CompTree
     #
     # Reset the computation for this node.
     #
-    def reset_self #:nodoc:
+    def reset_self
       @result = nil
       @computed = nil
       @lock_level = 0
@@ -39,27 +39,27 @@ module CompTree
     #
     # Reset the computation for this node and all children.
     #
-    def reset #:nodoc:
+    def reset
       each_downward { |node|
         node.reset_self
       }
     end
 
-    def each_downward(&block) #:nodoc:
+    def each_downward(&block)
       block.call(self)
       @children.each { |child|
         child.each_downward(&block)
       }
     end
 
-    def each_upward(&block) #:nodoc:
+    def each_upward(&block)
       block.call(self)
       @parents.each { |parent|
         parent.each_upward(&block)
       }
     end
 
-    def each_child #:nodoc:
+    def each_child
       @children.each { |child|
         yield(child)
       }
@@ -69,20 +69,26 @@ module CompTree
     # Force all children and self to be computed; no locking required.
     # Intended to be used outside of parallel computations.
     #
-    def compute_now #:nodoc:
-      unless @children_results
-        @children_results = @children.map { |child|
-          child.compute_now
-        }
+    def compute_now
+      unless @computed
+        unless @children_results
+          @children_results = @children.map { |child|
+            child.compute_now
+          }
+        end
+        compute
+        if @computed.is_a? Exception
+          raise @computed
+        end
       end
-      compute
+      @result
     end
     
     #
     # If all children have been computed, return their results;
     # otherwise return nil.
     #
-    def children_results #:nodoc:
+    def children_results
       @children_results or (
         @children_results = @children.map { |child|
           unless child.computed
@@ -97,11 +103,10 @@ module CompTree
     # Compute this node; children must be computed and lock must be
     # already acquired.
     #
-    def compute #:nodoc:
+    def compute
       begin
         unless @function
-          raise NoFunctionError,
-          "no function was defined for node `#{@name.inspect}'"
+          raise NoFunctionError.new(@name)
         end
         @result = @function.call(*@children_results)
         @computed = true
@@ -115,13 +120,13 @@ module CompTree
       @lock_level != 0
     end
 
-    def lock #:nodoc:
+    def lock
       each_upward { |node|
         node.lock_level += 1
       }
     end
 
-    def unlock #:nodoc:
+    def unlock
       each_upward { |node|
         node.lock_level -= 1
       }

data/lib/comp_tree/queue/queue.rb

@@ -0,0 +1 @@
+require("comp_tree/queue/queue_" + (RUBY_VERSION < "1.9" ? "18" : "19"))

data/lib/comp_tree/{queue_old.rb → queue/queue_18.rb}

@@ -14,15 +14,15 @@ module CompTree
     def push(object)
       Thread.critical = true
       @queue.push object
-      begin
-        thread = @waiting.shift and thread.wakeup
-      ensure
-        Thread.critical = false
+      if thread = @waiting.shift
+        thread.wakeup
       end
+    ensure
+      Thread.critical = false
     end
 
     def pop
-      while (Thread.critical = true; @queue.empty?)
+      while (Thread.critical = true ; @queue.empty?)
         @waiting.push Thread.current
         Thread.stop
       end

data/lib/comp_tree/{queue_new.rb → queue/queue_19.rb}

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

data/lib/comp_tree.rb

@@ -1,83 +1,30 @@
 # 
 # Copyright (c) 2008, 2009 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 (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:
+# 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 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.
+# 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.
 # 
 
+require 'comp_tree/error'
+require 'comp_tree/queue/queue'
+require 'comp_tree/node'
+require 'comp_tree/algorithm'
 require 'comp_tree/driver'
-
-#
-# CompTree -- Parallel Computation Tree.
-#
-# See README.rdoc.
-#
-module CompTree
-  COMP_TREE_VERSION = "0.7.6"
-
-  class << self
-    #
-    # :call-seq:
-    #   build { |driver| ... }
-    #
-    # Build a new computation tree. A Driver instance is passed to the
-    # given block.
-    #
-    # Options hash:
-    #
-    # <tt>:node_class</tt> -- CompTree::Node subclass from which nodes
-    # are created.
-    #
-    # 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, :threads => 4)
-    #     # => 63
-    # 
-    #     # We've done this computation.
-    #     puts((7 + 2)*(5 + 2))
-    #     # => 63
-    #   end
-    #
-    def build(opts = nil)
-      yield Driver.new(opts)
-    end
-  end
-end
+require 'comp_tree/comp_tree'

data/test/{test_basic.rb → basic_test.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/common'
+require File.dirname(__FILE__) + '/comp_tree_test_base'
 
 class TestBasic < Test::Unit::TestCase
   def test_define
@@ -44,7 +44,7 @@ class TestBasic < Test::Unit::TestCase
     (1..20).each { |threads|
       CompTree.build do |driver|
         driver.define(:a) { 33 }
-        assert_equal(33, driver.compute(:a, :threads => threads))
+        assert_equal(33, driver.compute(:a, threads))
       end
     }
   end
@@ -55,12 +55,14 @@ class TestBasic < Test::Unit::TestCase
         driver.define {
         }
       }
-      assert_raise(CompTree::RedefinitionError) {
+      error = assert_raise(CompTree::RedefinitionError) {
         driver.define(:a) {
         }
         driver.define(:a) {
         }
       }
+      assert_equal "attempt to redefine node `:a'", error.message
+      assert_equal :a, error.node_name
     }
   end
 

data/test/{test_circular.rb → circular_test.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/common'
+require File.dirname(__FILE__) + '/comp_tree_test_base'
 
 class TestCircular < Test::Unit::TestCase
   def test_circular