jkr 0.0.1

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2010-04-03
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/jkr
+lib/jkr.rb
+lib/jkr/analysis.rb
+lib/jkr/env.rb
+lib/jkr/plan.rb
+lib/jkr/rake.rb
+lib/jkr/trial.rb
+lib/jkr/userutils.rb
+lib/jkr/utils.rb
+test/test_jkr.rb

data/README.txt

@@ -0,0 +1,57 @@
+= jkr
+
+* http://github.com/hayamiz/jkr
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIX
+
+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.

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'jkr' do
+  developer('Yuto HAYAMIZU', 'y.hayamizu@gmail.com')
+
+  # self.rubyforge_name = 'jkrx' # if different than 'jkr'
+end
+
+# vim: syntax=ruby

data/bin/jkr

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'optparse'
+require 'jkr'
+
+def ul(str)
+  "\033[4m#{str}\033[24m"
+end
+
+def identity
+
+end
+
+class JkrCmd
+  def jkr_commands()
+    self.methods.map{|method_sym|
+      if method_sym.to_s =~ /^([a-z_-]+)_cmd$/
+        $~[1]
+      else
+        nil
+      end
+    }.compact
+  end
+
+  def setup_optparser()
+    @optparser = OptionParser.new
+
+    @optparser.banner = <<EOS
+Usage: #{$0} [#{ul('command')} [#{ul('options')}]]
+
+Available commands: #{self.jkr_commands.join(', ')}
+
+'#{$0} help #{ul('command')}' shows detailed usage of #{ul('command')}
+
+EOS
+
+    @options[:directory] = Dir.pwd
+    @optparser.on('-C', '--directory DIR',
+               "Change to directory DIR before reading jkr config files."
+               ) do |directory|
+      @options[:directory] = directory
+    end
+
+    @options[:jkr_directory] = File.join(@options[:directory], "jkr")
+    @optparser.on('-f', '--jkr-directory DIR',
+                  "Jkr specification file."
+                  ) do |jkr_directory|
+      @options[:jkr_directory] = jkr_directory
+    end
+  end
+
+  def parse_args(argv)
+    @optparser.parse!(argv)
+    @options
+  end
+
+  def initialize()
+    @options = Hash.new
+    self.setup_optparser()
+    @jkr_env = Jkr::Env.new(@options[:directory], @options[:jkr_directory])
+  end
+
+  def dispatch(argv)
+    self.parse_args(argv) # argv updated destructively
+    
+    if argv.empty?
+      argv = ["run"]
+    end
+    command = argv.shift
+    unless self.jkr_commands.include?(command)
+      $stderr.puts "No such command: #{command}"
+      puts
+      puts @optparser.help
+      exit 1
+    end
+
+    self.send("#{command}_cmd", argv)
+  end
+
+  ## Command definitions
+
+  def analyze_cmd(argv)
+    argv.each do |arg|
+      Jkr::Analysis.analyze(@jkr_env, arg)
+    end
+  end
+  def analyze_cmd_help()
+     {
+       :summary => "analyze results",
+       :desc => "Usage: #{$0} analyze #{ul('RESULT_ID')} ..."
+     }
+   end
+
+   def list_cmd(argv)
+     puts "Existing plans:"
+     puts
+     plans = @jkr_env.plans.map do |plan_file_path|
+       plan = Jkr::Plan.new(@jkr_env, plan_file_path)
+       [File.basename(plan_file_path, ".plan"), plan.title]
+     end
+     maxlen = plans.map{|plan| plan[0].size}.max
+     plans.each do |plan|
+       printf(" %#{maxlen}s : %s\n", plan[0], plan[1])
+     end
+     puts
+   end
+   def list_cmd_help()
+     {
+       :summary => "list existing plans",
+       :desc => "list existing plans"
+     }
+   end
+
+   def run_cmd(argv)
+     filter = (if argv.empty?
+                 lambda{|x| true}
+               else
+                 lambda do |plan_file_path|
+                   argv.map{|arg|
+                     Regexp.compile(arg)
+                   }.any?{|regex|
+                     File.basename(plan_file_path) =~ regex
+                   }
+                 end
+               end)
+     @jkr_env.plans.each do |plan_file_path|
+       if filter.call(plan_file_path)
+         plan = Jkr::Plan.new(@jkr_env, plan_file_path)
+         Jkr::Trial.run(@jkr_env, plan)
+       end
+     end
+   end
+   def run_cmd_help()
+     {
+       :summary => "run experiments",
+       :desc => ""
+     }
+   end
+
+   def install_cmd(argv)
+     jkr_dir = File.join(@options[:directory], "jkr")
+     result_dir = File.join(@options[:directory], "jkr", "result")
+     plan_dir = File.join(@options[:directory], "jkr", "plan")
+     [jkr_dir, result_dir, plan_dir].each{|dir| FileUtils.mkdir(dir) }
+     File.open(File.join(plan_dir, "sample.plan"), "w") do |file|
+       file.puts <<EOSS
+ # -*- mode: ruby -*-
+
+ title "Sample experiment plan"
+ description <<EOS
+ This is a sample experiment plan specification file.
+ EOS
+
+ # Discard this file after the experiments conducted.
+ discard_on_finish
+
+ def_experiment_plan do |p|
+   # 'p.variable' for variables
+   # 'p.param' for static parameters
+
+   p.variable :num_xxx => 1..10
+   p.param :use_yyy => false
+
+   if p.param[:use_yyy]
+     p.param[:yyy_zzz] = "foo"
+   else
+     p.param[:yyy_zzz] = "bar"
+   end
+ end
+
+ def_execution do |params|
+   puts "hello world, #\{params.num_xxx\}, #\{params[:num_xxx]\}"
+ end
+EOSS
+     end
+   end
+   def install_cmd_help()
+     {
+       :summary => "install jkr skelton setting files",
+       :desc => ""
+     }
+   end
+
+   def help_cmd(argv)
+     case argv[0]
+     when /^commands/
+       commands = self.jkr_commands
+       puts "Available commands:"
+       max_len = commands.map(&:size).max
+       commands.each do |command|
+         help = self.send("#{command}_cmd_help")
+         printf "  %#{max_len}s : #{help[:summary]}\n", command
+       end
+       puts
+     else
+       commands = argv.select{|arg| self.jkr_commands.include?(arg)}
+       if commands.size > 0
+         commands.each do |cmd|
+           help = self.send("#{cmd}_cmd_help")
+           puts("== help: #{cmd} ==\n#{help[:summary]}\n\n#{help[:desc]}\n")
+        end
+      else
+        puts @optparser.help
+      end
+    end
+  end
+  def help_cmd_help()
+    {
+      :summary => "show helps",
+      :desc => ""
+    }
+  end
+
+end
+
+def main(argv)
+  JkrCmd.new.dispatch(argv)
+end
+
+if __FILE__ == $0
+  main(ARGV.dup)
+end
+

