comp_tree 0.5.0

data/lib/comp_tree.rb

@@ -0,0 +1,23 @@
+# 
+# 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 'comp_tree/driver'

data/test/all.rb

@@ -0,0 +1,12 @@
+
+require 'rbconfig'
+
+Dir["#{File.dirname(__FILE__)}/test_*.rb"].map { |file|
+  File.expand_path(file)
+}.each { |file|
+  # spawn separate processes to avoid EAGAIN signals on fork
+  ruby = File.join(
+    Config::CONFIG["bindir"],
+    Config::CONFIG["RUBY_INSTALL_NAME"])
+  system(ruby, file)
+}

data/test/test_bucketipc.rb

@@ -0,0 +1,72 @@
+
+$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
+
+require 'test/unit'
+require 'comp_tree/bucket_ipc'
+
+Thread.abort_on_exception = true
+
+class BucketTest < Test::Unit::TestCase
+  include CompTree::RetriableFork
+
+  def each_bucket(num_buckets, &block)
+    if HAVE_FORK
+      CompTree::BucketIPC::Driver.new(num_buckets) { |buckets|
+        buckets.each { |bucket|
+          yield bucket
+        }
+      }
+    end
+  end
+
+  def test_1_no_fork
+    each_bucket(10) { |bucket|
+      local = bucket.contents = :before
+      bucket.contents = :after
+      assert_equal(local, :before)
+      assert_equal(bucket.contents, :after)
+    }
+  end
+
+  def test_2_fork
+    each_bucket(10) { |bucket|
+      local = bucket.contents = :before
+      process_id = fork {
+        bucket.contents = :after
+      }
+      Process.wait(process_id)
+      assert_equal(local, :before)
+      assert_equal(bucket.contents, :after)
+    }
+  end
+
+  def each_base_test
+    [
+     :test_1_no_fork,
+     :test_2_fork,
+    ].each { |method|
+      yield method
+    }
+  end
+  
+  def test_3_thread
+    each_base_test { |method|
+      Thread.new {
+        send(method)
+      }.join
+    }
+  end
+
+  def test_4_thread_flood
+    each_base_test { |method|
+      (0...10).map {
+        Thread.new {
+          send(method)
+        }
+      }.each { |thread|
+        thread.join
+      }
+    }
+  end
+end
+

data/test/test_circular.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
+
+require 'comp_tree'
+require 'test/unit'
+
+module CompTree
+  class TestCircular < Test::Unit::TestCase
+    def test_1
+      CompTree::Driver.new { |driver|
+        driver.define(:area, :width, :height, :offset) { |width, height, offset|
+          width*height - offset
+        }
+        
+        driver.define(:width, :border) { |border|
+          2 + border
+        }
+        
+        driver.define(:height, :border) { |border|
+          3 + border
+        }
+        
+        driver.define(:border) {
+          5
+        }
+        
+        driver.define(:offset, :area) {
+          7
+        }
+
+        assert_raises(Error::CircularError) {
+          driver.check_circular(:area)
+        }
+      }
+    end
+  end
+end

data/test/test_comp_tree.rb

