tiamat 0.1.0

data/lib/tiamat/version.rb

@@ -0,0 +1,4 @@
+
+module Tiamat
+  VERSION = "0.1.0"
+end

data/lib/tiamat/worker.rb

@@ -0,0 +1,61 @@
+
+module Tiamat
+  class Worker
+    def define_function_begin(pure_module, num_parallel)
+    end
+        
+    def define_function(spec)
+      lambda { |*args|
+        self.class.farm.lend_server { |server|
+          server.evaluate_function(spec, *args)
+        }
+      }
+    end
+        
+    def define_function_end
+    end
+
+    def num_parallel
+      self.class.num_parallel
+    end
+        
+    class << self
+      attr_reader :farm
+
+      def open(farm)
+        unless closed?
+          raise AlreadyOpenError.new(self)
+        end
+        @farm = farm
+        if block_given?
+          previous_worker = Pure.worker
+          Pure.worker = self
+          begin
+            yield
+          ensure
+            Pure.worker = previous_worker
+            close
+          end
+        end
+      end
+
+      def close
+        unless closed?
+          @farm.close
+          @farm = nil
+        end
+      end
+
+      def closed?
+        not defined?(@farm) or @farm.nil?
+      end
+    
+      def num_parallel
+        @farm.num_servers
+      end
+
+      def num_parallel=(value)
+      end
+    end
+  end
+end

data/spec/connector_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+describe Tiamat::Connector do
+  it "should raise for nonexistent server" do
+    lambda {
+      Tiamat::Connector.connect(0.1, 0.5) {
+        DRbObject.new_with_uri("druby://localhost:9999").foo
+      }
+    }.should raise_error(DRb::DRbConnError)
+  end
+end

data/spec/drb_connection_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+describe "drb connection" do
+  before :all do
+    @uri = "druby://localhost:22334"
+    @server = Tiamat::LocalChildServer.new(@uri, *Tiamat.compiler.reverse)
+  end
+
+  after :all do
+    @server.close
+  end
+
+  it "should be creatable" do
+    @server.instance_eval do
+      @drb_object.ping
+    end
+  end
+end

data/spec/local_child_farm_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+describe Tiamat::LocalChildFarm do
+  before :all do
+    @farm = Tiamat::LocalChildFarm.new(4, *Tiamat.compiler.reverse)
+  end
+
+  after :all do
+    @farm.close
+  end
+    
+  it "should provide local servers" do
+    mod = pure(Pure::Parser::RubyParser) do
+      def f
+        33 + 44
+      end
+    end
+    spec = Pure::ExtractedFunctions[Pure::Parser::RubyParser][mod][:f]
+
+    20.times {
+      @farm.lend_server { |server_a|
+        @farm.lend_server { |server_b|
+          server_a.evaluate_function(spec).should eql(77)
+          server_b.evaluate_function(spec).should eql(77)
+        }
+      }
+    }
+  end
+end

data/spec/local_child_server_path_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+describe "Tiamat::LocalChildServer launch" do
+  before :all do
+    require 'fileutils'
+    @dummy_server = File.expand_path(
+      File.dirname(__FILE__) +
+      "/data/" + 
+      Tiamat::LocalChildServer.server_basename
+    )
+    FileUtils.mkdir_p(File.dirname(@dummy_server))
+    FileUtils.touch(@dummy_server)
+  end
+    
+  after :all do
+    FileUtils.rm_r(File.dirname(@dummy_server))
+  end
+
+  it "should prefer #{Tiamat::LocalChildServer.server_basename} in path" do
+    new_path = (
+      ENV["PATH"].
+      split(File::PATH_SEPARATOR).
+      unshift(File.dirname(@dummy_server))
+    ).join(File::PATH_SEPARATOR)
+
+    fallback = File.expand_path(
+      File.dirname(__FILE__) +
+      "/../bin/" +
+      Tiamat::LocalChildServer.server_basename
+    )
+    Tiamat::LocalChildServer.server_path.should eql(fallback)
+    TiamatSpecBase.with_env("PATH" => new_path) {
+      Tiamat::LocalChildServer.server_path.should eql(@dummy_server)
+    }
+    Tiamat::LocalChildServer.server_path.should eql(fallback)
+  end
+end

data/spec/local_child_server_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+describe Tiamat::LocalChildServer do
+  before :all do
+    @server = Tiamat::LocalChildServer.new(
+      "druby://localhost:27272", *Tiamat.compiler.reverse
+    )
+  end
+
+  after :all do
+    @server.close
+  end
+
+  it "should evaluate a pure function spec" do
+    mod = pure(Pure::Parser::RubyParser) do
+      def f
+        33 + 44
+      end
+    end
+    spec = Pure::ExtractedFunctions[Pure::Parser::RubyParser][mod][:f]
+    
+    @server.evaluate_function(spec).should == 77
+  end
+end