data/lib/jkr/analysis.rb

@@ -0,0 +1,27 @@
+
+class Jkr
+  class Analysis
+    def self.analyze(env, resultset_num)
+      resultset_num = sprintf "%03d", resultset_num.to_i
+      resultset_dir = Dir.glob(File.join(env.jkr_result_dir, resultset_num)+"*")
+      if resultset_dir.size != 1
+        raise RuntimeError.new "cannot specify resultset dir (#{resultset_dir.join(" ")})"
+      end
+      resultset_dir = resultset_dir.first
+
+      plan_files = Dir.glob(File.join(resultset_dir, "*.plan"))
+      if plan_files.size == 0
+        raise RuntimeError.new "cannot find plan file"
+      elsif plan_files.size > 1
+        raise RuntimeError.new "there are two or more plan files"
+      end
+      plan_file_path = plan_files.first
+
+      plan = Jkr::Plan.new(env, plan_file_path)
+
+      Jkr::AnalysisUtils.define_analysis_utils(resultset_dir, plan)
+      plan.analysis.call(plan)
+      Jkr::AnalysisUtils.undef_analysis_utils(plan)
+    end
+  end
+end

data/lib/jkr/env.rb

@@ -0,0 +1,38 @@
+
+require 'fileutils'
+
+class Jkr
+  class Env
+    attr_reader :jkr_dir
+    attr_reader :working_dir
+    attr_reader :jkr_result_dir
+    attr_reader :jkr_plan_dir
+    attr_reader :jkr_script_dir
+    
+    PLAN_DIR = "plan"
+    RESULT_DIR = "result"
+    SCRIPT_DIR = "script"
+
+    def initialize(working_dir = Dir.pwd, jkr_dir = File.join(Dir.pwd, "jkr"))
+      @jkr_dir = jkr_dir
+      @working_dir = working_dir
+      @jkr_plan_dir = File.join(@jkr_dir, PLAN_DIR)
+      @jkr_result_dir = File.join(@jkr_dir, RESULT_DIR)
+      @jkr_script_dir = File.join(@jkr_dir, SCRIPT_DIR)
+      
+      [@jkr_dir, @jkr_result_dir, @jkr_plan_dir, @jkr_script_dir].each do |dir_path|
+        unless Dir.exists?(dir_path)
+          FileUtils.mkdir_p(dir_path)
+        end
+      end
+    end
+
+    def next_plan
+      self.plans.first
+    end
+
+    def plans
+      Dir.glob("#{@jkr_plan_dir}#{File::SEPARATOR}*.plan").sort
+    end
+  end
+end