@@ -0,0 +1,364 @@
+
+$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
+
+require 'test/unit'
+require 'benchmark'
+
+require 'comp_tree'
+
+srand(22)
+
+module CompTree
+  Thread.abort_on_exception = true
+  HAVE_FORK = RetriableFork::HAVE_FORK
+  DO_FORK = (HAVE_FORK and not ARGV.include?("--no-fork"))
+
+  module TestCommon
+    include Quix::Diagnostic
+
+    if  ARGV.include?("--bench")
+      def separator
+        trace ""
+        trace "-"*60
+      end
+    else
+      def separator ; end
+      def trace(*args) ; end
+    end
+  end
+
+  module TestBase
+    include TestCommon
+
+    def test_1_syntax
+      CompTree::Driver.new { |driver|
+        driver.define(:area, :width, :height, :offset) { |width, height, offset|
+          width*height - offset
+        }
+        
+        driver.define(:width, :border) { |border|
+          2 + border
+        }
+        
+        driver.define(:height, :border) { |border|
+          3 + border
+        }
+        
+        driver.define(:border) {
+          5
+        }
+        
+        driver.define(:offset) {
+          7
+        }
+        
+        assert_equal((2 + 5)*(3 + 5) - 7,
+                     driver.compute(:area, opts(6)))
+      }
+    end
+
+    def test_2_syntax
+      CompTree::Driver.new { |driver|
+        driver.define_area(:width, :height, :offset) { |width, height, offset|
+          width*height - offset
+        }
+        
+        driver.define_width(:border) { |border|
+          2 + border
+        }
+        
+        driver.define_height(:border) { |border|
+          3 + border
+        }
+        
+        driver.define_border {
+          5
+        }
+        
+        driver.define_offset {
+          7
+        }
+        
+        assert_equal((2 + 5)*(3 + 5) - 7,
+                     driver.compute(:area, opts(6)))
+      }
+    end
+
+    def test_3_syntax
+      CompTree::Driver.new { |driver|
+        driver.define_area :width, :height, :offset, %{
+          width*height - offset
+        }
+        
+        driver.define_width :border, %{
+          2 + border
+        }
+        
+        driver.define_height :border, %{
+          3 + border
+        }
+        
+        driver.define_border %{
+          5
+        }
+        
+        driver.define_offset %{
+          7
+        }
+
+        assert_equal((2 + 5)*(3 + 5) - 7,
+                     driver.compute(:area, opts(6)))
+      }
+    end
+
+    def test_thread_flood
+      max =
+        if use_fork?
+          16
+        else
+          200
+        end
+      (1..max).each { |threads|
+        CompTree::Driver.new { |driver|
+          drain = lambda {
+            1.times { }
+          }
+          driver.define_a(:b, &drain)
+          driver.define_b(&drain)
+          driver.compute(:a, opts(threads))
+        }
+      }
+    end
+
+    def test_malformed
+      CompTree::Driver.new { |driver|
+        assert_raise(CompTree::Error::ArgumentError) {
+          driver.define {
+          }
+        }
+        assert_raise(CompTree::Error::RedefinitionError) {
+          driver.define(:a) {
+          }
+          driver.define(:a) {
+          }
+        }
+        assert_raise(CompTree::Error::ArgumentError) {
+          driver.define(:b) {
+          }
+          driver.compute(:b, :threads => 0)
+        }
+        assert_raise(CompTree::Error::ArgumentError) {
+          driver.define(:c) {
+          }
+          driver.compute(:c, :threads => -1)
+        }
+      }
+    end
+
+    def generate_comp_tree(num_levels, num_children, drain_iterations)
+      CompTree::Driver.new { |driver|
+        root = :aaa
+        last_name = root
+        pick_names = lambda {
+          (0..rand(num_children)).map {
+            last_name = last_name.to_s.succ.to_sym
+          }
+        }
+        drain = lambda {
+          drain_iterations.times {
+          }
+        }
+        build_tree = lambda { |parent, children, level|
+          trace "building #{parent} --> #{children.join(' ')}"
+          
+          driver.define(parent, *children, &drain)
+
+          if level < num_levels
+            children.each { |child|
+              build_tree.call(child, pick_names.call, level + 1)
+            }
+          else
+            children.each { |child|
+              driver.define(child, &drain)
+            }
+          end
+        }
+        build_tree.call(root, pick_names.call, drain_iterations)
+      }
+    end
+
+    def run_generated_tree(args)
+      args[:level_range].each { |num_levels|
+        args[:children_range].each { |num_children|
+          separator
+          trace {%{num_levels}}
+          trace {%{num_children}}
+          trace {%{use_fork?}}
+          driver = generate_comp_tree(
+            num_levels,
+            num_children,
+            args[:drain_iterations])
+          args[:thread_range].each { |threads|
+            trace {%{threads}}
+            2.times {
+              driver.reset(:aaa)
+              result = nil
+              trace Benchmark.measure {
+                result = driver.compute(:aaa, opts(threads))
+              }
+              assert_equal(result, args[:drain_iterations])
+            }
+          }
+        }
+      }
+    end
+
+    def test_generated_tree
+      if use_fork?
+        run_generated_tree(
+          :level_range => 4..4,
+          :children_range => 4..4,
+          :thread_range => 8..8,
+          :drain_iterations => 0)
+      else
+        run_generated_tree(
+          :level_range => 4..4,
+          :children_range => 4..4,
+          :thread_range => 8..8,
+          :drain_iterations => 0)
+      end
+    end
+
+    def use_fork?
+      not opts(0)[:fork].nil?
+    end
+  end
+  
+  module NoForkTestBase
+    include TestBase
+    def opts(threads)
+      {
+        :threads => threads,
+      }
+    end
+  end
+
+  module ForkTestBase
+    include TestBase
+    def opts(threads)
+      {
+        :threads => threads,
+        :fork => HAVE_FORK,
+      }
+    end
+  end
+  
+  class Test_1_NoFork < Test::Unit::TestCase
+    include NoForkTestBase
+  end
+
+  if DO_FORK
+    class Test_2_Fork < Test::Unit::TestCase
+      include ForkTestBase
+    end
+  end
+
+  class Test_Task < Test::Unit::TestCase
+    def test_task
+      CompTree::Driver.new(:discard_result => true) { |driver|
+        visit = 0
+        mutex = Mutex.new
+        func = lambda {
+          mutex.synchronize {
+            visit += 1
+          }
+        }
+        driver.define_a(:b, :c, &func)
+        driver.define_b(&func)
+        driver.define_c(:d, &func)
+        driver.define_d(&func)
+
+        (2..10).each { |threads|
+          assert_equal(
+            true,
+            driver.compute(
+              :a,
+              :threads => threads))
+          assert_equal(visit, 4)
+          driver.reset(:a)
+          visit = 0
+        }
+
+        (2..10).each { |threads|
+          assert_equal(
+            true,
+            driver.compute(
+              :a,
+              :threads => threads,
+              :fork => HAVE_FORK))
+          if HAVE_FORK
+            assert_equal(visit, 0)
+          else
+            assert_equal(visit, 4)
+          end
+          driver.reset(:a)
+          visit = 0
+        }
+      }
+    end
+  end
+
+  class Test_Drainer < Test::Unit::TestCase
+    include TestCommon
+
+    def drain(opts)
+      code = %{ 5000.times { } }
+      if opts[:fork]
+        eval code
+      else
+        system("ruby", "-e", code)
+      end
+    end
+    
+    def run_drain(opts)
+      CompTree::Driver.new { |driver|
+        func = lambda {
+          drain(opts)
+        }
+        driver.define_area(:width, :height, :offset, &func)
+        driver.define_width(:border, &func)
+        driver.define_height(:border, &func)
+        driver.define_border(&func)
+        driver.define_offset(&func)
+        trace "number of threads: #{opts[:threads]}"
+        trace Benchmark.measure {
+          driver.compute(:area, opts)
+        }
+      }
+    end
+
+    def each_drain
+      (1..10).each { |threads|
+        yield threads
+      }
+    end
+
+    def test_no_fork
+      separator
+      trace "Subrocess test."
+      each_drain { |threads|
+        run_drain({:threads => threads})
+      }
+    end
+    
+    if DO_FORK
+      def test_fork
+        separator
+        trace "Forking test."
+        each_drain { |threads|
+          run_drain({:threads => threads, :fork => HAVE_FORK})
+        }
+      end
+    end
+  end
+end

