drake 0.8.4.1.1.0 → 0.8.4.1.2.0

data/test/test_require.rb

@@ -10,6 +10,7 @@ class TestRequire < Test::Unit::TestCase
 
   def test_can_load_rake_library
     app = Rake::Application.new
+    app.options.threads = Rake.application.options.threads
     assert app.instance_eval {
       rake_require("test2", ['test/data/rakelib'], [])
     }
@@ -17,6 +18,7 @@ class TestRequire < Test::Unit::TestCase
 
   def test_wont_reload_rake_library
     app = Rake::Application.new
+    app.options.threads = Rake.application.options.threads
     assert ! app.instance_eval {
       rake_require("test2", ['test/data/rakelib'], ['test2'])
     }
@@ -24,6 +26,7 @@ class TestRequire < Test::Unit::TestCase
 
   def test_throws_error_if_library_not_found
     app = Rake::Application.new
+    app.options.threads = Rake.application.options.threads
     ex = assert_exception(LoadError) {
       assert app.instance_eval {
         rake_require("testx", ['test/data/rakelib'], [])

data/test/test_rules.rb

@@ -21,7 +21,7 @@ class TestRules < Test::Unit::TestCase
 
   def setup
     Task.clear
-    @runs = []
+    @runs = SerializedArray.new
   end
 
   def teardown
@@ -41,12 +41,11 @@ class TestRules < Test::Unit::TestCase
   end
 
   def test_multiple_rules2
-    mutex = Mutex.new
     create_file(FTNFILE)
     delete_file(SRCFILE)
     delete_file(OBJFILE)
-    rule(/\.o$/ => ['.f']) do mutex.synchronize { @runs << :F } end
-    rule(/\.o$/ => ['.c']) do mutex.synchronize { @runs << :C } end
+    rule(/\.o$/ => ['.f']) do @runs << :F end
+    rule(/\.o$/ => ['.c']) do @runs << :C end
     Task[OBJFILE].invoke
     assert_equal [:F], @runs
   end
@@ -318,7 +317,7 @@ class TestRules < Test::Unit::TestCase
   end
 
   def test_recursive_rules_will_work_as_long_as_they_terminate
-    actions = []
+    actions = SerializedArray.new
     create_file("testdata/abc.xml")
     rule '.y' => '.xml' do actions << 'y' end
     rule '.c' => '.y' do actions << 'c'end

data/test/test_task_manager.rb

@@ -13,7 +13,6 @@ class TestTaskManager < Test::Unit::TestCase
 
   def setup
     @tm = TaskManager.new
-    @tm.num_threads = Rake.application.num_threads
   end
 
   def test_create_task_manager
@@ -139,7 +138,7 @@ class TestTaskManager < Test::Unit::TestCase
   def test_correctly_scoped_prerequisites_are_invoked
     values = []
     @tm = Rake::Application.new
-    @tm.num_threads = Rake.application.num_threads
+    @tm.options.threads = Rake.application.options.threads
     @tm.define_task(Rake::Task, :z) do values << "top z" end
     @tm.in_namespace("a") do
       @tm.define_task(Rake::Task, :z) do values << "next z" end

data/test/test_tasks.rb

@@ -35,17 +35,24 @@ class TestTask < Test::Unit::TestCase
   end
 
   def test_invoke
-    runlist = []
+    runlist = SerializedArray.new
     t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
     t2 = task(:t2) { |t| runlist << t.name }
     t3 = task(:t3) { |t| runlist << t.name }
     assert_equal ["t2", "t3"], t1.prerequisites
     t1.invoke
-    assert_equal ["t2", "t3", "t1"], runlist
+    if Rake.application.options.threads == 1
+      assert_equal ["t2", "t3", "t1"], runlist
+    else
+      assert_block {
+        ["t2", "t3", "t1"] == runlist or
+        ["t3", "t2", "t1"] == runlist
+      }
+    end
   end
 
   def test_invoke_with_circular_dependencies
-    runlist = []
+    runlist = SerializedArray.new
     t1 = task(:t1 => [:t2]) { |t| runlist << t.name; 3321 }
     t2 = task(:t2 => [:t1]) { |t| runlist << t.name }
     assert_equal ["t2"], t1.prerequisites
@@ -59,7 +66,7 @@ class TestTask < Test::Unit::TestCase
 
   def test_dry_run_prevents_actions
     Rake.application.options.dryrun = true
-    runlist = []
+    runlist = SerializedArray.new
     t1 = task(:t1) { |t| runlist << t.name; 3321 }
     out = capture_stdout { t1.invoke }
     assert_match(/execute .*t1/i, out)
@@ -76,25 +83,30 @@ class TestTask < Test::Unit::TestCase
     out = capture_stdout {
       t1.invoke
     }
-    if Rake.application.num_threads == 1
-      assert_match(/invoke t1/i, out)
-    end
+    assert_match(/invoke t1/i, out)
     assert_match(/execute t1/i, out)
   ensure
     Rake.application.options.trace = false
   end
 
   def test_no_double_invoke
-    runlist = []
+    runlist = SerializedArray.new
     t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
     t2 = task(:t2 => [:t3]) { |t| runlist << t.name }
     t3 = task(:t3) { |t| runlist << t.name }
     t1.invoke
-    assert_equal ["t3", "t2", "t1"], runlist
+    if Rake.application.options.threads == 1
+      assert_equal ["t3", "t2", "t1"], runlist
+    else
+      assert_block {
+        ["t2", "t3", "t1"] == runlist or
+        ["t3", "t2", "t1"] == runlist
+      }
+    end
   end
 
   def test_can_double_invoke_with_reenable
-    runlist = []
+    runlist = SerializedArray.new
     t1 = task(:t1) { |t| runlist << t.name }
     t1.invoke
     t1.reenable
@@ -136,7 +148,7 @@ class TestTask < Test::Unit::TestCase
   end
 
   def test_multi_invocations
-    runs = []
+    runs = SerializedArray.new
     p = proc do |t| runs << t.name end
     task({:t1=>[:t2,:t3]}, &p)
     task({:t2=>[:t3]}, &p)
@@ -284,7 +296,7 @@ class TestTaskWithArguments < Test::Unit::TestCase
   end
 
   def test_actions_of_various_arity_are_ok_with_args
-    notes = []
+    notes = SerializedArray.new
     t = task(:t, :x) do
       notes << :a
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: drake
 version: !ruby/object:Gem::Version 
-  version: 0.8.4.1.1.0
+  version: 0.8.4.1.2.0
 platform: ruby
 authors: 
 - James M. Lawrence
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-09 00:00:00 -04:00
+date: 2009-04-13 00:00:00 -04:00
 default_executable: drake
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: comp_tree
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.1
+    version: 
 description: Rake is a Make-like program implemented in Ruby. Tasks and dependencies are specified in standard Ruby syntax.
 email: quixoticsycophant@gmail.com
 executables: 
@@ -26,6 +35,7 @@ extra_rdoc_files:
 - CHANGES
 - doc/command_line_usage.rdoc
 - doc/glossary.rdoc
+- doc/parallel.rdoc
 - doc/proto_rake.rdoc
 - doc/rakefile.rdoc
 - doc/rational.rdoc
@@ -48,19 +58,14 @@ files:
 - CHANGES
 - CHANGES.drake
 - MIT-LICENSE
+- README
 - Rakefile
 - Rakefile.drake
-- README
 - TODO
 - bin/drake
 - lib/rake/alt_system.rb
 - lib/rake/classic_namespace.rb
 - lib/rake/clean.rb
-- lib/rake/comp_tree/algorithm.rb
-- lib/rake/comp_tree/comp_tree.rb
-- lib/rake/comp_tree/driver.rb
-- lib/rake/comp_tree/error.rb
-- lib/rake/comp_tree/node.rb
 - lib/rake/contrib/compositepublisher.rb
 - lib/rake/contrib/ftptools.rb
 - lib/rake/contrib/publisher.rb
@@ -88,22 +93,22 @@ files:
 - test/filecreation.rb
 - test/functional.rb
 - test/in_environment.rb
-- test/parallel.rb
+- test/parallel_setup.rb
 - test/rake_test_setup.rb
 - test/reqfile.rb
 - test/reqfile2.rb
+- test/serial_setup.rb
 - test/session_functional.rb
 - test/shellcommand.rb
-- test/single_threaded.rb
 - test/test_application.rb
 - test/test_clean.rb
 - test/test_definitions.rb
 - test/test_earlytime.rb
 - test/test_extension.rb
-- test/test_filelist.rb
-- test/test_fileutils.rb
 - test/test_file_creation_task.rb
 - test/test_file_task.rb
+- test/test_filelist.rb
+- test/test_fileutils.rb
 - test/test_ftp.rb
 - test/test_invocation_chain.rb
 - test/test_makefile_loader.rb
@@ -117,10 +122,10 @@ files:
 - test/test_rdoc_task.rb
 - test/test_require.rb
 - test/test_rules.rb
-- test/test_tasklib.rb
-- test/test_tasks.rb
 - test/test_task_arguments.rb
 - test/test_task_manager.rb
+- test/test_tasklib.rb
+- test/test_tasks.rb
 - test/test_test_task.rb
 - test/test_top_level_functions.rb
 - test/test_win32.rb
@@ -135,18 +140,17 @@ files:
 - test/data/namespace/Rakefile
 - test/data/statusreturn/Rakefile
 - test/data/unittest/Rakefile
-- test/Rakefile.seq
-- test/Rakefile.simple
 - test/data/unittest/subdir
 - doc/command_line_usage.rdoc
 - doc/example
+- doc/example/Rakefile1
+- doc/example/Rakefile2
 - doc/example/a.c
 - doc/example/b.c
 - doc/example/main.c
-- doc/example/Rakefile1
-- doc/example/Rakefile2
 - doc/glossary.rdoc
 - doc/jamis.rb
+- doc/parallel.rdoc
 - doc/proto_rake.rdoc
 - doc/rake.1.gz
 - doc/rakefile.rdoc
@@ -196,6 +200,6 @@ rubyforge_project: drake
 rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
-summary: A fork of Rake supporting parallel task execution.
+summary: A branch of Rake supporting automatic parallelizing of tasks.
 test_files: []
 

data/lib/rake/comp_tree/algorithm.rb

@@ -1,172 +0,0 @@
-
-module Rake end
-module Rake::CompTree
-  module Algorithm
-    module_function
-
-    def loop_with(leave, again)
-      catch(leave) {
-        while true
-          catch(again) {
-            yield
-          }
-        end
-      }
-    end
-
-    def compute_multithreaded(root, num_threads)
-      #trace "Computing #{root.name} with #{num_threads} threads"
-      finished = nil
-      tree_mutex = Mutex.new
-      node_finished_condition = ConditionVariable.new
-      thread_wake_condition = ConditionVariable.new
-      num_threads_in_use = 0
-
-      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_in_use += 1
-            thread_wake_condition.wait(tree_mutex)
-          }
-
-          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_in_use -= 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."
-                  thread_wake_condition.wait(tree_mutex)
-                  throw :again
-                end
-              end
-            }
-
-            #trace "Thread #{thread_index} computing node"
-            #debug {
-            #  node.trace_compute
-            #}
-            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.
-              #
-              node_finished_condition.signal
-            }
-          }
-          #trace "Thread #{thread_index} exiting"
-        }
-      }
-
-      #trace "Main: waiting for threads to launch and block."
-      until tree_mutex.synchronize { num_threads_in_use == num_threads }
-        Thread.pass
-      end
-
-      tree_mutex.synchronize {
-        #trace "Main: entering main loop"
-        until num_threads_in_use == 0
-          #trace "Main: waking threads"
-          thread_wake_condition.broadcast
-
-          if finished
-            #trace "Main: detected finish."
-            break
-          end
-
-          #trace "Main: waiting for a node"
-          node_finished_condition.wait(tree_mutex)
-          #trace "Main: got a node"
-        end
-      }
-
-      #trace "Main: waiting for threads to finish."
-      loop_with(:leave, :again) {
-        tree_mutex.synchronize {
-          if threads.all? { |thread| thread.status == false }
-            throw :leave
-          end
-          thread_wake_condition.broadcast
-        }
-        Thread.pass
-      }
-
-      #trace "Main: computation done."
-      if finished.is_a? Exception
-        raise finished
-      else
-        root.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
-        #
-        # Node is not computed and its children are computed;
-        # and we have the lock.  Ready to compute.
-        #
-        node.children_results = children_results
-        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
-        }
-        nil
-      end
-    end
-  end
-end