data/lib/jkr/plan.rb

@@ -0,0 +1,134 @@
+
+require 'jkr/utils'
+require 'tempfile'
+
+class Jkr
+  class Plan
+    attr_accessor :title
+    attr_accessor :desc
+    
+    attr_accessor :params
+    attr_accessor :vars
+  
+    # Proc's
+    attr_accessor :prep
+    attr_accessor :cleanup
+    attr_accessor :routine
+    attr_accessor :analysis
+
+    attr_accessor :src
+
+    attr_reader :file_path
+    attr_reader :jkr_env
+
+    def initialize(jkr_env, plan_file_path = nil)
+      @jkr_env = jkr_env
+      @file_path = plan_file_path || jkr_env.next_plan
+      return nil unless @file_path
+
+      @title = "no title"
+      @desc = "no desc"
+
+      @params = {}
+      @vars = {}
+      @routine = lambda do |_|
+        raise NotImplementedError.new("A routine of experiment '#{@title}' is not implemented")
+      end
+      @prep = lambda do |_|
+        raise NotImplementedError.new("A prep of experiment '#{@title}' is not implemented")
+      end
+      @cleanup = lambda do |_|
+        raise NotImplementedError.new("A cleanup of experiment '#{@title}' is not implemented")
+      end
+
+      @src = nil
+
+      PlanLoader.load_plan(self)
+    end
+
+
+    class PlanLoader
+      class PlanParams
+        attr_reader :vars
+        attr_reader :params
+
+        def initialize()
+          @vars = {}
+          @params = {}
+        end
+        
+        def [](key)
+          @params[key]
+        end
+
+        def []=(key, val)
+          @params[key] = val
+        end
+      end
+      
+      include Jkr::PlanUtils
+
+      def initialize(plan)
+        @plan = plan
+        @params = nil
+      end
+      
+      def self.load_plan(plan)
+        plan_loader = self.new(plan)
+        plan.src = File.open(plan.file_path, "r").read
+        plan_loader.instance_eval(plan.src, plan.file_path, 1)
+        plan
+      end
+      
+      ## Functions for describing plans in '.plan' files below
+      def plan
+        @plan
+      end
+
+      def title(plan_title)
+        @plan.title = plan_title.to_s
+      end
+      
+      def description(plan_desc)
+        @plan.desc = plan_desc.to_s
+      end
+      
+      def def_parameters(&proc)
+        @params = PlanParams.new
+        proc.call()
+        @plan.params.merge!(@params.params)
+        @plan.vars.merge!(@params.vars)
+      end
+      
+      def def_routine(&proc)
+        @plan.routine = proc
+      end
+      def def_prep(&proc)
+        @plan.prep = proc
+      end
+      def def_cleanup(&proc)
+        @plan.cleanup = proc
+      end
+      def def_analysis(&proc)
+        @plan.analysis = proc
+      end
+
+      def parameter(arg = nil)
+        if arg.is_a? Hash
+          # set param
+          @params.params.merge!(arg)
+        else
+          @params
+        end
+      end
+
+      def variable(arg = nil)
+        if arg.is_a? Hash
+          @params.vars.merge!(arg)
+        else
+          @params
+        end
+      end
+    end
+  end
+end

