jkr 0.0.1 → 0.1.0

data/Rakefile

@@ -1,12 +1,11 @@
 # -*- ruby -*-
 
 require 'rubygems'
-require 'hoe'
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
 
-Hoe.spec 'jkr' do
-  developer('Yuto HAYAMIZU', 'y.hayamizu@gmail.com')
+RSpec::Core::RakeTask.new("spec")
 
-  # self.rubyforge_name = 'jkrx' # if different than 'jkr'
-end
+task :default => [:spec]
 
 # vim: syntax=ruby

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "jkr"
+
+require "pry"
+Pry.start

data/etc/example.plan

@@ -0,0 +1,32 @@
+# -*- mode: ruby -*-
+
+title "example"
+description "this is an example."
+short_desc ""
+
+def_parameters do
+  constant :foo => 123
+  variable :trial_no => [1,2,3]
+end
+
+def_prep do |plan|
+end
+
+# This is optional routine for presenting estimated execution time for users.
+# Return estimated execution time in seconds.
+exec_time_estimate do |plan|
+  # 30 seconds for each trial
+  30 * plan.vars[:trial_no].size
+end
+
+def_routine do |plan, params|
+  # store various information with metastore
+  # metastore data is saved in "metastore.msh" with Marshal.dump for each trial
+  plan.metastore[:foo] = "bar"
+end
+
+def_cleanup do |plan|
+end
+
+def_analysis do |plan|
+end

data/etc/zsh-comp.sh

@@ -0,0 +1,82 @@
+#compdef jkr
+
+# Subcommand completion function
+__jkr-execute-cmd() {
+    local curcontext context state line
+    local env_dir
+
+    integer ret=1
+    _arguments \
+        -C -S \
+        '--debug[enable debug mode]' \
+        {-C,--directory}':Jkr directory:_directories' \
+        '(-): :->jkr_plans' \
+        && return
+
+    case $state in
+        (jkr_plans)
+            if [[ -n ${opt_args[(I)-C|--directory]} ]]; then
+                env_dir=${opt_args[${opt_args[(I)-C|--directory]}]}
+            else
+                env_dir=""
+            fi
+
+            __jkr_plans $env_dir && ret=0
+            ;;
+    esac
+    return $ret
+}
+
+__jkr-list-cmd() {
+    _arguments \
+        -C -S \
+        '--debug[enable debug mode]' \
+        {-C,--directory}':Jkr directory:_directories' \
+        && return
+}
+
+__jkr_plans() {
+    local old_IFS="$IFS" # save IFS
+    IFS=$'\n'
+    if [[ -n $1 ]]; then
+        _values "Available plans" $(JKR_ZSHCOMP_HELPER=y jkr list --directory=$1)
+    else
+        _values "Available plans" $(JKR_ZSHCOMP_HELPER=y jkr list)
+    fi
+    IFS="$old_IFS" # restore IFS
+}
+
+# Main completion function
+_jkr() {
+    local curcontext context state line
+    declare -A opt_args
+    integer ret=1
+
+    _arguments \
+        -C -S \
+        '(-): :->subcmds' \
+        '(-)*:: :->option-or-argument' \
+        && return
+
+    case $state in
+        (subcmds)
+            __jkr_subcmds && ret=0
+            ;;
+        (option-or-argument)
+            if (( $+functions[__jkr-$words[1]-cmd] )); then
+                _call_function ret __jkr-$words[1]-cmd
+            else
+                _message 'no completion'
+            fi
+            ;;
+    esac
+
+    return $ret
+}
+
+__jkr_subcmds() {
+    _values 'Jkr command' \
+            'execute[Execute a plan]' \
+            'list[List jkr plans]' \
+            'analyze[Analyze a result]'
+}

data/exe/jkr

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require 'jkr'
+
+Jkr::CLI.start(ARGV)

data/jkr.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jkr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jkr"
+  spec.version       = Jkr::VERSION
+  spec.authors       = ["Yuto Hayamizu"]
+  spec.email         = ["y.hayamizu@gmail.com"]
+  spec.licenses      = ["GPL-3.0"]
+
+  spec.summary       = %q{Script execution manager for experimental measurements.}
+  spec.description   = %q{Jkr is a script execution manager for experimental measurements.}
+  spec.homepage      = "https://github.com/as110-tkl/jkr"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thor'
+  spec.add_dependency 'term-ansicolor'
+
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency "rake"
+end

data/lib/jkr.rb

@@ -1,9 +1,18 @@
 
+require 'jkr/array'
+require 'jkr/numeric'
 require 'jkr/env'
