comp_tree 0.5.2 → 0.7.0

data/lib/comp_tree/driver.rb

@@ -1,10 +1,6 @@
 
-require 'comp_tree/bucket_ipc'
-require 'comp_tree/diagnostic'
-require 'comp_tree/misc'
 require 'comp_tree/algorithm'
 require 'comp_tree/node'
-require 'comp_tree/task_node'
 require 'comp_tree/error'
 
 require 'thread'
@@ -15,53 +11,25 @@ module CompTree
   # responsible for defining nodes and running computations.
   #
   class Driver
-    DEFAULTS = {
-      :threads => 1,
-      :fork => false,
-      :timeout => 5.0,
-      :wait_interval => 0.02,
-    }
+    include Algorithm
 
-    include Diagnostic
-    include Misc
-    
     #
-    # Begin a new computation tree.
+    # Build and run a new computation tree.
     #
     # Options hash:
     #
     # <tt>:node_class</tt> -- (Class) CompTree::Node subclass from
     # which nodes are created.
     #
-    # <tt>:discard_result</tt> -- (boolean) If you are <em>not</em>
-    # interested in the final answer, but only in the actions which
-    # complete the computation, then set this to +true+.  This is
-    # equivalent to saying <tt>:node_class => CompTree::TaskNode</tt>.
-    # (If you are forking processes, it is good to know that IPC is
-    # not needed to communicate the result.)
-    #
     def initialize(opts = nil)
-      if opts and opts[:node_class] and opts[:discard_result]
-        raise(
-          Error::ArgumentError,
-          "#{self.class.name}.new: :discard_result and :node_class " +
-          "are mutually exclusive")
-      end
-
-      @node_class =
+      @node_class = (
         if opts and opts[:node_class]
           opts[:node_class]
-        elsif opts and opts[:discard_result]
-          TaskNode
         else
           Node
         end
-
+      )
       @nodes = Hash.new
-
-      if block_given?
-        yield self
-      end
     end
 
     #
@@ -72,55 +40,43 @@ module CompTree
     #
     # Define a computation node.
     #
-    # There are three distinct forms of a node definition.  In each of
-    # the following examples, a computation node named +area+ is
-    # defined which depends on the nodes +height+, +width+, +offset+.
+    # The first argument is the name of the node to define.
+    # Subsequent arguments are the names of this node's children.
     #
-    # The method_missing form:
-    #  driver.define_area(:width, :height, :offset) { |width, height, offset|
-    #    width*height - offset
-    #  }
+    # The values of the child nodes are passed to the block.  The
+    # block returns the result of this node.
     #
-    # The eval form:
-    #  driver.define_area :width, :height, :offset, %{
-    #    width*height - offset
-    #  }
-    # (Note the '%' before the brace.)
+    # In this example, a computation node named +area+ is defined
+    # which depends on the nodes +width+ and +height+.
     #
-    # The raw form:
-    #  driver.define(:area, :width, :height, :offset) { |width, height, offset|
-    #    width*height - offset
-    #  }
+    #   driver.define(:area, :width, :height) { |width, height|
+    #     width*height
+    #   }
     #
     def define(*args, &block)
       parent_name = args.first
       children_names = args[1..-1]
       
       unless parent_name
-        raise Error::ArgumentError, "No name given for node"
+        raise ArgumentError, "No name given for node"
       end
       
       #
       # retrieve or create parent and children
       #
-      parent =
-        if t = @nodes[parent_name]
-          t
-        else 
-          @nodes[parent_name] = @node_class.new(parent_name)
-        end
+      parent = @nodes[parent_name] || (
+        @nodes[parent_name] = @node_class.new(parent_name)
+      )
 
       if parent.function
-        raise Error::RedefinitionError, "Node #{parent.name} already defined."
+        raise RedefinitionError, "Node `#{parent.name.inspect}' redefined."
       end
       parent.function = block
       
       children = children_names.map { |child_name|
-        if t = @nodes[child_name]
-          t
-        else
+        @nodes[child_name] || (
           @nodes[child_name] = @node_class.new(child_name)
-        end
+        )
       }
 
       #
@@ -132,72 +88,37 @@ module CompTree
       }
     end
 