data/lib/jkr/rake.rb

@@ -0,0 +1,18 @@
+require 'rake'
+
+desc "Preparation before experiments"
+task :before
+
+desc "Running experiments"
+task :run => FileList['jkr/queue/*.plan'] do
+  
+end
+
+
+desc "Wrapping-up data after experiments"
+task :after
+
+task :run => [:before]
+task :after => [:run]
+
+task :default => [:after]

data/lib/jkr/trial.rb

@@ -0,0 +1,54 @@
+
+require 'fileutils'
+require 'jkr/utils'
+
+class Jkr
+  class Trial
+    attr_reader :params
+    
+    def self.make_trials(resultset_dir, plan)
+      var_combs = [{}]
+      plan.vars.each do |key, vals|
+        var_combs = vals.map {|val|
+          var_combs.map do |var_comb|
+            var_comb.dup.merge(key => val)
+          end
+        }.flatten
+      end
+
+      var_combs.map do |var_comb|
+        result_dir = Utils.reserve_next_dir(resultset_dir)
+        Trial.new(result_dir, plan, plan.params.merge(var_comb))
+      end
+    end
+
+    def self.run(env, plan)
+      plan_suffix = File.basename(plan.file_path, ".plan")
+      resultset_dir = Utils.reserve_next_dir(env.jkr_result_dir, plan_suffix)
+      trials = self.make_trials(resultset_dir, plan)
+
+      FileUtils.copy_file(plan.file_path,
+                          File.join(resultset_dir, File.basename(plan.file_path)))
+      params = plan.params.merge(plan.vars)
+      plan.freeze
+      plan.prep.call(plan)
+      trials.each do |trial|
+        trial.run
+      end
+      plan.cleanup.call(plan)
+    end
+
+    def initialize(result_dir, plan, params)
+      @result_dir = result_dir
+      @plan = plan
+      @params = params
+    end
+    private :initialize
+
+    def run()
+      Jkr::TrialUtils.define_routine_utils(@result_dir, @plan, @params)
+      @plan.routine.call(@plan, @params)
+      Jkr::TrialUtils.undef_routine_utils(@plan)
+    end
+  end
+end

data/lib/jkr/userutils.rb

