drake 0.8.1.10.0

data/lib/rake/classic_namespace.rb

@@ -0,0 +1,8 @@
+# The following classes used to be in the top level namespace.
+# Loading this file enables compatibility with older Rakefile that
+# referenced Task from the top level.
+
+Task = Rake::Task
+FileTask = Rake::FileTask
+FileCreationTask = Rake::FileCreationTask
+RakeApp = Rake::Application

data/lib/rake/clean.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+# The 'rake/clean' file defines two file lists (CLEAN and CLOBBER) and
+# two rake tasks (:clean and :clobber).
+#
+# [:clean] Clean up the project by deleting scratch files and backup
+#          files.  Add files to the CLEAN file list to have the :clean
+#          target handle them.
+#
+# [:clobber] Clobber all generated and non-source files in a project.
+#            The task depends on :clean, so all the clean files will
+#            be deleted as well as files in the CLOBBER file list.
+#            The intent of this task is to return a project to its
+#            pristine, just unpacked state.
+
+require 'rake'
+
+CLEAN = Rake::FileList["**/*~", "**/*.bak", "**/core"]
+CLEAN.clear_exclude.exclude { |fn| 
+  fn.pathmap("%f") == 'core' && File.directory?(fn) 
+}
+
+desc "Remove any temporary products."
+task :clean do
+  CLEAN.each { |fn| rm_r fn rescue nil }
+end
+
+CLOBBER = Rake::FileList.new
+
+desc "Remove any generated file."
+task :clobber => [:clean] do
+  CLOBBER.each { |fn| rm_r fn rescue nil }
+end

data/lib/rake/comp_tree/algorithm.rb

@@ -0,0 +1,234 @@
+
+
+
+######################################################
+# 
+# **** DO NOT EDIT ****
+# 
+# **** THIS IS A GENERATED FILE *****
+# 
+######################################################
+
+
+
+require 'rake/comp_tree/quix/diagnostic'
+require 'rake/comp_tree/retriable_fork'
+
+module Rake::CompTree
+  module Algorithm
+    include Quix::Diagnostic
+
+    def compute_multithreaded(root, num_threads, use_fork, buckets)
+      trace "Computing #{root.name} with #{num_threads} threads"
+      result = nil
+      mutex = Mutex.new
+      node_finished_condition = ConditionVariable.new
+      thread_wake_condition = ConditionVariable.new
+      threads = []
+      
+      # workaround: jruby gives "run" status for waiting on
+      # condition variable
+      num_threads_ready = 0
+
+      num_threads.times { |thread_index|
+        threads << Thread.new {
+          #
+          # wait for main thread
+          #
+          mutex.synchronize {
+            trace "Thread #{thread_index} waiting to start"
+            num_threads_ready += 1
+            thread_wake_condition.wait(mutex)
+          }
+
+          while true
+            trace "Thread #{thread_index} node search"
+
+            #
+            # Done! Thread will exit.
+            #
+            break if mutex.synchronize {
+              result
+            }
+
+            #
+            # Lock the tree and find a node.  The node we
+            # obtain, if any, is already locked.
+            #
+            node = mutex.synchronize {
+              find_node(root)
+            }
+
+            if node
+              trace "Thread #{thread_index} found node #{node.name}"
+
+              node_result =
+                compute_node(
+                  node,
+                  use_fork,
+                  buckets ? buckets[thread_index] : nil)
+              
+              mutex.synchronize {
+                node.result = node_result
+              }
+
+              #
+              # remove locks for this node (shared lock and own lock)
+              #
+              mutex.synchronize {
+                node.unlock
+                if node == root
+                  #
+                  # Root node was computed; we are done.
+                  #
+                  trace "Thread #{thread_index} got final answer"
+                  result = root.result
+                end
+                node_finished_condition.signal
+              }
+            else
+              trace "Thread #{thread_index}: no node found; sleeping."
+              mutex.synchronize {
+                thread_wake_condition.wait(mutex)
+              }
+            end
+          end
+          trace "Thread #{thread_index} exiting"
+        }
+      }
+
+      trace "Main: waiting for threads to launch and block."
+      while true
+        break if mutex.synchronize {
+          num_threads_ready == num_threads
+        }
+        Thread.pass
+      end
+      
+      trace "Main: entering main loop"
+      mutex.synchronize {
+        while true
+          trace "Main: waking threads"
+          thread_wake_condition.broadcast
+
+          if result
+            trace "Main: detected finish."
+            break
+          end
+
+          trace "Main: waiting for a node"
+          node_finished_condition.wait(mutex)
+          trace "Main: got a node"
+        end
+      }
+
+      trace "Main: waiting for threads to finish."
+      catch(:done) {
+        while true
+          mutex.synchronize {
+            throw :done if threads.all? { |thread|
+              thread.status == false
+            }
+            thread_wake_condition.broadcast
+          }
+          Thread.pass
+        end
+      }
+
+      trace "Main: computation done."
+      result
+    end
+
+    def find_node(node)
+      # --- only called inside mutex
+      trace "Looking for a node, starting with #{node.name}"
+      if node.result
+        #
+        # already computed
+        #
+        trace "#{node.name} has been computed"
+        nil
+      elsif node.children_results and node.try_lock
+        #
+        # Node is not computed and its children are computed;
+        # and we have the lock.  Ready to compute.
+        #
+        node
+      else
+        #
+        # locked or children not computed; recurse to children
+        #
+        trace "Checking #{node.name}'s children"
+        node.each_child { |child|
+          if next_node = find_node(child)
+            return next_node
+          end
+        }
+        nil
+      end
+    end
+
+    def compute_node(node, use_fork, bucket)
+      if use_fork
+        trace "About to fork for node #{node.name}"
+        if bucket
+          #
+          # Use our assigned bucket to transfer the result.
+          #
+          fork_node(node) {
+            node.trace_compute
+            bucket.contents = node.compute
+          }
+          bucket.contents
+        else
+          #
+          # No bucket -- discarding result
+          #
+          fork_node(node) {
+            node.trace_compute
+            node.compute
+          }
+          true
+        end
+      else
+        #
+        # No fork
+        #
+        node.trace_compute
+        node.compute
+      end
+    end
+
+    def fork_node(node)
+      trace "About to fork for node #{node.name}"
+      process_id = RetriableFork.fork {
+        trace "Fork: process #{Process.pid}"
+        node.trace_compute
+        yield
+        trace "Fork: computation done"
+      }
+      trace "Waiting for process #{process_id}"
+      Process.wait(process_id)
+      trace "Process #{process_id} finished"
+      exitstatus = $?.exitstatus
+      if exitstatus != 0
+        trace "Process #{process_id} returned #{exitstatus}; exiting."
+        exit(1)
+      end
+    end
+    
+    extend self
+  end
+end
+
+
+
+######################################################
+# 
+# **** DO NOT EDIT ****
+# 
+# **** THIS IS A GENERATED FILE *****
+# 
+######################################################
+
+

