tiamat 0.1.0

data/install.rb

@@ -0,0 +1,2 @@
+load './devel/jumpstart.rb'
+Jumpstart::SimpleInstaller.new.run

data/lib/tiamat.rb

@@ -0,0 +1,43 @@
+# 
+# Copyright (c) 2009 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 'rbconfig'
+require 'drb'
+
+require 'pure'
+
+require 'tiamat/error'
+require 'tiamat/version'
+require 'tiamat/util'
+require 'tiamat/connector'
+require 'tiamat/server'
+require 'tiamat/farm'
+require 'tiamat/worker'
+require 'tiamat/remote_farm'
+require 'tiamat/remote_worker'
+require 'tiamat/child_server'
+require 'tiamat/local_child_server'
+require 'tiamat/local_child_farm'
+require 'tiamat/local_child_worker'
+require 'tiamat/tiamat'

data/lib/tiamat/autoconfig.rb

@@ -0,0 +1,8 @@
+#
+# Upon <tt>require 'tiamat/autoconfig'</tt>, a search will ensue to
+# find the optimal (Pure.parser, Tiamat.compiler) pair.
+#
+# There is currently only one available implementation:
+# (RubyParser, Ruby2Ruby).
+#
+require 'tiamat/config/ruby_parser'

data/lib/tiamat/child_server.rb

@@ -0,0 +1,21 @@
+
+module Tiamat
+  class ChildServer < Server
+    def initialize(uri, *args)
+      @thread = Thread.new {
+        launch(uri, *args)
+      }
+      super(uri)
+    end
+    
+    def close
+      begin
+        @drb_object.close
+      rescue DRb::DRbConnError
+        nil # rcov workaround
+      end
+      super
+      @thread.join
+    end
+  end
+end

data/lib/tiamat/config/ruby_parser.rb

@@ -0,0 +1,6 @@
+
+require 'tiamat'
+require 'pure/parser/ruby_parser'
+
+Pure.parser = Pure::Parser::RubyParser
+Tiamat.compiler = Pure.parser.compiler

data/lib/tiamat/connector.rb

@@ -0,0 +1,23 @@
+
+module Tiamat
+  module Connector
+    module_function
+
+    def connect(wait_interval, timeout)
+      begin
+        yield
+      rescue DRb::DRbConnError
+        start = Time.now
+        begin
+          Kernel.sleep(wait_interval)
+          yield
+        rescue DRb::DRbConnError
+          if Time.now - start > timeout
+            raise
+          end
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/tiamat/error.rb

@@ -0,0 +1,24 @@
+
+module Tiamat
+  class Error < StandardError
+  end
+
+  class AlreadyOpenError < Error
+    def initialize(object)
+      @object = object
+      super("open called on object which is already open: #{@object.inspect}")
+    end
+
+    attr_reader :object
+  end
+
+  class RunRubyError < Error
+    def initialize(command, status)
+      @command, @status = command, status
+      command_str = command.map { |a| "'#{a}'" }.join(", ")
+      super("system(#{command_str}) failed with status #{@status}")
+    end
+
+    attr_reader :command, :status
+  end
+end

data/lib/tiamat/farm.rb

@@ -0,0 +1,32 @@
+
+module Tiamat
+  class Farm
+    def initialize(servers)
+      @servers = servers
+      @available = Queue.new
+
+      @servers.each { |server|
+        @available.push(server)
+      }
+    end
+
+    def num_servers
+      @servers.size
+    end
+
+    def lend_server
+      server = @available.pop
+      begin
+        yield server
+      ensure
+        @available.push(server)
+      end
+    end
+
+    def close
+      @servers.each { |server|
+        server.close
+      }
+    end
+  end
+end

data/lib/tiamat/local_child_farm.rb

@@ -0,0 +1,23 @@
+
+module Tiamat
+  class LocalChildFarm < Farm
+    def initialize(num_servers, *args)
+      base_uri = self.class.base_uri
+      port_begin = self.class.port_begin
+      servers = (0...num_servers).map { |n|
+        LocalChildServer.new("#{base_uri}:#{port_begin + n}", *args)
+      }
+      super(servers)
+    end
+    
+    class << self
+      def base_uri
+        "druby://localhost"
+      end
+
+      def port_begin
+        48727
+      end
+    end
+  end
+end

data/lib/tiamat/local_child_server.rb