@@ -0,0 +1,156 @@
+
+require 'kconv'
+require 'time'
+require 'date'
+require 'csv'
+
+class Jkr
+  class SysUtils
+    def self.cpu_cores()
+      self.num_cores()
+    end
+
+    def self.num_cores()
+      `grep "core id" /proc/cpuinfo|wc -l`.to_i
+    end
+
+    def self.num_processors()
+      `grep "physical id" /proc/cpuinfo|sort|uniq|wc -l`.to_i
+    end
+  end
+
+  class DataUtils
+    BLOCKSIZE = 268435456 # 256MB
+    def self.read_blockseq(io_or_filepath, separator = "\n\n", &proc)
+      file = io_or_filepath
+      if ! io_or_filepath.is_a? IO
+        file = File.open(io_or_filepath, "r")
+      end
+      proc ||= lambda do |blockstr|
+        unless blockstr.strip.empty?
+          blockstr.split
+        else
+          nil
+        end
+      end
+
+      result = []
+      bufstr = ""
+      while ! file.eof?
+        bufstr += file.read(BLOCKSIZE)
+        blocks = bufstr.split(separator)
+        bufstr = blocks.pop
+        blocks.each do |block|
+          ret = proc.call(block)
+          result.push(ret) if ret
+        end
+      end
+      ret = proc.call(bufstr)
+      result.push(ret) if ret
+
+      result
+    end
+
+    def self.read_rowseq(io_or_filepath, &block)
+      self.read_blockseq(io_or_filepath, "\n", &block)
+    end
+
+    def self.read_mpstat_avg(io_or_filepath)
+      self.read_blockseq(io_or_filepath){|blockstr|
+        if blockstr =~ /^Average:/
+          result = Hash.new
+          rows = blockstr.lines.map(&:strip)
+          header = rows.shift.split
+          header.shift
+          result[:labels] = header
+          result[:data] = rows.map { |row|
+            vals = row.split
+            vals.shift
+            if vals.size != result[:labels].size
+              raise RuntimeError.new("Invalid mpstat data")
+            end
+            vals.map{|val|
+              begin
+                Float(val)
+              rescue ArgumentError
+                val
+              end
+            }
+          }
+          result
+        end
+      }.last
+    end
+
+    def self.read_mpstat(io_or_filepath)
+      hostname = `hostname`.strip
+      
+      date = nil
+      last_time = nil
+      self.read_blockseq(io_or_filepath) do |blockstr|
+        if blockstr =~ /^Linux/ && blockstr =~ /(\d{2})\/(\d{2})\/(\d{2})$/
+          # the first line
+          y = $~[3].to_i; m = $~[1].to_i; d = $~[2].to_i
+          date = Date.new(2000 + y, m, d)
+          next
+        else
+          # it's a data block, maybe
+          unless date
+            $stderr.puts "Cannot find date in your mpstat log. It was assumed today."
+            date = Date.today
+          end
+
+          result = Hash.new
+          rows = blockstr.lines.map(&:strip)
+          header = rows.shift.split
+          next if header.shift =~ /Average/
+          result[:labels] = header
+          time = nil
+          result[:data] = rows.map { |row|
+            vals = row.split
+            wallclock = vals.shift
+            unless time
+              unless wallclock =~ /(\d{2}):(\d{2}):(\d{2})/
+                raise RuntimeError.new("Cannot extract wallclock time from mpstat data")
+              end
+              time = Time.local(date.year, date.month, date.day,
+                                $~[1].to_i, $~[2].to_i, $~[3].to_i)
+              if last_time && time < last_time
+                date += 1
+                time = Time.local(date.year, date.month, date.day,
+                                  $~[1].to_i, $~[2].to_i, $~[3].to_i)
+              end
+              result[:time] = time
+              last_time = time
+            end
+            if vals.size != result[:labels].size
+              raise RuntimeError.new("Invalid mpstat data")
+            end
+            vals.map{|val|
+              begin
+                Float(val)
+              rescue ArgumentError
+                val
+              end
+            }
+          }
+          result
+        end
+      end
+    end
+
+    def self.read_csv(io_or_filepath, fs = ",", rs = nil, &proc)
+      if io_or_filepath.is_a?(String) && File.exists?(io_or_filepath)
+        io_or_filepath = File.open(io_or_filepath, "r")
+      end
+
+      result = []
+      proc ||= lambda{|row| row}
+      CSV.parse(io_or_filepath).each do |row|
+        ret = proc.call(row)
+        result.push ret if ret
+      end
+      result
+    end
+  end
+end

data/lib/jkr/utils.rb

