jkr 0.0.1 → 0.1.0

data/lib/jkr/cli.rb

@@ -0,0 +1,110 @@
+require 'thor'
+require 'term/ansicolor'
+
+module Jkr
+  class CLI < ::Thor
+    include Term::ANSIColor
+
+    class_option :debug, :type => :boolean
+    class_option :directory, :type => :string, :default => Dir.pwd, :aliases => :C
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "init", "Initialize a Jkr environment"
+    def init()
+      dir = options[:directory]
+
+      jkr_dir    = File.join(dir, "jkr")
+      result_dir = File.join(dir, "jkr", "result")
+      plan_dir   = File.join(dir, "jkr", "plan")
+      script_dir = File.join(dir, "jkr", "script")
+
+      puts "Preparing a new Jkr environment ... @ #{dir}"
+
+      [jkr_dir, result_dir, plan_dir, script_dir].each do |dir|
+        puts "  making directory: #{dir}"
+        FileUtils.mkdir(dir)
+      end
+
+      [result_dir, plan_dir, script_dir].each do |dir|
+        File.open(File.expand_path(".gitdir", dir), "w") do |_|
+        end
+      end
+
+      puts "  preparing an example plan: example.plan"
+      FileUtils.cp(File.expand_path("../../etc/example.plan", __dir__),
+                   File.join(plan_dir, "example.plan"))
+
+      puts ""
+      puts "... done"
+    end
+
+    desc "list", "List executable plans"
+    def list()
+      begin
+        @jkr_env = Jkr::Env.new(options[:directory])
+      rescue Errno::ENOENT
+        puts(red("[ERROR] jkr dir not found at #{@options[:directory]}"))
+        puts(red("        Maybe you are in a wrong directory."))
+        exit(false)
+      end
+
+      plans = Dir.glob("#{@jkr_env.jkr_plan_dir}/*.plan").map do |plan_file_path|
+        plan = Jkr::Plan.create_by_name(@jkr_env, File.basename(plan_file_path, ".plan"))
+        [File.basename(plan_file_path, ".plan"), plan.title]
+      end
+
+      if ENV["JKR_ZSHCOMP_HELPER"]
+        plans.each do |plan_name, plan_title|
+          puts "#{plan_name}[#{plan_title}]"
+        end
+        return
+      end
+
+      puts "Existing plans:"
+      puts
+      maxlen = plans.map{|plan| plan[0].size}.max
+      plans.each do |plan|
+        printf(" %#{maxlen}s : %s\n", plan[0], plan[1])
+      end
+      puts
+    end
+
+    desc "execute <plan> [<plan> ...]", "Execute plans"
+    def execute(*plan_names)
+      @jkr_env = Jkr::Env.new(options[:directory])
+
+      if options[:debug]
+        delete_files_on_error = false
+      else
+        delete_files_on_error = true
+      end
+
+      if plan_names.size > 0
+        plan_name = plan_names.first
+        plan = Jkr::Plan.create_by_name(@jkr_env, plan_name)
+        Jkr::Trial.run(@jkr_env, plan, delete_files_on_error)
+      end
+    end
+
+    desc "analyze <result> [<result> ...]", "Run analysis script for executed results"
+    def analyze(*result_ids)
+      @jkr_env = Jkr::Env.new(options[:directory])
+
+      result_ids.each do |arg|
+        Jkr::Analysis.analyze(@jkr_env, arg)
+      end
+    end
+
+    no_commands do
+      def find_plan_file(plan_name)
+        @jkr_env.plans.find do |plan_file_path|
+          File.basename(plan_file_path) == plan_name + ".plan"
+        end
+      end
+    end
+  end
+
+end # Jkr

data/lib/jkr/cpu_usage.rb