-    #
-    # parsing/evaling helper
-    #
-    def evaling_define(*args) #:nodoc:
-      function_name = args[0]
-      function_arg_names = args[1..-2]
-      function_string = args.last.to_str
-      
-      comma_separated = function_arg_names.map { |name|
-        name.to_s
-      }.join(",")
-
-      eval_me = %{ 
-        lambda { |#{comma_separated}|
-          #{function_string}
-        }
-      }
-
-      function = eval(eval_me, TOPLEVEL_BINDING)
-
-      define(function_name, *function_arg_names, &function)
-    end
-
-    def method_missing(symbol, *args, &block) #:nodoc:
-      if match = symbol.to_s.match(%r!\Adefine_(\w+)\Z!)
-        method_name = match.captures.first.to_sym
-        if block
-          define(method_name, *args, &block)
-        else
-          evaling_define(method_name, *args)
-        end
-      else
-        super(symbol, *args, &block)
-      end
-    end
-
     #
     # Mark this node and all its children as uncomputed.
     #
     # Arguments:
     #
-    # +name+ -- (Symbol) node name.
+    # +name+ -- unique node identifier (usually a symbol).
     #
     def reset(name)
       @nodes[name].reset
     end
 
     #
-    # Check for a cyclic graph below the given node.  Raises
-    # CompTree::Error::CircularError if found.
+    # Check for a cyclic graph below the given node.  If found,
+    # returns the names of the nodes (in order) which form a loop.
+    # Otherwise returns nil.
     #
     # Arguments:
     #
-    # +name+ -- (Symbol) node name.
+    # +name+ -- unique node identifier (usually a symbol).
     #
     def check_circular(name)