@@ -0,0 +1,470 @@
+
+require 'fileutils'
+require 'popen4'
+require 'thread'
+
+require 'jkr/userutils'
+
+class Barrier
+  def initialize(num)
+    @mux = Mutex.new
+    @cond = ConditionVariable.new
+
+    @num = num
+    @cur_num = num
+  end
+
+  def wait()
+    @mux.lock
+    @cur_num -= 1
+    if @cur_num == 0
+      @cur_num = @num
+      @cond.broadcast
+    else
+      @cond.wait(@mux)
+    end
+    @mux.unlock
+  end
+end
+
+class Jkr
+  class Utils
+    def self.reserve_next_dir(dir, suffix = "")
+      dirs = Dir.glob("#{dir}#{File::SEPARATOR}???*")
+      max_num = -1
+      dirs.each do |dir|
+        if /\A[0-9]+/ =~ File.basename(dir)
+          max_num = [$~[0].to_i, max_num].max
+        end
+      end
+      
+      num = max_num + 1
+      dir = "#{dir}#{File::SEPARATOR}" + sprintf("%03d%s", num, suffix)
+      FileUtils.mkdir(dir)
+      dir
+    end
+  end
+
+  module PlanUtils
+    # info about processes spawned by me
+    def procdb
+      @procdb ||= Hash.new
+    end
+    def procdb_spawn(pid, command, owner_thread)
+      @procdb_mutex.synchronize do
+        self.procdb[pid] = {
+          :pid => pid,
+          :command => command,
+          :thread => owner_thread,
+          :status => nil
+        }
+      end
+    end
+    def procdb_waitpid(pid)
+      t = nil
+      @procdb_mutex.synchronize do
+        if self.procdb[pid]
+          t = self.procdb[pid][:thread]
+        end
+      end
+      t.join if t
+    end
+    def procdb_resetpid(pid)
+      @procdb_mutex.synchronize do
+        if self.procdb[pid]
+          self.procdb.delete(pid)
+        end
+      end
+    end
+    def procdb_update_status(pid, status)
+      @procdb_mutex.synchronize do
+        if self.procdb[pid]
+          self.procdb[pid][:status] = status
+        end
+      end
+    end
+    def procdb_get(pid)
+      @procdb_mutex.synchronize do
+        self.procdb[pid]
+      end
+    end
+    def procdb_get_status(pid)
+      proc = self.procdb_get(pid)
+      proc && proc[:status]
+    end
+    def procdb_get_command(pid)
+      proc = self.procdb_get(pid)
+      proc && proc[:command]
+    end
+
+    def cmd(*args)
+      @procdb_mutex ||= Mutex.new
+      options = (if args.last.is_a? Hash
+                   args.pop
+                 else
+                   {}
+                 end)
+      options = {
+        :wait   => true,
+        :timeout => 0,
+        :raise_failure => true,
+        :stdin  => nil,
+        :stdout => [$stdout],
+        :stderr => [$stderr]
+      }.merge(options)
+
+      if options[:timeout] > 0 && ! options[:wait]
+        raise ArgumentError.new("cmd: 'wait' must be true if 'timeout' specified.")
+      end
+
+      start_time = Time.now
+      pid = nil
+      status = nil
+      args.flatten!
+      args.map!(&:to_s)
+      command = args.join(" ")
+      barrier = Barrier.new(2)
+      process_exited = false
+
+      t = Thread.new {
+        pipers = []
+        status = POpen4::popen4(command){|p_stdout, p_stderr, p_stdin, p_id|
+          pid = p_id
+          barrier.wait
+          stdouts = if options[:stdout].is_a? Array
+                      options[:stdout]
+                    else
+                      [options[:stdout]]
+                    end
+          stderrs = if options[:stderr].is_a? Array
+                      options[:stderr]
+                    else
+                      [options[:stderr]]
+                    end
+          pipers << Thread.new{
+            target = p_stdout
+            timeout_count = 0
+            while true
+              begin
+                if (ready = IO.select([target], [], [], 1))
+                  ready.first.each do |fd|
+                    buf = fd.read_nonblock(4096)
+                    stdouts.each{|out| out.print buf}
+                  end
+                  Thread.exit if target.eof?
+                else
+                  if process_exited
+                    timeout_count += 1
+                    if timeout_count > 5
+                      target.close_read
+                      Thread.exit
+                    end
+                  end
+                end
+              rescue IOError => err
+                if target.closed?
+                  Thread.exit
+                end
+              end
+            end
+          }
+          pipers << Thread.new{
+            target = p_stderr
+            timeout_count = 0
+            while true
+              begin
+                if (ready = IO.select([target], [], [], 1))
+                  ready.first.each do |fd|
+                    buf = fd.read_nonblock(4096)
+                    stderrs.each{|out| out.print buf}
+                  end
+                  Thread.exit if target.eof?
+                else
+                  if process_exited
+                    timeout_count += 1
+                    if timeout_count > 5
+                      target.close_read
+                      Thread.exit
+                    end
+                  end
+                end
+              rescue IOError => err
+                if target.closed?
+                  Thread.exit
+                end
+              end
+            end
+          }
+          if options[:stdin]
+            pipers << Thread.new{
+            target = options[:stdin]
+            timeout_count = 0
+            while true
+              begin
+                if (ready = IO.select([target], [], [], 1))
+                  ready.first.each do |fd|
+                      buf = fd.read_nonblock(4096)
+                      p_stdin.print buf
+                    end
+                else
+                  if process_exited
+                    timeout_count += 1
+                    if timeout_count > 5
+                      p_stdin.close_write
+                      Thread.exit
+                    end
+                  end
+                end
+              rescue IOError => err
+                if target.closed?
+                  Thread.exit
+                end
+              end
+            end
+          }
+          end
+        }
+        pipers.each{|t| t.join}
+        raise ArgumentError.new("Invalid command: #{command}") unless status
+        procdb_update_status(pid, status)
+      }
+      barrier.wait
+      procdb_spawn(pid, command, t)
+      timekeeper = nil
+
+      killed = false
+      timekeeper = nil
+      if options[:timeout] > 0
+        timekeeper = Thread.new do
+          sleep(options[:timeout])
+          begin
+            Process.kill(:INT, pid)
+            killed = true
+          rescue Errno::ESRCH # No such process
+          end
+        end
+      end
+      if options[:wait]
+        timekeeper.join if timekeeper
+        t.join
+        if (! killed) && options[:raise_failure] && status.exitstatus != 0
+          raise RuntimeError.new("'#{command}' failed.")
+        end
+      end
+      while ! pid
+        sleep 0.001 # do nothing
+      end
+
+      pid
+    end
+
+    def with_process2(*args)
+      options = (if args.last.is_a? Hash
+                   args.pop
+                 else
+                   {}
+                 end )
+      options = {
+        :kill_on_exit => false
+      }.merge(options)
+      
+      command = args.flatten.map(&:to_s).join(" ")
+      pid = Process.spawn(command)
+
+      err = nil
+      begin
+        yield
+      rescue Exception => e
+        err = e
+      end
+
+      if options[:kill_on_exit]
+        Process.kill(:INT, pid)
+      else
+        if err
+          begin
+            Process.kill(:TERM, pid)
+          rescue Exception
+          end
+        else
+          begin
+            status = Process.waitpid(pid)
+            p status
+          rescue Errno::ESRCH
+          end
+        end
+      end
+      raise err if err
+    end
+
+    def with_process(*args)
+      options = (if args.last.is_a? Hash
+                   args.pop
+                 else
+                   {}
+                 end )
+      options = {
+        :kill_on_exit => false
+      }.merge(options)
+      options[:wait] = false
+
+      args.push(options)
+      pid = cmd(*args)
+
+      err = nil
+      begin
+        yield
+      rescue Exception => e
+        err = e
+      end
+
+      if options[:kill_on_exit]
+        Process.kill(:INT, pid)
+      else
+        if err
+          begin
+            Process.kill(:TERM, pid)
+          rescue Exception
+          end
+        else
+          procdb_waitpid(pid)
+          status = procdb_get_status(pid)
+          unless status && status.exitstatus == 0
+            command = procdb_get_command(pid) || "Unknown command"
+            raise RuntimeError.new("'#{command}' failed.")
+          end
+          procdb_resetpid(pid)
+        end
+      end
+
+      raise err if err
+    end
+
+    def use_script(name)
+      name = name.to_s
+      name = name + ".rb" unless name =~ /\.rb$/
+      dir = @plan.jkr_env.jkr_script_dir
+      path = File.join(dir, name)
+      script = File.open(path, "r").read
+      self.instance_eval(script, path, 1)
+      true
+    end
+  end
+
+  class TrialUtils
+    def self.undef_routine_utils(plan)
+      plan.routine.binding.eval <<EOS
+undef result_file
+undef result_file_name
+undef touch_result_file
+undef with_result_file
+EOS
+    end
+
+    def self.define_routine_utils(result_dir, plan, params)
+      line = __LINE__; src = <<EOS
+def result_file_name(basename)
+  File.join(#{result_dir.inspect}, basename)
+end
+
+def result_file(basename, mode = "a+")
+  path = result_file_name(basename)
+  File.open(path, mode)
+end
+
+def touch_result_file(basename, options = {})
+  path = result_file_name(basename)
+  FileUtils.touch(path, options)
+  path
+end
+
+def with_result_file(basename, mode = "a+")
+  file = result_file(basename, mode)
+  err = nil
+  begin
+    yield(file)
+  rescue Exception => e
+    err = e
+  end
+  file.close
+  raise err if err
+  file.path
+end
+EOS
+      plan.routine.binding.eval(src, __FILE__, line)
+    end
+  end
+
+  class AnalysisUtils
+    def self.undef_analysis_utils(plan)
+      plan.analysis.binding.eval <<EOS
+undef resultset
+undef result_file
+undef result_file_name
+undef with_result_file
+undef common_file
+undef common_file_name
+undef with_common_file
+EOS
+    end
+
+    def self.define_analysis_utils(resultset_dir, plan)
+      line = __LINE__; src = <<EOS
+def resultset()
+  dirs = Dir.glob(File.join(#{resultset_dir.inspect}, "*"))
+  dirs.map{|dir| File.basename dir}.select{|basename|
+    basename =~ /\\A\\d{3,}\\Z/
+  }
+end
+
+def result_file_name(num, basename)
+  if num.is_a? Integer
+    num = sprintf "%03d", num
+  end
+  File.join(#{resultset_dir.inspect}, num, basename)
+end
+
+def result_file(num, basename, mode = "r")
+  path = result_file_name(num, basename)
+  File.open(path, mode)
+end
+
+def common_file_name(basename)
+  File.join(#{resultset_dir.inspect}, basename)
+end
+
+def common_file(basename, mode = "r")
+  path = common_file_name(basename)
+  File.open(path, mode)
+end
+
+def with_common_file(basename, mode = "r")
+  file = common_file(basename, mode)
+  err = nil
+  begin
+    yield(file)
+  rescue Exception => e
+    err = e
+  end
+  file.close
+  raise err if err
+  file.path
+end
+
+def with_result_file(basename, mode = "r")
+  file = result_file(basename, mode)
+  err = nil
+  begin
+    yield(file)
+  rescue Exception => e
+    err = e
+  end
+  file.close
+  raise err if err
+  file.path
+end
+EOS
+      plan.routine.binding.eval(src, __FILE__, line)
+    end
+  end
+end

data/lib/jkr.rb

@@ -0,0 +1,9 @@
+
+require 'jkr/env'
+require 'jkr/plan'
+require 'jkr/trial'
+require 'jkr/analysis'
+
+class Jkr
+  VERSION = '0.0.1'
+end

data/test/test_jkr.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "jkr"
+
+class TestJkr < Test::Unit::TestCase
+  def test_sanity
+    flunk "write tests or I will kneecap you"
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: jkr
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Yuto HAYAMIZU
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-17 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+    version: 
+description: FIX (describe your package)
+email: 
+- y.hayamizu@gmail.com
+executables: 
+- jkr
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/jkr
+- lib/jkr.rb
+- lib/jkr/analysis.rb
+- lib/jkr/env.rb
+- lib/jkr/plan.rb
+- lib/jkr/rake.rb
+- lib/jkr/trial.rb
+- lib/jkr/userutils.rb
+- lib/jkr/utils.rb
+- test/test_jkr.rb
+has_rdoc: true
+homepage: http://github.com/hayamiz/jkr
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: jkr
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: FIX (describe your package)
+test_files: 
+- test/test_jkr.rb