@@ -0,0 +1,81 @@
+
+module Jkr
+  class CpuUsageMonitor
+    def initialize
+      @checkpoint1 = nil
+      @checkpoint2 = nil
+
+      self.checkpoint
+    end
+
+    def read_stat
+      stat_str = `cat /proc/stat`
+      cpu_total = nil
+      cpus = Array.new
+      stat_str.each_line do |line|
+        case line
+        when /cpu (.*)$/
+          user, nice, sys, idle, *rest = $~[1].strip.split.map(&:to_i)
+          rest = rest.inject(&:+)
+          cpu_total = {:user => user, :sys => sys, :nice => nice, :idle => idle, :rest => rest}
+        when /cpu(\d+) (.*)$/
+          idx = $~[1].to_i
+          user, nice, sys, idle, *rest = $~[2].strip.split.map(&:to_i)
+          cpus[idx] = {:user => user, :sys => sys, :nice => nice, :idle => idle, :rest => rest}
+        end
+      end
+
+      {:system => cpu_total,
+        :cpus => cpus}
+    end
+
+    def checkpoint
+      @checkpoint2 = @checkpoint1
+      @checkpoint1 = self.read_stat
+    end
+
+    def reset
+      @checkpoint2 = @checkpoint1 = nil
+    end
+
+    def checkpoint_and_get_usage
+      self.checkpoint
+      self.get_last_usage
+    end
+
+    def get_usage
+      unless @checkpoint1
+        raise RuntimeError.new("Checkpointing is required")
+      end
+
+      self.calc_usage(self.read_stat[:system], @checkpoint1[:system])
+    end
+
+    def get_last_usage
+      unless @checkpoint1 && @checkpoint2
+        raise RuntimeError.new("At least two checkpoints are required")
+      end
+
+      self.calc_usage(@checkpoint2[:system], @checkpoint1[:system])
+    end
+
+    def calc_usage(stat1, stat2)
+      stat1_clk, stat2_clk = [stat1, stat2].map{|stat|
+        stat.values.inject(&:+)
+      }
+      if stat1_clk > stat2_clk
+        stat1, stat2, stat1_clk, stat2_clk = [stat2, stat1, stat2_clk, stat1_clk]
+      elsif stat1_clk == stat2_clk
+        raise RuntimeError.new("Same clock count. cannot calc usage.")
+      end
+      clk_diff = (stat2_clk - stat1_clk).to_f
+      ret = Hash.new
+      [:user, :sys, :nice, :idle].map{|key|
+        ret[key] = (stat2[key] - stat1[key]) / clk_diff
+      }
+      ret[:total] = 1.0 - ret[:idle]
+
+      ret
+    end
+  end
+end

data/lib/jkr/cpufreq.rb