+require 'jkr/error'
 require 'jkr/plan'
+require 'jkr/planfinder'
 require 'jkr/trial'
 require 'jkr/analysis'
-
-class Jkr
-  VERSION = '0.0.1'
-end
+require 'jkr/cpufreq'
+require 'jkr/cpu_usage'
+require 'jkr/sysinfo'
+require 'jkr/analytics'
+require 'jkr/plot'
+require 'jkr/stat'
+require 'jkr/userutils'
+require 'jkr/dirlock'
+require 'jkr/cli'

data/lib/jkr/analysis.rb

@@ -1,27 +1,18 @@
 
-class Jkr
+module Jkr
   class Analysis
     def self.analyze(env, resultset_num)
-      resultset_num = sprintf "%03d", resultset_num.to_i
+      resultset_num = sprintf "%05d", 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)
+      plan = Plan.create_by_result_id(env, resultset_num)
+      plan.resultset_dir = File.dirname(plan.file_path)
 
-      Jkr::AnalysisUtils.define_analysis_utils(resultset_dir, plan)
-      plan.analysis.call(plan)
-      Jkr::AnalysisUtils.undef_analysis_utils(plan)
+      plan.do_analysis()
     end
   end
 end

data/lib/jkr/analytics.rb

@@ -0,0 +1,75 @@
+
+module Jkr
+  class Analytics
+    class << self
+      def normalize_param(key, value = nil)
+        if value.is_a? TrueClass
+          return key.to_s + "_true"
+        elsif value.is_a? FalseClass
+          return key.to_s + "_false"
+        end
+
+        value
+      end
+
+      def each_group(results, variable, opt = {})
+        # extract parameters given as variables
+        param_keys = results.first[:params].keys.select do |param_key|
+          values = results.map do |result|
+            normalize_param(param_key, result[:params][param_key])
+          end
+          values.all?{|val| ! val.nil?} && values.sort.uniq.size > 1
+        end
+
+        unless param_keys.include?(variable)
+          raise ArgumentError.new("Invalid variable: #{variable.inspect}")
+        end
+        [:start_time, :end_time].each do |obsolete_key|
+          if param_keys.include?(obsolete_key)
+            $stderr.puts("#{obsolete_key} should not be included in result[:params]")
+            param_keys.delete(obsolete_key)
+          end
+        end
+        param_keys.delete(:trial)
+        param_keys.delete(variable)
+        if opt[:except]
+          opt[:except].each do |key|
+            param_keys.delete(key)
+          end
+        end
+
+        results.group_by do |result|
+          param_keys.map{|key| normalize_param(key, result[:params][key])}
+        end.sort_by do |group_param, group|
+          group_param
+        end.each do |group_param, group|
+          group = group.sort_by{|result| result[:params][variable]}
+          yield(group_param, group)
+        end
+      end
+
+      def hton(str)
+        if str.is_a? Numeric
+          return str
+        end
+
+        units = {
+          'k' => 1024, 'K' => 1024,
+          'm' => 1024*1024, 'M' => 1024*1024,
+          'g' => 1024*1024*1024, 'G' => 1024*1024*1024,
+        }
+
+        if str =~ /(\d+)([kKmMgG]?)/
+          num = $1.to_i
+          unit = $2
+          if unit.size > 0
+            num *= units[unit]
+          end
+        else
+          raise ArgumentError.new("#{str} is not a valid number expression")
+        end
+        num
+      end
+    end
+  end
+end

data/lib/jkr/array.rb

@@ -0,0 +1,47 @@
+
+class Array
+  def sum()
+    self.inject(&:+)
+  end
+
+  def avg()
+    if self.empty?
+      nil
+    else
+      self.sum.to_f / self.size
+    end
+  end
+
+  def stdev()
+    avg = self.avg
+    var = self.map{|val| (val - avg) ** 2}.sum
+    if self.size > 1
+      var /= self.size - 1
+    end
+    Math.sqrt(var)
+  end
+
+  def sterr()
+    self.stdev / Math.sqrt(self.size)
+  end
+
+  def every?(&block)
+    ret = true
+    self.each do |elem|
+      unless block.call(elem)
+        ret = false
+        break
+      end
+    end
+    ret
+  end
+
+  def group_by()
+    ret = Hash.new{ Array.new }
+    self.each do |elem|
+      ret[yield(elem)] += [elem]
+    end
+
+    ret
+  end
+end

data/lib/jkr/blktrace.rb