@@ -0,0 +1,25 @@
+
+module Tiamat
+  class LocalChildServer < ChildServer
+    def launch(uri, compiler_name, *requires)
+      args = [compiler_name] + requires
+      Util.run_ruby(self.class.server_path, uri, *args)
+    end
+
+    class << self
+      def server_basename
+        "tiamat-server"
+      end
+
+      def server_path
+        if server = Util.find_executable(server_basename)
+          server
+        else
+          File.expand_path(
+            File.dirname(__FILE__) + "/../../bin/" + server_basename
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tiamat/local_child_worker.rb

@@ -0,0 +1,11 @@
+
+module Tiamat
+  class LocalChildWorker < Worker
+    class << self
+      def open(num_servers, *args, &block)
+        farm = LocalChildFarm.new(num_servers, *args)
+        super(farm, &block)
+      end
+    end
+  end
+end

data/lib/tiamat/remote_farm.rb

@@ -0,0 +1,11 @@
+
+module Tiamat
+  class RemoteFarm < Farm
+    def initialize(*uris)
+      servers = uris.map { |uri|
+        Server.new(uri)
+      }
+      super(servers)
+    end
+  end
+end

data/lib/tiamat/remote_worker.rb

@@ -0,0 +1,10 @@
+
+module Tiamat
+  class RemoteWorker < Worker
+    class << self
+      def open(*uris, &block)
+        super(RemoteFarm.new(*uris), &block)
+      end
+    end
+  end
+end

data/lib/tiamat/server.rb

@@ -0,0 +1,42 @@
+
+module Tiamat
+  class Server
+    include Connector
+
+    def initialize(uri)
+      @uri = uri
+      @drb_object = DRbObject.new_with_uri(uri)
+      connect {
+        @drb_object.ping
+      }
+    end
+
+    attr_reader :uri
+
+    def close
+    end
+
+    def evaluate_function(*args)
+      @drb_object.evaluate_function(*args)
+    end
+
+    private
+
+    def connect(&block)
+      super(self.class.wait_interval, self.class.timeout, &block)
+    end
+
+    class << self
+      attr_writer :wait_interval
+      attr_writer :timeout
+
+      def wait_interval
+        @wait_interval ||= 0.02
+      end
+
+      def timeout
+        @timeout ||= 3
+      end
+    end
+  end
+end

data/lib/tiamat/tiamat.rb

@@ -0,0 +1,49 @@
+
+module Tiamat
+  class << self
+    #
+    # Launch _num_parallel_ local Ruby interpreters.
+    #
+    # If a block is given:
+    # * Pure.worker is replaced for the duration of the block.
+    # * The return value is the block result.
+    # * The interpreters are stopped when the block finishes.
+    #
+    # If no block is given, an opened worker is returned. You are
+    # responsible for closing it.
+    #
+    def open_local(num_parallel, *requires, &block)
+      args = [num_parallel] + Tiamat.compiler.reverse + requires
+      open_worker(LocalChildWorker, *args, &block)
+    end
+
+    #
+    # Connect to the already-running tiamat servers given by the URIs,
+    # e.g. druby://192.168.4.1:27272.
+    #
+    # If a block is given:
+    # * Pure.worker is replaced for the duration of the block.
+    # * The return value is the block result.
+    #
+    # If no block is given, an opened worker is returned. You are
+    # responsible for closing it.
+    #
+    def open_remote(*uris, &block)
+      open_worker(RemoteWorker, *uris, &block)
+    end
+    
+    attr_accessor :compiler
+
+    private
+    
+    def open_worker(worker, *args, &block)
+      result = worker.open(*args, &block)
+      if block
+        result
+      else
+        worker
+      end
+    end
+  end
+  @compiler = nil
+end

data/lib/tiamat/tiamat_server.rb

@@ -0,0 +1,48 @@
+#
+# This is the core of bin/tiamat-server, the code which runs on the
+# remote Ruby interpreter.
+#
+# This file is not required by the top-level tiamat.rb.
+#
+
+module Tiamat
+  class TiamatServer
+    FINISH = Queue.new
+
+    def initialize(compiler_name, *requires)
+      @compiler_name = compiler_name
+
+      requires.each { |path| require path }
+
+      @compiler = compiler_name.split("::").inject(Object) { |acc, name|
+        acc.const_get(name)
+      }.new
+
+      nil # rcov workaround
+    end
+
+    attr_reader :compiler_name
+
+    def evaluate_function(spec, *args)
+      @compiler.evaluate_function(spec, *args)
+    end
+
+    def ping
+    end
+
+    def close
+      FINISH.push nil
+    end
+
+    class << self
+      def run(uri, *args)
+        DRb.start_service(uri, new(*args))
+        begin
+          FINISH.pop
+        ensure
+          DRb.stop_service
+        end
+      end
+    end
+  end
+end

data/lib/tiamat/util.rb

@@ -0,0 +1,37 @@
+
+module Tiamat
+  module Util
+    module_function
+
+    def ruby_executable
+      require 'rbconfig'
+      name = File.join(
+        Config::CONFIG["bindir"],
+        Config::CONFIG["RUBY_INSTALL_NAME"]
+      )
+      if Config::CONFIG["host"] =~ %r!(mswin|cygwin|mingw)! and
+          File.basename(name) !~ %r!\.(exe|com|bat|cmd)\Z!i
+        name + Config::CONFIG["EXEEXT"]
+      else
+        name
+      end
+    end
+
+    def run_ruby(*args)
+      cmd = [ruby_executable, *args]
+      unless system(*cmd)
+        raise RunRubyError.new(cmd, $?.exitstatus)
+      end
+    end
+
+    def find_executable(basename)
+      ENV["PATH"].split(File::PATH_SEPARATOR).each { |path|
+        candidate = path + "/" + basename
+        if File.exist?(candidate)
+          return candidate
+        end
+      }
+      nil
+    end
+  end
+end