-      helper = lambda { |root, chain|
+      helper = Proc.new { |root, chain|
         if chain.include? root
-          raise Error::CircularError,
-            "Circular dependency detected: #{root} => #{chain.last} => #{root}"
+          return chain + [root]
         end
         @nodes[root].children.each { |child|
           helper.call(child.name, chain + [root])
         }
       }
       helper.call(name, [])
+      nil
     end
 
     #
@@ -205,62 +126,26 @@ module CompTree
     #
     # Arguments:
     #
-    # +name+ -- (Symbol) node name.
-    #
-    # Options hash:
-    #
-    # <tt>:threads</tt> -- (Integer) Number of parallel threads.
+    # +name+ -- unique node identifier (usually a symbol).
     #
-    # <tt>:fork</tt> -- (boolean) Whether to fork each computation
-    # node into its own process.
+    # +threads+ -- (Integer) number of threads.
     #
-    # Defaults options are taken from Driver::DEFAULTS.
+    # compute(:volume, :threads => 4) syntax is also accepted.
     #
-    def compute(name, opts = nil)
-      #
-      # Undocumented options:
-      #
-      # <tt>:wait_interval</tt> -- (seconds) (Obscure) How long to
-      # wait after an IPC failure.
-      #
-      # <tt>:timeout</tt> -- (seconds) (Obscure) Give up after this
-      # period of persistent IPC failures.
-      #
-
-      abort_on_exception {
-        compute_private(name, opts || Hash.new)
-      }
-    end
-
-    private
-    
-    def compute_private(name, opts_in)
-      opts = DEFAULTS.merge(opts_in)
+    def compute(name, opts)
+      threads = opts.is_a?(Hash) ? opts[:threads] : opts
       root = @nodes[name]
 
-      if opts[:threads] < 1
-        raise Error::ArgumentError, "threads is #{opts[:threads]}"
+      if threads < 1
+        raise ArgumentError, "threads is #{threads}"
       end
 
-      if opts[:threads] == 1
+      if root.computed
+        root.result
+      elsif threads == 1
         root.result = root.compute_now
-      elsif opts[:fork] and not @node_class.discard_result?
-        #
-        # Use buckets to send results across forks.
-        #
-        result = nil
-        BucketIPC::Driver.new(opts[:threads], opts) { |buckets|
-          result =
-            Algorithm.compute_multithreaded(
-              root, opts[:threads], opts[:fork], buckets)
-        }
-        result
       else
-        #
-        # Multithreaded computation without fork.
-        #
-        Algorithm.compute_multithreaded(
-          root, opts[:threads], opts[:fork], nil)
+        compute_multithreaded(root, threads)
       end
     end
   end

data/lib/comp_tree/error.rb

@@ -1,27 +1,22 @@
 
 module CompTree
-  module Error
-    # Base class for CompTree errors.
-    class Base < StandardError ; end
+  # Base class for CompTree errors.
+  class Error < StandardError ; end
     
-    # Internal error inside CompTree.  Please send a bug report.
-    class AssertionFailed < Base ; end
-    
-    # Bad arguments were passed to a method.
-    class ArgumentError < Base ; end
-    
-    #
-    # Attempt to redefine a Node.
-    #
-    # If you wish to only replace the function, set
-    #   driver.nodes[name].function = some_new_lambda
-    #
-    class RedefinitionError < Base ; end
-    
-    # A Cyclic graph was detected.
-    class CircularError < Base ; end
-
-    # No function was defined for this node.
-    class NoFunctionError < Base ; end
-  end
+  # Internal error inside CompTree.  Please send a bug report.
+  class AssertionFailedError < Error ; end
+  
+  # Bad arguments were passed to a method.
+  class ArgumentError < Error ; end
+  
+  #
+  # Attempt to redefine a Node.
+  #
+  # If you wish to only replace the function, set
+  #   driver.nodes[name].function = some_new_lambda
+  #
+  class RedefinitionError < Error ; end
+  
+  # No function was defined for this node.
+  class NoFunctionError < Error ; end
 end

data/lib/comp_tree/node.rb

@@ -1,5 +1,4 @@
 
-require 'comp_tree/diagnostic'
 require 'thread'
 
 module CompTree
@@ -7,24 +6,26 @@ module CompTree
   # Base class for nodes in the computation tree.
   # 
   class Node
-    include Diagnostic
-
     attr_reader :name                   #:nodoc:
 
     attr_accessor :parents              #:nodoc:
     attr_accessor :children             #:nodoc:
     attr_accessor :function             #:nodoc:
     attr_accessor :result               #:nodoc:
+    attr_accessor :computed             #:nodoc:
     attr_accessor :shared_lock          #:nodoc:
 
+    attr_writer :children_results       #:nodoc:
+
     #
     # Create a node
     #
     def initialize(name) #:nodoc:
       @name = name
-      @mutex = Mutex.new
-      @children = []
       @parents = []
+      @children = []
+      @function = nil
+      @mutex = Mutex.new
       reset_self
     end
 
@@ -32,9 +33,10 @@ module CompTree
     # Reset the computation for this node.
     #
     def reset_self #:nodoc:
+      @result = nil
+      @computed = nil
       @shared_lock = 0
       @children_results = nil
-      @result = nil
     end
 
     #
@@ -83,50 +85,55 @@ module CompTree
     # If all children have been computed, return their results;
     # otherwise return nil.
     #
-    def children_results #:nodoc:
-      if @children_results
-        @children_results
-      else
-        results = @children.map { |child|
-          if child_result = child.result
-            child_result
-          else
+    # Do not assign to @children_results since own lock is not
+    # necessarily aquired.
+    #
+    def find_children_results #:nodoc:
+      @children_results or (
+        @children.map { |child|
+          unless child.computed
             return nil
           end
+          child.result
         }
-        @children_results = results
-      end
+      )
     end
 
-    def trace_compute #:nodoc:
-      debug {
-        # --- own mutex
-        trace "Computing #{@name}"
-        raise Error::AssertionFailed if @result
-        raise Error::AssertionFailed unless @mutex.locked?
-        raise Error::AssertionFailed unless @children_results
-      }
-    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.
     #
     def compute #:nodoc:
-      unless defined?(@function) and @function
-        raise Error::NoFunctionError,
+      begin
+        unless @function
+          raise NoFunctionError,
           "No function was defined for node '#{@name.inspect}'"
+        end
+        @result = @function.call(*@children_results)
+        @computed = true
+      rescue Exception => e
+        @computed = e
       end
-      @function.call(*@children_results)
+      @result
     end
 
     def try_lock #:nodoc:
       # --- shared tree mutex and own mutex
       if @shared_lock == 0 and @mutex.try_lock
-        trace "Locking #{@name}"
+        #trace "Locking #{@name}"
         each_upward { |node|
           node.shared_lock += 1
-          trace "#{node.name} locked by #{@name}: level: #{node.shared_lock}"
+          #trace "#{node.name} locked by #{@name}: level: #{node.shared_lock}"
         }
         true
       else
@@ -136,30 +143,19 @@ module CompTree
 
     def unlock #:nodoc:
       # --- shared tree mutex and own mutex
-      debug {
-        raise Error::AssertionFailed unless @mutex.locked?
-        trace "Unlocking #{@name}"
-      }
+      #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
-        }
+        #debug {
+        #  if node.shared_lock == 0
+        #    trace "#{node.name} unlocked by #{@name}"
+        #  end
+        #}
       }
       @mutex.unlock
     end