@@ -0,0 +1,131 @@
+
+module Jkr
+  class Blktrace
+    class << self
+      def open(input_basename)
+        self.new(input_basename)
+      end
+
+      def each(input_basename, &block)
+        self.new(input_basename).each(&block)
+      end
+    end
+
+    def initialize(input_basename)
+      input_basename = Pathname.new(input_basename).relative_path_from(Pathname.new(`pwd`.strip)).to_s
+      if Dir.glob(input_basename + ".blktrace.*").size > 0
+        @input_basename = input_basename
+        puts "multi file: #{input_basename}"
+      else
+        if File.exists?(input_basename)
+          @input_singlefile = input_basename
+          puts "single file: #{input_basename}"
+        else
+          raise ArgumentError.new("No such blktrace data: #{input_basename}")
+        end
+      end
+    end
+
+    def raw_each(option = {}, &block)
+      if option[:limit]
+        limit = "| head -n #{option[:limit]}"
+      else
+        limit = ""
+      end
+      if @input_basename
+        cmd = "blkparse -f \"bt\\t%c\\t%s\\t%T.%t\\t%a\\t%d\\t%S\\t%n\\n\" -i #{@input_basename} #{limit} | grep '^bt'|sort -k4,4"
+      elsif @input_singlefile
+        cmd = "cat #{@input_singlefile}|blkparse -f \"bt\\t%c\\t%s\\t%T.%t\\t%a\\t%d\\t%S\\t%n\\n\" -i - #{limit} | grep '^bt'|sort -k4,4"
+      end
+      IO.popen(cmd, "r") do |io|
+        while line = io.gets
+          _, cpu, seqno, time, action, rwbs, pos_sec, sz_sec = line.split("\t")
+          cpu = cpu.to_i
+          seqno = seqno.to_i
+          time = time.to_f
+          pos_sec = pos_sec.to_i
+          sz_sec = sz_sec.to_i
+          record = [cpu, seqno, time, action, rwbs, pos_sec, sz_sec]
+
+          block.call(record)
+        end
+      end
+    end
+
+    def each(option = {}, &block)
+      self.map(option, &block)
+      true
+    end
+
+    def map(option = {}, &block)
+      if ! option.include?(:cache)
+        option[:cache] = true
+      end
+      if option[:limit]
+        limit = "| head -n #{option[:limit]}"
+      else
+        limit = ""
+      end
+
+      if @input_basename
+        cache_file_path = @input_basename + ".cache"
+      else
+        cache_file_path = @input_singlefile + ".cache"
+      end
+
+      if option[:cache] && File.exists?(cache_file_path)
+        records = Marshal.load(File.open(cache_file_path))
+      else
+        records = []
+        issues = []
+        if @input_basename
+          cmd = "blkparse -f \"bt\\t%c\\t%s\\t%T.%t\\t%a\\t%d\\t%S\\t%n\\n\" -i #{@input_basename} #{limit} | grep '^bt'|sort -k4,4"
+        elsif
+          cmd = "cat #{@input_singlefile}|blkparse -f \"bt\\t%c\\t%s\\t%T.%t\\t%a\\t%d\\t%S\\t%n\\n\" -i - #{limit} | grep '^bt'|sort -k4,4"
+        end
+        IO.popen(cmd, "r") do |io|
+          while line = io.gets
+            _, cpu, seqno, time, action, rwbs, pos_sec, sz_sec = line.split("\t")
+            cpu = cpu.to_i
+            seqno = seqno.to_i
+            time = time.to_f
+            pos_sec = pos_sec.to_i
+            sz_sec = sz_sec.to_i
+            
+            record = [cpu, seqno, time, action, rwbs, pos_sec, sz_sec]
+            if action == "D"
+              issues.push(record)
+            elsif action == "C"
+              # check pos and sz
+              del_idx = nil
+              issues.each_with_index do |rec, idx|
+                if pos_sec == rec[5] && sz_sec == rec[6]
+                  del_idx = idx
+                  rt = time - rec[2]
+                  record.push(rt) # append response time
+                  records.push(record)
+                  break
+                end
+              end
+              if del_idx.nil?
+                puts("Unmatched complete record: #{record.inspect}")
+                # raise StandardError.new("Unmatched complete record: #{record.inspect}")
+                next
+              end
+              issues.delete_at(del_idx)
+            else
+              raise NotImplementedError.new("Action #{action} handler is not implemented.")
+            end
+          end
+        end
+        File.open(cache_file_path, "w") do |file|
+          Marshal.dump(records, file)
+        end
+      end
+
+      records.map do |*record|
+        block.call(*record)
+      end
+    end
+  end
+end