drake 0.8.4.1.1.0 → 0.8.4.1.2.0

data/lib/rake/comp_tree/comp_tree.rb

@@ -1,42 +0,0 @@
-# 
-# Copyright (c) 2008 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:
-# 
-# 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.
-# 
-
-require 'rake/comp_tree/driver'
-
-module Rake end
-module Rake::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.
-    #
-    def build(opts = nil)
-      yield Driver.new(opts)
-    end
-  end
-end

data/lib/rake/comp_tree/driver.rb

@@ -1,153 +0,0 @@
-
-require 'rake/comp_tree/algorithm'
-require 'rake/comp_tree/node'
-require 'rake/comp_tree/error'
-
-require 'thread'
-
-module Rake end
-module Rake::CompTree
-  #
-  # Driver is the main interface to the computation tree.  It is
-  # responsible for defining nodes and running computations.
-  #
-  class Driver
-    include Algorithm
-
-    #
-    # Build and run a new computation tree.
-    #
-    # Options hash:
-    #
-    # <tt>:node_class</tt> -- (Class) CompTree::Node subclass from
-    # which nodes are created.
-    #
-    def initialize(opts = nil)
-      @node_class = (
-        if opts and opts[:node_class]
-          opts[:node_class]
-        else
-          Node
-        end
-      )
-      @nodes = Hash.new
-    end
-
-    #
-    # Name-to-node hash.
-    #
-    attr_reader :nodes
-
-    #
-    # Define a computation node.
-    #
-    # The first argument is the name of the node to define.
-    # Subsequent arguments are the names of this node's children.
-    #
-    # The values of the child nodes are passed to the block.  The
-    # block returns the result of this node.
-    #
-    # In this example, a computation node named +area+ is defined
-    # which depends on the nodes +width+ and +height+.
-    #
-    #   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 ArgumentError, "No name given for node"
-      end
-      
-      #
-      # retrieve or create parent and children
-      #
-      parent = @nodes[parent_name] || (
-        @nodes[parent_name] = @node_class.new(parent_name)
-      )
-
-      if parent.function
-        raise RedefinitionError, "Node `#{parent.name.inspect}' redefined."
-      end
-      parent.function = block
-      
-      children = children_names.map { |child_name|
-        @nodes[child_name] || (
-          @nodes[child_name] = @node_class.new(child_name)
-        )
-      }
-
-      #
-      # link
-      #
-      parent.children = children
-      children.each { |child|
-        child.parents << parent
-      }
-    end
-
-    #
-    # Mark this node and all its children as uncomputed.
-    #
-    # Arguments:
-    #
-    # +name+ -- unique node identifier (usually a symbol).
-    #
-    def reset(name)
-      @nodes[name].reset
-    end
-
-    #
-    # 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+ -- unique node identifier (usually a symbol).
-    #
-    def check_circular(name)
-      helper = Proc.new { |root, chain|
-        if chain.include? root
-          return chain + [root]
-        end
-        @nodes[root].children.each { |child|
-          helper.call(child.name, chain + [root])
-        }
-      }
-      helper.call(name, [])
-      nil
-    end
-
-    #
-    # Compute this node.
-    #
-    # Arguments:
-    #
-    # +name+ -- unique node identifier (usually a symbol).
-    #
-    # +threads+ -- (Integer) number of threads.
-    #
-    # compute(:volume, :threads => 4) syntax is also accepted.
-    #
-    def compute(name, opts)
-      threads = (opts.respond_to?(:to_i) ? opts : opts[:threads]).to_i
-      root = @nodes[name]
-
-      if threads < 1
-        raise ArgumentError, "threads is #{threads}"
-      end
-
-      if root.computed
-        root.result
-      elsif threads == 1
-        root.result = root.compute_now
-      else
-        compute_multithreaded(root, threads)
-      end
-    end
-  end
-end

data/lib/rake/comp_tree/error.rb

@@ -1,23 +0,0 @@
-
-module Rake end
-module Rake::CompTree
-  # Base class for CompTree errors.
-  class Error < StandardError ; 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/rake/comp_tree/node.rb

@@ -1,164 +0,0 @@
-
-require 'thread'
-
-module Rake end
-module Rake::CompTree
-  #
-  # Base class for nodes in the computation tree.
-  # 
-  class Node
-    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:
-
-    #
-    # Create a node
-    #
-    def initialize(name) #:nodoc:
-      @name = name
-      @mutex = Mutex.new
-      @children = []
-      @parents = []
-      @function = nil
-      reset_self
-    end
-
-    #
-    # Reset the computation for this node.
-    #
-    def reset_self #:nodoc:
-      @shared_lock = 0
-      @children_results = nil
-      @result = nil
-      @computed = nil
-    end
-
-    #
-    # Reset the computation for this node and all children.
-    #
-    def reset #:nodoc:
-      each_downward { |node|
-        node.reset_self
-      }
-    end
-
-    def each_downward(&block) #:nodoc:
-      block.call(self)
-      @children.each { |child|
-        child.each_downward(&block)
-      }
-    end
-
-    def each_upward(&block) #:nodoc:
-      block.call(self)
-      @parents.each { |parent|
-        parent.each_upward(&block)
-      }
-    end
-
-    def each_child #:nodoc:
-      @children.each { |child|
-        yield(child)
-      }
-    end
-
-    #
-    # Force computation of all children; intended for
-    # single-threaded mode.
-    #
-    def compute_now #:nodoc:
-      unless @children_results
-        @children_results = @children.map { |child|
-          child.compute_now
-        }
-      end
-      compute
-    end
-    
-    #
-    # 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:
-      @children_results or (
-        @children.map { |child|
-          unless child.computed
-            return nil
-          end
-          child.result
-        }
-      )
-    end
-
-    def children_results=(value) #:nodoc:
-      @children_results = value
-    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:
-      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
-      @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
-    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
-        #}
-      }
-      @mutex.unlock
-    end
-  end
-end

data/test/Rakefile.seq

@@ -1,20 +0,0 @@
-
-require 'thread'
-
-task_names = (1..50).map { |n| n.to_s }
-order_invoked = []
-mutex = Mutex.new
-
-task_names.each { |task_name|
-  task task_name do
-    mutex.synchronize {
-      order_invoked.push(task_name)
-    }
-  end
-}
-
-task :default => seq[*task_names] do
-  unless order_invoked == task_names
-    raise "seq failed"
-  end
-end

data/test/Rakefile.simple

@@ -1,18 +0,0 @@
-
-require 'thread'
-
-task :default => [:a, :b]
-task :a => [:x, :y]
-task :b
-
-mutex = Mutex.new
-STDOUT.sync = true
-
-%w[a b x y].each { |name|
-  task name.to_sym do
-    mutex.synchronize {
-      puts "task #{name}"
-    }
-    sleep(1)
-  end
-}

data/test/parallel.rb

@@ -1,4 +0,0 @@
-require 'rake'
-Rake.application.num_threads = 8
-puts "- Testing multi-threaded"
-

data/test/single_threaded.rb

@@ -1,3 +0,0 @@
-require 'rake'
-Rake.application.num_threads = 1
-puts "- Testing single-threaded"