data/spec/local_child_worker_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+require 'benchmark'
+
+describe Tiamat::LocalChildWorker do
+  before :all do
+    Tiamat::LocalChildWorker.open(2, *Tiamat.compiler.reverse)
+  end
+
+  after :all do
+    Tiamat::LocalChildWorker.close
+  end
+
+  it "should evaluate a pure function with no args" do
+    result = pure do
+      def f
+        11 + 22
+      end
+    end.compute(Tiamat::LocalChildWorker)
+
+    result.f.should == 33
+  end
+
+  it "should evaluate a pure function with args" do
+    mod = pure do
+      def f(x, y)
+        x + y
+      end
+      def x
+        33
+      end
+      def y
+        44
+      end
+    end.compute(Tiamat::LocalChildWorker).f.should == 77
+  end
+
+  it "should handle `fun' definitions with no args" do
+    pure do
+      fun :f do
+        11 + 22
+      end
+    end.compute(Tiamat::LocalChildWorker).f.should == 33
+  end
+
+  it "should handle `fun' definitions with args" do
+    pure do
+      fun :f => [:x, :y] do |u, v|
+        u*v
+      end
+
+      fun :x do
+        4
+      end
+
+      def y
+        5
+      end
+    end.compute(Tiamat::LocalChildWorker).f.should == 20
+  end
+
+  it "should be around 2x faster with 2 servers" do
+    mod = pure do
+      def total(left, right)
+        left + right
+      end
+
+      def left
+        (1..250_000).inject(0) { |acc, n| acc + n }
+      end
+
+      def right
+        (1..250_000).inject(0) { |acc, n| acc + n }
+      end
+    end
+    
+    default_result = nil
+    default_time = mod.compute(2) { |result|
+      Benchmark.measure {
+        default_result = result.total
+      }.real
+    }
+    
+    tiamat_result = nil
+    tiamat_time = mod.compute(Tiamat::LocalChildWorker) { |result|
+      Benchmark.measure {
+        tiamat_result = result.total
+      }.real
+    }
+
+    expected = 250_000*(250_000 + 1)
+    default_result.should eql(expected)
+    tiamat_result.should eql(expected)
+
+    # jruby is slow
+    epsilon = 0.65 + (RUBY_PLATFORM == "java" ? 1.0 : 0)
+    if ARGV.include? "--bench"
+      puts
+      puts "-----------"
+      puts "tiamat  #{tiamat_time}"
+      puts "default #{default_time}"
+      puts
+      puts "ratio   #{tiamat_time/default_time}"
+      puts "-----------"
+    end
+  end
+
+  it "should propagate exceptions from root function" do
+    mod = pure do
+      def f
+        raise "zz"
+      end
+    end
+    result = mod.compute(4)
+    lambda {
+      result.f
+    }.should raise_error(RuntimeError, "zz")
+  end
+
+  it "should propagate exceptions from child functions" do
+    mod = pure do
+      def f(x)
+        33
+      end
+      
+      def x(y)
+        44
+      end
+      
+      def y
+        raise "foo"
+      end
+    end
+    result = mod.compute(4)
+    lambda {
+      result.f
+    }.should raise_error(RuntimeError, "foo")
+  end
+end
+

data/spec/pure_spec.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+describe Pure do
+  before :all do
+    border = pure do
+      def border
+        2
+      end
+    end
+
+    @geometry = pure do
+      include border
+
+      def area(width, height)
+        width*height
+      end
+      
+      def width(border)
+        7 + border
+      end
+      
+      def height(border)
+        5 + border
+      end
+    end
+  end
+
+  it "should use the custom worker assigned to Pure.worker" do
+    expected = {
+      :area => [:width, :height],
+      :width => [:border],
+      :height => [:border],
+      :border => [],
+    }
+
+    actual = Hash.new
+
+    worker = Class.new do
+      def num_parallel
+        2
+      end
+
+      def define_function_begin(*args)
+      end
+      
+      def define_function_end(*args)
+      end
+
+      define_method :define_function do |spec|
+        lambda { |*a|
+          actual[spec[:name]] = spec[:args]
+        }
+      end
+    end
+
+    @geometry.compute(worker).area
+    actual.should == expected
+  end
+end

data/spec/readme_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+require "jumpstart"
+
+readme = "README.rdoc"
+
+Jumpstart.doc_to_spec(readme, "Synopsis") {
+  |expected_str, actual_str, index|
+
+  expected, actual = [expected_str, actual_str].map { |expr|
+    expr.should match(%r!\A\d+\.\d+\n\d+\.\d+\Z!)
+    expr.split.map { |s| s.to_f }
+  }.map { |pair|
+    {
+      :one_cpu => pair[0],
+      :two_cpu => pair[1],
+    }
+  }
+
+  [expected, actual].each { |result|
+    epsilon = 0.15 + TiamatSpecBase.slow_platform_epsilon
+    (result[:two_cpu]/result[:one_cpu]).should be_close(0.5, epsilon)
+  }
+}
+
+Jumpstart.doc_to_spec(readme, "Adding +require+ Paths to Local Servers")
+
+Jumpstart.doc_to_spec(readme, "About DRbConnError")
+

data/spec/remote_farm_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/tiamat_spec_base'
+
+describe Tiamat::RemoteFarm do
+  before :all do
+    uris = (47055..47060).map { |n|
+      "druby://localhost:#{n}"
+    }
+    @servers = uris.map { |uri|
+      Tiamat::LocalChildServer.new(uri, *Tiamat.compiler.reverse)
+    }
+    @farm = Tiamat::RemoteFarm.new(*uris)
+    Tiamat::Worker.open(@farm)
+  end
+  
+  after :all do
+    Tiamat::Worker.close
+    @farm.close
+    @servers.each { |s| s.close }
+  end
+  
+  it "should be useable by a worker" do
+    pure(Pure::Parser::RubyParser) do
+      def f(x, y)
+        x + y
+      end
+      
+      def x
+        33
+      end
+      
+      def y
+        44
+      end
+    end.compute(Tiamat::Worker).f.should == 77
+  end
+end