data/lib/rake/comp_tree/bucket_ipc.rb

@@ -0,0 +1,175 @@
+
+
+
+######################################################
+# 
+# **** DO NOT EDIT ****
+# 
+# **** THIS IS A GENERATED FILE *****
+# 
+######################################################
+
+
+
+require 'drb'
+require 'thread'
+
+require 'rake/comp_tree/retriable_fork'
+require 'rake/comp_tree/quix/diagnostic'
+require 'rake/comp_tree/quix/builtin/kernel/tap'
+
+module Rake::CompTree
+  module BucketIPC
+    class Bucket
+      include Quix::Diagnostic
+      include RetriableFork
+
+      def initialize(address, timeout, wait_interval)
+        trace "Making bucket with address #{address}"
+        
+        @remote_pid = fork {
+          own_object = Class.new {
+            attr_accessor(:contents)
+          }.new
+          server = DRb.start_service(address, own_object)
+          debug {
+            server.verbose = true
+          }
+          DRb.thread.join
+        }
+
+        @remote_object = DRbObject.new_with_uri(address)
+        @address = address
+        @timeout = timeout
+        @wait_interval = wait_interval
+      end
+      
+      attr_accessor(:timeout, :wait_interval)
+      attr_reader(:address)
+      
+      def contents=(new_contents)
+        connect {
+          @remote_object.contents = new_contents
+        }
+      end
+      
+      def contents
+        connect {
+          @remote_object.contents
+        }
+      end
+      
+      def stop
+        Process.kill("TERM", @remote_pid)
+      end
+      
+      private
+      
+      def connect
+        begin
+          return yield
+        rescue DRb::DRbConnError
+          start = Time.now
+          begin
+            Kernel.sleep(@wait_interval)
+            return yield
+          rescue DRb::DRbConnError
+            if Time.now - start > @timeout
+              raise
+            end
+            retry
+          end
+        end
+      end
+    end
+
+    class DriverBase
+      def initialize(addresses, timeout, wait_interval)
+        begin
+          @buckets = addresses.map { |address|
+            Bucket.new(address, timeout, wait_interval)
+          }
+          if block_given?
+            yield @buckets
+          end
+        ensure
+          if block_given?
+            stop
+          end
+        end
+      end
+      
+      def stop
+        if defined?(@buckets)
+          @buckets.each { |bucket|
+            bucket.stop
+          }
+        end
+      end
+    end
+
+    class Driver < DriverBase
+      DEFAULTS = {
+        :timeout => 0.5,
+        :wait_interval => 0.05,
+        :port_start => 18181,
+      }
+
+      module BucketCounter
+        @mutex = Mutex.new
+        @count = 0
+        class << self
+          def increment_count
+            @mutex.synchronize {
+              @count += 1
+            }
+          end
+
+          def map_indexes(num_buckets)
+            Array.new.tap { |result|
+              num_buckets.times {
+                result << yield(increment_count)
+              }
+            }
+          end
+        end
+      end
+
+      def initialize(num_buckets, opts_in = {})
+        opts = DEFAULTS.merge(opts_in)
+
+        addresses = 
+          if RetriableFork::HAVE_FORK
+            #
+            # Assume the existence of fork implies a unix machine.
+            #
+            require 'drb/unix'
+            basename = "drbunix://#{Dir.tmpdir}/bucket.#{Process.pid}.#{rand}"
+            BucketCounter.map_indexes(num_buckets) { |index|
+              "#{basename}.#{index}"
+            }
+          else
+            #
+            # Fallback: use the default socket.
+            #
+            BucketCounter.map_indexes(num_buckets) { |index|
+              "druby://localhost:#{opts[:port_start] + index}"
+            }
+          end
+        super(addresses, opts[:timeout], opts[:wait_interval])
+      end
+    end
+  end
+end
+
+
+
+######################################################
+# 
+# **** DO NOT EDIT ****
+# 
+# **** THIS IS A GENERATED FILE *****
+# 
+######################################################
+
+