-
-    class << self
-      #
-      # Throw away the computation result?
-      #
-      # This Node base class always returns false.
-      #
-      def discard_result?
-        false
-      end
-    end
   end
 end

data/lib/comp_tree.rb

@@ -21,3 +21,59 @@
 # 
 
 require 'comp_tree/driver'
+
+#
+# CompTree -- Parallel Computation Tree.
+#
+# See README.
+#
+module CompTree
+  class << self
+    #
+    # Build and run a new computation tree.
+    #
+    # A Driver instance is passed to the given block.
+    #
+    # Options hash:
+    #
+    # <tt>:node_class</tt> -- (Class) 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

data/rakelib/jumpstart/ruby.rb

@@ -0,0 +1,51 @@
+
+require 'rbconfig'
+
+module Jumpstart
+  module Ruby
+    EXECUTABLE = lambda {
+      name = File.join(
+        Config::CONFIG["bindir"],
+        Config::CONFIG["RUBY_INSTALL_NAME"]
+      )
+
+      if Config::CONFIG["host"] =~ %r!(mswin|cygwin|mingw)! and
+          File.basename(name) !~ %r!\.(exe|com|bat|cmd)\Z!i
+        name + Config::CONFIG["EXEEXT"]
+      else
+        name
+      end
+    }.call
+
+    class << self
+      def run(*args)
+        system(EXECUTABLE, *args)
+      end
+
+      def run_or_raise(*args)
+        cmd = [EXECUTABLE, *args]
+        unless system(*cmd)
+          msg = (
+            "failed to launch ruby: " +
+            "system(*#{cmd.inspect}) failed with status #{$?.exitstatus}"
+          )
+          raise msg
+        end
+      end
+
+      def with_warnings(value = true)
+        previous = $VERBOSE
+        $VERBOSE = value
+        begin
+          yield
+        ensure
+          $VERBOSE = previous
+        end
+      end
+      
+      def no_warnings(&block)
+        with_warnings(false, &block)
+      end
+    end
+  end
+end

data/{contrib/quix/lib/quix → rakelib/jumpstart}/simple_installer.rb

@@ -2,13 +2,9 @@
 require 'rbconfig'
 require 'fileutils'
 require 'find'
-require 'fileutils'
-require 'quix/vars'
-  
-module CompTree
-  class SimpleInstaller
-    include CompTree::Vars
 
+module Jumpstart
+  class SimpleInstaller
     def initialize
       dest_root = Config::CONFIG["sitelibdir"]
       sources = []
@@ -49,19 +45,21 @@ module CompTree
             end
           }
   
-          acc << locals_to_hash {%{source, dest, install, uninstall}}
+          acc << {
+            :source => source,
+            :dest => dest,
+            :install => install,
+            :uninstall => uninstall,
+          }
         end
       }
     end
   
     def install_file?(source)
-      !File.symlink?(source) and
-        (File.directory?(source) or
-          (File.file?(source) and File.extname(source) == ".rb"))
+      File.directory?(source) or
+      (File.file?(source) and File.extname(source) == ".rb")
     end
 
-    attr_accessor :spec
-
     def install
       @spec.each { |entry|
         entry[:install].call
@@ -75,7 +73,7 @@ module CompTree
     end
 
     def run(args = ARGV)
-      if args.empty? or (args.size == 1 and args.first == "install")
+      if args.empty?
         install
       elsif args.size == 1 and args.first == "--uninstall"
         uninstall