data/test/test_exception.rb

@@ -0,0 +1,97 @@
+
+#
+# Mean workaround using separate processes due to assert_raise causing
+# problems with threads.
+#
+
+require 'test/unit'
+
+module WorkaroundConfig
+  HERE = File.dirname(__FILE__)
+  LIB_DIR = File.expand_path("#{HERE}/../lib")
+  QUIX_LIB_DIR = File.expand_path("#{HERE}/../contrib/quix/lib")
+  OUTPUT_FILE = "#{HERE}/#{File.basename(__FILE__)}.output"
+  
+  $LOAD_PATH.unshift LIB_DIR
+  $LOAD_PATH.unshift QUIX_LIB_DIR
+end
+  
+require 'comp_tree'
+require 'quix/config'
+
+module CompTree
+  class TestRaises < Test::Unit::TestCase
+    include WorkaroundConfig
+
+    def test_exception
+      if RUBY_PLATFORM =~ %r!java!
+        puts "skipping #{File.basename(__FILE__)}."
+      else
+        [true, false].each { |use_fork|
+          [true, false].each { |define_all|
+            assert(
+              !system(
+                ::Quix::Config.ruby_executable,
+                "-e",
+                code(use_fork, define_all)))
+            
+            output = File.read(OUTPUT_FILE)
+
+            if define_all
+              assert_match(%r!CompTreeTestError!, output)
+            else
+              assert_match(%r!NoFunctionError!, output)
+            end
+            
+            File.unlink(OUTPUT_FILE) # leave when exception raised above
+          }
+        }
+      end
+    end
+
+    def code(use_fork, define_all)
+      %Q( 
+        $LOAD_PATH.unshift '#{LIB_DIR}'
+        require 'comp_tree'
+        require 'open3'
+        
+        class CompTreeTestError < Exception ; end
+        
+        CompTree::Driver.new { |driver|
+          driver.define(:area, :width, :height, :offset) {
+            |width, height, offset|
+            width*height - offset
+          }
+
+          driver.define(:width, :border) { |border|
+            2 + border
+          }
+
+          driver.define(:height, :border) { |border|
+            3 + border
+          }
+      ) +    
+      if define_all
+        %Q(
+          driver.define(:border) {
+            raise CompTreeTestError
+          }
+        )
+      else
+        ""
+      end +
+      %Q(        
+          driver.define(:offset) {
+            7
+          }
+          
+          File.open('#{OUTPUT_FILE}', "w") { |out|
+            $stderr = out
+            driver.compute(
+              :area, :threads => 99, :fork => #{use_fork.inspect})
+          }
+        }
+      )
+    end
+  end
+end