comp_tree 0.5.2 → 0.7.0

data/CHANGES

@@ -0,0 +1,24 @@
+
+= CompTree ChangeLog
+
+== Version 0.7.0
+
+* remove fork and discard_result options
+* remove contrib/
+* remove block arg to CompTree.new; use CompTree.build
+* remove CompTree::Error nesting
+* Driver#compute accepts integer as second option
+* remove method_missing and eval tricks for node definitions;
+  new project 'pure' makes this obsolete
+* split up tests
+* allow non-symbols for node IDs
+* check_circular now returns the loop instead of raising
+* allow computation result of nil
+
+== Version 0.5.2
+
+* internal project cleanup (no relevant code changes).
+
+== Version 0.5.0
+
+* Initial release.

data/README

@@ -5,71 +5,38 @@
   
   require 'comp_tree'
   
-  CompTree::Driver.new { |driver|
+  CompTree.build do |driver|
 
-    # Define a function named 'area' taking these three arguments.
-    driver.define_area(:width, :height, :offset) { |width, height, offset|
-      width*height - offset
+    # 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|
-      2 + border
+    driver.define(:width, :border) { |border|
+      7 + border
     }
     
     # Ditto for 'height'.
-    driver.define_height(:border) { |border|
-      3 + border
+    driver.define(:height, :border) { |border|
+      5 + border
     }
     
     # Define a constant function 'border'.
-    driver.define_border {
-      5
-    }
-    
-    # Ditto for 'offset'.
-    driver.define_offset {
-      7
+    driver.define(:border) {
+      2
     }
     
     # Compute the area using four parallel threads.
-    area = driver.compute(:area, :threads => 4)
+    puts driver.compute(:area, :threads => 4)
+    # => 63
 
     # We've done this computation.
-    if area == (2 + 5)*(3 + 5) - 7
-      puts "It worked!"
-    else
-      puts "Send bug report to ..."
-    end
-  }
+    puts((7 + 2)*(5 + 2))
+    # => 63
+  end
 
-=== Alternative Forms for Function Definitions
-
-This form evals a lambda, saving you the repeat parameter list:
-
-  driver.define_area :width, :height, :offset, %{
-    width*height - offset
-  }
-  
-  driver.define_width :border, %{
-    2 + border
-  }
-  
-Notice the '<code>%</code>' before the brace.  The lambda is created
-just once, during the time of definition.
-
-Finally there is the raw form which uses no +eval+ or
-+method_missing+ tricks:
-
-  driver.define(:area, :width, :height, :offset) { |width, height, offset|
-    width*height - offset
-  }
-        
-  driver.define(:width, :border) { |border|
-    2 + border
-  }
-
-== Important Notes
+== Notes
 
 The user should have a basic understanding of <em>functional
 programming</em> (see for example
@@ -82,7 +49,7 @@ function you define must explicitly depend on the data it uses.
   #
   # BAD example: depending on state -- offset not listed as a parameter
   #
-  driver.define_area(:width, :height) { |width, height|
+  driver.define(:area, :width, :height) { |width, height|
     width*height - offset
   }
 
@@ -96,9 +63,9 @@ to affect a state (to produce a <em>side effect</em>).
   #
   # BAD example: affecting state
   #
-  driver.define_area(:width, :height, :offset) { |width, height, offset|
+  driver.define(:area, :width, :height) { |width, height|
     ACCUMULATOR.add "more data"
-    width*height - offset
+    width*height
   }
 
 Given a tree where nodes are modifying _ACCUMULATOR_, the end state of

data/Rakefile

@@ -1,140 +1,3 @@
-$LOAD_PATH.unshift "contrib/quix/lib"
 
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
+# rakelib generates tasks 
 
-$VERBOSE = nil
-require 'rdoc/rdoc'
-$VERBOSE = true
-
-require 'fileutils'
-include FileUtils
-
-GEMSPEC = eval(File.read("comp_tree.gemspec"))
-DOC_DIR = "html"
-
-######################################################################
-# clean
-
-task :clean => [:clobber, :clean_doc] do
-end
-
-task :clean_doc do
-  rm_rf(DOC_DIR)
-end
-
-######################################################################
-# test
-
-task :test do
-  require 'test/all'
-end
-
-######################################################################
-# package
-
-task :package => :clean
-
-Rake::GemPackageTask.new(GEMSPEC) { |t|
-  t.need_tar = true
-}
-
-######################################################################
-# doc
-
-task :doc => :clean_doc do 
-  files = %w(README) + %w(driver error node task_node).map { |name|
-    "lib/comp_tree/#{name}.rb"
-  }
-
-  options = [
-    "-o", DOC_DIR,
-    "--title", "comp_tree: #{GEMSPEC.summary}",
-    "--main", "README"
-  ]
-
-  RDoc::RDoc.new.document(files + options)
-end
-
-######################################################################
-# git
-
-def git(*args)
-  cmd = ["git"] + args
-  sh(*cmd)
-end
-
-task :init_contrib do
-  unless `git remote`.split.include? "quix"
-    git(*%w!remote add -f quix git@github.com:quix/quix.git!)
-  end
-end
-
-task :add_contrib_first_time => :init_contrib do
-  git(*%w!merge --squash -s ours --no-commit quix/master!)
-  git(*%w!read-tree --prefix=contrib/quix -u quix/master!)
-  git("commit", "-m", "add quix utils")
-end
-
-task :run_pull_contrib do
-  git(*%w!pull --no-commit -s subtree quix master!)
-end
-
-task :pull_contrib => [ :init_contrib, :run_pull_contrib ]
-
-######################################################################
-# publisher
-
-task :publish => :doc do
-  Rake::RubyForgePublisher.new('comptree', 'quix').upload
-end
-
-######################################################################
-# release
-
-task :prerelease => :clean do
-  rm_rf(DOC_DIR)
-  rm_rf("pkg")
-  unless `git status` =~ %r!nothing to commit \(working directory clean\)!
-    raise "Directory not clean"
-  end
-  unless `ping -c2 github.com` =~ %r!0% packet loss!i
-    raise "No ping for github.com"
-  end
-end
-
-def rubyforge(command, file)
-  sh("rubyforge",
-     command,
-     GEMSPEC.rubyforge_project,
-     GEMSPEC.rubyforge_project,
-     GEMSPEC.version.to_s,
-     file)
-end
-
-task :finish_release do
-  gem, tgz = %w(gem tgz).map { |ext|
-    "pkg/#{GEMSPEC.name}-#{GEMSPEC.version}.#{ext}"
-  }
-  gem_md5, tgz_md5 = [gem, tgz].map { |file|
-    "#{file}.md5".tap { |md5|
-      sh("md5sum #{file} > #{md5}")
-    }
-  }
-
-  rubyforge("add_release", gem)
-  rubyforge("add_file", gem_md5)
-  rubyforge("add_file", tgz)
-  rubyforge("add_file", tgz_md5)
-
-  git("tag", "comp_tree-" + GEMSPEC.version.to_s)
-  git(*%w(push --tags origin master))
-end
-
-task :release =>
-  [
-   :prerelease,
-   :package,
-   :publish,
-   :finish_release,
-  ]

data/comp_tree.gemspec

@@ -1,38 +1,41 @@
 
-Gem::Specification.new { |t|
-  t.author = "James M. Lawrence"
-  t.email = "quixoticsycophant@gmail.com"
-  t.summary = "Parallel Computation Tree"
-  t.name = "comp_tree"
-  t.rubyforge_project = "comptree"
-  t.homepage = "comptree.rubyforge.org"
-  t.version = "0.5.2"
-  t.description = "Build a computation tree and execute it with N " +
-    "parallel threads.  Optionally fork computation nodes into new processes."
+Gem::Specification.new { |g|
+  g.author = "James M. Lawrence"
+  g.email = "quixoticsycophant@gmail.com"
+  g.summary = "Parallel Computation Tree"
+  g.name = "comp_tree"
+  g.rubyforge_project = "comptree"
+  g.homepage = "comptree.rubyforge.org"
+  g.version = "0.7.0"
+  g.description =
+    "Build a computation tree and execute it with N parallel threads."
 
-  t.files = %w{README comp_tree.gemspec} +
-    Dir["./**/*.rb"] +
-    Dir["./**/Rakefile"]
+  readme = "README"
 
-  rdoc_exclude = %w{
-    test
-    contrib
-    install
-    quix
-    fork
-    diagnostic
-    algorithm
-    bucket
-    comp_tree\.rb
+  g.files = %W[
+    CHANGES
+    #{readme}
+    Rakefile
+    #{g.name}.gemspec
+    install.rb
+  ] + %w[lib rakelib test].inject(Array.new) { |acc, dir|
+    acc + Dir[dir + "/**/*.rb"]
   }
-  t.has_rdoc = true
-  t.extra_rdoc_files = %w{README}
-  t.rdoc_options += [
+  g.has_rdoc = true
+  rdoc_files = [
+    readme,
+    "lib/comp_tree.rb",
+    "lib/comp_tree/driver.rb",
+    "lib/comp_tree/error.rb"
+  ]
+  g.extra_rdoc_files += [readme]
+
+  g.rdoc_options += [
     "--main",
-    "README",
+    readme,
     "--title",
-    "comp_tree: #{t.summary}",
-  ] + rdoc_exclude.inject(Array.new) { |acc, pattern|
-    acc + ["--exclude", pattern]
+    "#{g.name}: #{g.summary}"
+  ] + (g.files - rdoc_files).inject(Array.new) { |acc, file|
+    acc + ["--exclude", file]
   }
 }

data/install.rb

@@ -1,3 +1,3 @@
-$LOAD_PATH.unshift "./contrib/quix/lib"
-require 'quix/simple_installer'
-CompTree::SimpleInstaller.new.run
+$LOAD_PATH.unshift "rakelib"
+require 'jumpstart/simple_installer'
+Jumpstart::SimpleInstaller.new.run

data/lib/comp_tree/algorithm.rb

@@ -1,210 +1,171 @@
 
-require 'comp_tree/diagnostic'
-require 'comp_tree/retriable_fork'
-
 module CompTree
   module Algorithm
-    include Diagnostic
+    module_function
+
+    def loop_with(leave, again)
+      catch(leave) {
+        while true
+          catch(again) {
+            yield
+          }
+        end
+      }
+    end
 
-    def compute_multithreaded(root, num_threads, use_fork, buckets)
-      trace "Computing #{root.name} with #{num_threads} threads"
-      result = nil
-      mutex = Mutex.new
+    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
-      threads = []
-      
-      # workaround: jruby gives "run" status for waiting on
-      # condition variable
-      num_threads_ready = 0
-
-      num_threads.times { |thread_index|
-        threads << Thread.new {
+      num_threads_in_use = 0
+
+      threads = (0...num_threads).map { |thread_index|
+        Thread.new {
           #
           # wait for main thread
           #
-          mutex.synchronize {
-            trace "Thread #{thread_index} waiting to start"
-            num_threads_ready += 1
-            thread_wake_condition.wait(mutex)
+          tree_mutex.synchronize {
+            #trace "Thread #{thread_index} waiting to start"
+            num_threads_in_use += 1
+            thread_wake_condition.wait(tree_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)
+          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
             }
 
-            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
-              }
-
+            #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)
               #
-              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"
+              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."
-      while true
-        break if mutex.synchronize {
-          num_threads_ready == num_threads
-        }
+      #trace "Main: waiting for threads to launch and block."
+      until tree_mutex.synchronize { num_threads_in_use == num_threads }
         Thread.pass
       end
-      
-      trace "Main: entering main loop"
-      mutex.synchronize {
-        while true
-          trace "Main: waking threads"
+
+      tree_mutex.synchronize {
+        #trace "Main: entering main loop"
+        until num_threads_in_use == 0
+          #trace "Main: waking threads"
           thread_wake_condition.broadcast
 
-          if result
-            trace "Main: detected finish."
+          if finished
+            #trace "Main: detected finish."
             break
           end
 
-          trace "Main: waiting for a node"
-          node_finished_condition.wait(mutex)
-          trace "Main: got a node"
+          #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."
-      catch(:done) {
-        while true
-          mutex.synchronize {
-            throw :done if threads.all? { |thread|
-              thread.status == false
-            }
-            thread_wake_condition.broadcast
-          }
-          Thread.pass
-        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."
-      result
+      #trace "Main: computation done."
+      if finished.is_a? Exception
+        raise finished
+      else
+        root.result
+      end
     end
 
     def find_node(node)
-      # --- only called inside mutex
-      trace "Looking for a node, starting with #{node.name}"
-      if node.result
+      # --- 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"
+        #trace "#{node.name} has been computed"
         nil
-      elsif node.children_results and node.try_lock
+      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"
+        #trace "Checking #{node.name}'s children"
         node.each_child { |child|
-          if next_node = find_node(child)
-            return next_node
-          end
+          next_node = find_node(child) and return next_node
         }
         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