@@ -0,0 +1,201 @@
+#!/usr/bin/env ruby
+
+require 'jkr/array'
+
+module Jkr
+  class Cpufreq
+    def self.cpupath(cpu_idx = nil)
+      if cpu_idx
+        self.cpupath() + "/cpu#{cpu_idx}"
+      else
+        "/sys/devices/system/cpu"
+      end
+    end
+
+    def self.cpufreqpath(cpu_idx = 0)
+      cpupath(cpu_idx) + "/cpufreq"
+    end
+
+    def self.num_cpu()
+      Dir.glob(cpupath("*")).select{|file| file =~ /cpu\d+$/}.size
+    end
+    
+    def self.available?()
+      (0..(self.num_cpu() - 1)).to_a.every?{|cpu_idx|
+        File.exists?(cpufreqpath(cpu_idx))
+      }
+    end
+
+    def self.config()
+      Config.get()
+    end
+
+    def self.available_frequency(cpu_idx = 0)
+      if self.available?
+        `cat #{cpufreqpath(cpu_idx) + "/scaling_available_frequencies"}`.strip.split.map(&:to_i).sort
+      else
+        []
+      end
+    end
+
+    class Config
+      attr_reader :cpuconfigs
+
+      def initialize(*args)
+        @cpuconfigs = \
+        if args.size == 0
+          self.current_config
+        elsif args.size == 1 && args.first.is_a?(Hash)
+          arg = args.first
+          if ! arg[:governor]
+            raise ArgumentError.new("governor must be specified.")
+          elsif arg[:governor] == "userspace" && ! arg[:frequency]
+            raise ArgumentError.new("parameter :frequency is required for userspece governor")
+          end
+
+          Array.new(Cpufreq.num_cpu()){|idx|
+            CpuConfig.new(idx, arg[:governor], arg)
+          }
+        elsif args.size == 1 && args.first.is_a?(Array) && args.first.every?{|arg| arg.is_a? CpuConfig}
+          args.first
+        elsif args.size == Cpufreq.num_cpu() && args.every?{|arg| arg.is_a? CpuConfig}
+          args
+        end
+      end
+
+      def self.get()
+        cpuconfigs = Array.new(Cpufreq.num_cpu){|cpu_idx|
+          CpuConfig.read_config(cpu_idx)
+        }
+        self.new(cpuconfigs)
+      end
+
+      def self.set(config)
+        config.cpuconfigs.each_with_index{|cpuconfig, idx|
+          CpuConfig.write_config(idx, cpuconfig)
+        }
+      end
+
+      def to_s
+        cpuconfig = @cpuconfigs.first
+
+        ret = cpuconfig.governor
+
+        suffix = case cpuconfig.governor
+                 when /\Aperformance\Z/
+                   nil
+                 when /\Apowersave\Z/
+                   nil
+                 when /\Auserspace\Z/
+                   cpuconfig.params[:frequency] / 1000000.0
+                 when /\Aondemand\Z/
+                   nil
+                 end
+
+        if suffix
+          ret += ":freq=#{suffix}GHz"
+        end
+
+        ret
+      end
+
+      class CpuConfig
+        attr_accessor :governor
+        attr_accessor :params
+
+        # cpu_idx is just a hint for gathering information
+        def initialize(cpu_idx, gov, params = Hash.new)
+          @governor = gov.to_s
+          @freq = nil
+          @params = params
+
+          @cpu_idx = cpu_idx
+          @available_freqs = Cpufreq.available_frequency(cpu_idx)
+
+          case @governor
+          when /\Aperformance\Z/
+            # do nothing
+          when /\Apowersave\Z/
+            # do nothing
+          when /\Auserspace\Z/
+            if ! @freq = params[:frequency]
+              raise ArgumentError.new("parameter :frequency is required for userspece governor")
+            elsif ! @available_freqs.include?(params[:frequency])
+              raise ArgumentError.new("Frequency not available: #{params[:frequency]}")
+            end
+          when /\Aondemand\Z/
+            # TODO
+          end
+        end
+
+        def frequency
+          case @governor
+          when /\Aperformance\Z/
+            @available_freqs.max
+          when /\Apowersave\Z/
+            @available_freqs.min
+          when /\Auserspace\Z/
+            @freq
+          when /\Aondemand\Z/
+            `cat #{Cpufreq.cpufreqpath(@cpu_idx) + "/scaling_cur_freq"}`.strip.to_i
+          end
+        end
+
+        def frequency=(freq)
+          if @available_freqs.include?(freq)
+            @freq = freq
+          else
+            raise ArgumentError.new("Frequency not available: #{freq}")
+          end
+        end
+
+        def self.read_config(cpu_idx)
+          gov = `cat #{Cpufreq.cpufreqpath(cpu_idx) + "/scaling_governor"}`.strip
+          freq = nil
+
+          case gov
+          when /\Aperformance\Z/
+            # do nothing
+          when /\Aperformance\Z/
+            # do nothing
+          when /\Auserspace\Z/
+            freq = `cat #{Cpufreq.cpufreqpath(cpu_idx) + "/scaling_cur_freq"}`.strip.to_i
+          when /\Aondemand\Z/
+            # TODO: read parameters
+          end
+
+          CpuConfig.new(cpu_idx, gov, {:frequency => freq})
+        end
+
+        def self.write_config(cpu_idx, cpuconfig)
+          `echo #{cpuconfig.governor} > #{Cpufreq.cpufreqpath(cpu_idx) + "/scaling_governor"}`
+          case cpuconfig.governor
+          when /\Aperformance\Z/
+            # do nothing
+          when /\Aperformance\Z/
+            # do nothing
+          when /\Auserspace\Z/
+            `echo #{cpuconfig.frequency} > #{Cpufreq.cpufreqpath(cpu_idx) + "/scaling_setspeed"}`
+          when /\Aondemand\Z/
+            if cpuconfig.params[:up_threshold]
+              `echo #{cpuconfig.params[:up_threshold]} > #{Cpufreq.cpufreqpath(cpu_idx) + "/ondemand/up_threshold"}`
+            end
+            if cpuconfig.params[:sampling_rate]
+              `echo #{cpuconfig.params[:sampling_rate]} > #{Cpufreq.cpufreqpath(cpu_idx) + "/ondemand/sampling_rate"}`
+            end
+            # TODO: parameters
+          end
+        end
+
+        def to_s
+          case self.governor
+          when /\Auserspace\Z/
+            "#<CpuConfig: governor=#{self.governor}, frequency=#{self.frequency}>"
+          else
+            "#<CpuConfig: governor=#{self.governor}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jkr/dirlock.rb

@@ -0,0 +1,9 @@
+
+class ::Dir
+  def self.lock(dir_path)
+    File.open(dir_path, "r") do |f|
+      f.flock(File::LOCK_EX)
+      yield
+    end
+  end
+end

data/lib/jkr/env.rb

@@ -1,38 +1,38 @@
 
 require 'fileutils'
+require 'term/ansicolor'
 
-class Jkr
+module Jkr
   class Env
+    attr_reader :env_dir
     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
+    def initialize(env_dir = Dir.pwd)
+      @env_dir = env_dir
+      @jkr_dir = File.join(@env_dir, "jkr")
       @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?(@jkr_dir)
+        raise Errno::ENOENT.new(@jkr_dir)
+      end
+
+      [@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)
+          raise ArgumentError.new("Directory #{dir_path} not found")
         end
       end
     end
-
-    def next_plan
-      self.plans.first
-    end
-
-    def plans
-      Dir.glob("#{@jkr_plan_dir}#{File::SEPARATOR}*.plan").sort
-    end
   end
 end