comp_tree 0.7.1 → 0.7.2

data/devel/jumpstart/lazy_attribute.rb

@@ -0,0 +1,38 @@
+
+class Jumpstart
+  #
+  # Mixin for lazily-evaluated attributes.
+  #
+  module LazyAttribute
+    #
+    # &block is evaluated when this attribute is requested.  The same
+    # result is returned for subsequent calls until the attribute is
+    # assigned a different value.
+    #
+    def attribute(reader, &block)
+      writer = "#{reader}="
+
+      singleton = (class << self ; self ; end)
+
+      define_evaluated_reader = lambda { |value|
+        singleton.class_eval {
+          remove_method(reader)
+          define_method(reader) { value }
+        }
+      }
+
+      singleton.class_eval {
+        define_method(reader) {
+          value = block.call
+          define_evaluated_reader.call(value)
+          value
+        }
+          
+        define_method(writer) { |value|
+          define_evaluated_reader.call(value)
+          value
+        }
+      }
+    end
+  end
+end

data/{rakelib → devel}/jumpstart/ruby.rb

@@ -1,7 +1,7 @@
 
 require 'rbconfig'
 
-module Jumpstart
+class Jumpstart
   module Ruby
     EXECUTABLE = lambda {
       name = File.join(

data/{rakelib → devel}/jumpstart/simple_installer.rb

@@ -3,7 +3,7 @@ require 'rbconfig'
 require 'fileutils'
 require 'find'
 
-module Jumpstart
+class Jumpstart
   class SimpleInstaller
     def initialize
       dest_root = Config::CONFIG["sitelibdir"]

data/lib/comp_tree.rb

@@ -28,6 +28,8 @@ require 'comp_tree/driver'
 # See README.rdoc.
 #
 module CompTree
+  VERSION = "0.7.2"
+
   class << self
     #
     # :call-seq:

data/lib/comp_tree/algorithm.rb

@@ -1,162 +1,81 @@
 
 module CompTree
   module Algorithm
-    LEAVE = :__comp_tree_leave
-    AGAIN = :__comp_tree_again
-
     module_function
 
-    def loop_with(leave, again)
-      catch(leave) {
-        while true
-          catch(again) {
-            yield
-          }
-        end
-      }
-    end
-
     def compute_parallel(root, num_threads)
-      #trace "Computing #{root.name} with #{num_threads} threads"
-      finished = nil
-      tree_mutex = Mutex.new
-      condition = ConditionVariable.new
-      num_threads_ready = 0
+      to_workers = Queue.new
+      from_workers = Queue.new
 
-      threads = (0...num_threads).map { |thread_index|
-        Thread.new {
-          #
-          # wait for main thread
-          #
-          tree_mutex.synchronize {
-            #trace "Thread #{thread_index} waiting to start"
-            num_threads_ready += 1
-            condition.wait(tree_mutex)
-          }
+      node_to_worker = nil
+      node_from_worker = nil
 
-          loop_with(LEAVE, AGAIN) {
-            node = tree_mutex.synchronize {
-              #trace "Thread #{thread_index} acquired tree lock; begin search"
-              if finished
-                #trace "Thread #{thread_index} detected finish"
-                num_threads_ready -= 1
-                throw LEAVE
-              else
-                #
-                # Find a node.  The node we obtain, if any, will be locked.
-                #
-                node = find_node(root)
-                if node
-                  #trace "Thread #{thread_index} found node #{node.name}"
-                  node
-                else
-                  #trace "Thread #{thread_index}: no node found; sleeping."
-                  condition.wait(tree_mutex)
-                  throw AGAIN
-                end
-              end
-            }
+      num_working = 0
+      finished = nil
 
-            #trace "Thread #{thread_index} computing node"
-            #debug {
-            #  node.trace_compute
-            #}
+      workers = (1..num_threads).map {
+        Thread.new {
+          until (node = to_workers.pop) == :finished
             node.compute
-            #trace "Thread #{thread_index} node computed; waiting for tree lock"
-
-            tree_mutex.synchronize {
-              #trace "Thread #{thread_index} acquired tree lock"
-              #debug {
-              #  name = "#{node.name}" + ((node == root) ? " (ROOT NODE)" : "")
-              #  initial = "Thread #{thread_index} compute result for #{name}: "
-              #  status = node.computed.is_a?(Exception) ? "error" : "success"
-              #  trace initial + status
-              #  trace "Thread #{thread_index} node result: #{node.result}"
-              #}
-
-              if node.computed.is_a? Exception
-                #
-                # An error occurred; we are done.
-                #
-                finished = node.computed
-              elsif node == root
-                #
-                # Root node was computed; we are done.
-                #
-                finished = true
-              end
-                
-              #
-              # remove locks for this node (shared lock and own lock)
-              #
-              node.unlock
-
-              #
-              # Tell the main thread that another node was computed.
-              #
-              condition.signal
-            }
-          }
-          #trace "Thread #{thread_index} exiting"
+            from_workers.push node
+          end
         }
       }
 
-      #trace "Main: waiting for threads to launch and block."
-      until tree_mutex.synchronize { num_threads_ready == num_threads }
-        Thread.pass
-      end
-
-      tree_mutex.synchronize {
-        #trace "Main: entering main loop"
-        until num_threads_ready == 0
-          #trace "Main: waking threads"
-          condition.broadcast
-
-          if finished
-            #trace "Main: detected finish."
+      while true
+        if num_working == num_threads or not (node_to_worker = find_node(root))
+          #
+          # max computations running 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
+            finished = node_from_worker
             break
           end
-
-          #trace "Main: waiting for a node"
-          condition.wait(tree_mutex)
-          #trace "Main: got a node"
+        elsif node_to_worker
+          #
+          # found a node
+          #
+          to_workers.push node_to_worker
+          num_working += 1
+          node_to_worker = nil
         end
-      }
-
-      #trace "Main: waiting for threads to finish."
-      threads.each { |t| t.join }
-
-      #trace "Main: computation done."
-      if finished.is_a? Exception
-        raise finished
+      end
+      
+      num_threads.times { to_workers.push :finished }
+      workers.each { |t| t.join }
+      
+      if finished.computed.is_a? Exception
+        raise finished.computed
       else
-        root.result
+        finished.result
       end
     end
 
     def find_node(node)
-      # --- only called inside shared tree mutex
-      #trace "Looking for a node, starting with #{node.name}"
       if node.computed
         #
         # already computed
         #
-        #trace "#{node.name} has been computed"
         nil
-      elsif (children_results = node.find_children_results) and node.try_lock
+      elsif not node.locked? and node.children_results
         #
-        # Node is not computed and its children are computed;
-        # and we have the lock.  Ready to compute.
+        # Node is not computed, not locked, and its children are
+        # computed; Ready to compute.
         #
-        node.children_results = children_results
+        node.lock
         node
       else
         #
         # locked or children not computed; recurse to children
         #
-        #trace "Checking #{node.name}'s children"
         node.each_child { |child|
-          next_node = find_node(child) and return next_node
+          found = find_node(child) and (
+            return found
+          )
         }
         nil
       end

data/lib/comp_tree/driver.rb

@@ -118,7 +118,10 @@ module CompTree
     # Any uncomputed children are computed first.
     #
     def compute(name, opts)
-      threads = opts.is_a?(Hash) ? opts[:threads] : opts
+      threads = (opts.is_a?(Hash) ? opts[:threads] : opts).to_i
+      unless threads > 0
+        raise ArgumentError, "number of threads must be greater than zero"
+      end
       root = @nodes[name]
       if root.computed
         root.result

data/lib/comp_tree/node.rb

@@ -13,9 +13,7 @@ module CompTree
     attr_accessor :function             #:nodoc:
     attr_accessor :result               #:nodoc:
     attr_accessor :computed             #:nodoc:
-    attr_accessor :shared_lock          #:nodoc:
-
-    attr_writer :children_results       #:nodoc:
+    attr_accessor :lock_level           #:nodoc:
 
     #
     # Create a node
@@ -25,7 +23,6 @@ module CompTree
       @parents = []
       @children = []
       @function = nil
-      @mutex = Mutex.new
       reset_self
     end
 
@@ -35,7 +32,7 @@ module CompTree
     def reset_self #:nodoc:
       @result = nil
       @computed = nil
-      @shared_lock = 0
+      @lock_level = 0
       @children_results = nil
     end
 
@@ -85,12 +82,9 @@ module CompTree
     # If all children have been computed, return their results;
     # otherwise return nil.
     #
-    # Do not assign to @children_results since own lock is not
-    # necessarily aquired.
-    #
-    def find_children_results #:nodoc:
+    def children_results #:nodoc:
       @children_results or (
-        @children.map { |child|
+        @children_results = @children.map { |child|
           unless child.computed
             return nil
           end
@@ -99,16 +93,6 @@ module CompTree
       )
     end
 
-    #def trace_compute #:nodoc:
-    #  debug {
-    #    # --- own mutex
-    #    trace "Computing #{@name}"
-    #    raise AssertionFailedError if @computed
-    #    raise AssertionFailedError unless @mutex.locked?
-    #    raise AssertionFailedError unless @children_results
-    #  }
-    #end
-
     #
     # Compute this node; children must be computed and lock must be
     # already acquired.
@@ -127,35 +111,20 @@ module CompTree
       @result
     end
 
-    def try_lock #:nodoc:
-      # --- shared tree mutex and own mutex
-      if @shared_lock == 0 and @mutex.try_lock
-        #trace "Locking #{@name}"
-        each_upward { |node|
-          node.shared_lock += 1
-          #trace "#{node.name} locked by #{@name}: level: #{node.shared_lock}"
-        }
-        true
-      else
-        false
-      end
+    def locked?
+      @lock_level != 0
+    end
+
+    def lock #:nodoc:
+      each_upward { |node|
+        node.lock_level += 1
+      }
     end
 
     def unlock #:nodoc:
-      # --- shared tree mutex and own mutex
-      #debug {
-      #  raise AssertionFailedError unless @mutex.locked?
-      #  trace "Unlocking #{@name}"
-      #}
       each_upward { |node|
-        node.shared_lock -= 1
-        #debug {
-        #  if node.shared_lock == 0
-        #    trace "#{node.name} unlocked by #{@name}"
-        #  end
-        #}
+        node.lock_level -= 1
       }
-      @mutex.unlock
     end
   end
 end

data/test/common.rb

@@ -2,7 +2,7 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
 
 require 'test/unit'
 require 'comp_tree'
-require 'benchmark'
+#require 'benchmark'
 
 module TestCommon
   if ARGV.include?("--bench")

data/test/test_drain.rb

@@ -17,9 +17,10 @@ class TestDrain < Test::Unit::TestCase
       driver.define(:height, :border, &func)
       driver.define(:border, &func)
       driver.define(:offset, &func)
-      bench_output "number of threads: #{threads}"
-      bench = Benchmark.measure { driver.compute(:area, threads) }
-      bench_output bench
+      #bench_output "number of threads: #{threads}"
+      #bench = Benchmark.measure { driver.compute(:area, threads) }
+      driver.compute(:area, threads)
+      #bench_output bench
     }
   end
 

data/test/test_exception.rb

@@ -4,45 +4,65 @@ class TestException < Test::Unit::TestCase
   def test_exception
     test_error = Class.new StandardError
     [true, false].each { |define_all|
-      error = (
-        begin
-          CompTree.build { |driver|
-            driver.define(:area, :width, :height, :offset) {
-              |width, height, offset|
-              width*height - offset
-            }
-            
-            driver.define(:width, :border) { |border|
-              2 + border
-            }
-
-            driver.define(:height, :border) { |border|
-              3 + border
-            }
-            
-            if define_all
-              driver.define(:border) {
-                raise test_error
+      [true, false].each { |abort_on_exception|
+        error = (
+          begin
+            CompTree.build { |driver|
+              driver.define(:area, :width, :height, :offset) {
+                |width, height, offset|
+                width*height - offset
+              }
+              
+              driver.define(:width, :border) { |border|
+                2 + border
               }
-            end
-            
-            driver.define(:offset) {
-              7
+  
+              driver.define(:height, :border) { |border|
+                3 + border
+              }
+              
+              if define_all
+                driver.define(:border) {
+                  raise test_error
+                }
+              end
+              
+              driver.define(:offset) {
+                7
+              }
+        
+              begin
+                previous = Thread.abort_on_exception
+                Thread.abort_on_exception = abort_on_exception
+                driver.compute(:area, 99) 
+              ensure
+                Thread.abort_on_exception = previous
+              end
             }
-      
-            driver.compute(:area, 99) 
-          }
-          nil
-        rescue => e
-          e
+            nil
+          rescue => e
+            e
+          end
+        )
+  
+        if define_all
+          assert_block { error.is_a? test_error }
+        else
+          assert_block { error.is_a? CompTree::NoFunctionError }
         end
-      )
-
-      if define_all
-        assert_block { error.is_a? test_error }
-      else
-        assert_block { error.is_a? CompTree::NoFunctionError }
-      end
+      }
     }
+  end 
+
+  def test_num_threads
+    CompTree.build do |driver|
+      driver.define(:root) { }
+      assert_raises(ArgumentError) { driver.compute(:root, 0) }
+      assert_raises(ArgumentError) { driver.compute(:root, :threads => 0) }
+      assert_raises(ArgumentError) { driver.compute(:root, -1) }
+      assert_raises(ArgumentError) { driver.compute(:root, :threads => -1) }
+      assert_raises(ArgumentError) { driver.compute(:root, -11) }
+      assert_raises(ArgumentError) { driver.compute(:root, :threads => -11) }
+    end
   end
-end 
+end