jkr 0.0.1 → 0.1.0

data/lib/jkr/stat.rb

@@ -0,0 +1,2 @@
+
+require(File.expand_path('../stat/kmeans-1d', __FILE__))

data/lib/jkr/stat/kmeans-1d.rb

@@ -0,0 +1,94 @@
+
+class Cluster1D
+  attr_accessor :center, :points
+
+  # Constructor with a starting centerpoint
+  def initialize(center)
+    @center = center
+    @points = []
+  end
+
+  # Recenters the centroid point and removes all of the associated points
+  def recenter!
+    avg = 0
+    old_center = @center
+
+    # Sum up all x/y coords
+    @points.each do |point|
+      avg += point
+    end
+
+    # Average out data
+    if points.length == 0
+      avg = center
+    else
+      avg /= points.length
+    end
+
+    # Reset center and return distance moved
+    @center = avg
+    return (old_center - center).abs
+  end
+end
+
+#
+# kmeans algorithm
+#
+
+def kmeans1d(data, k, delta=0.001)
+  clusters = []
+
+  # Assign intial values for all clusters
+  (1..k).each do |point|
+    index = (data.length * rand).to_i
+
+    rand_point = data[index]
+    c = Cluster1D.new(rand_point)
+
+    clusters.push c
+  end
+
+  # Loop
+  while true
+    # Assign points to clusters
+    data.each do |point|
+      min_dist = +Float::INFINITY
+      min_cluster = nil
+
+      # Find the closest cluster
+      clusters.each do |cluster|
+        dist = (point - cluster.center).abs
+
+        if dist < min_dist
+          min_dist = dist
+          min_cluster = cluster
+        end
+      end
+
+      # Add to closest cluster
+      min_cluster.points.push point
+    end
+
+    # Check deltas
+    max_delta = -Float::INFINITY
+
+    clusters.each do |cluster|
+      dist_moved = cluster.recenter!
+
+      # Get largest delta
+      if dist_moved > max_delta
+        max_delta = dist_moved
+      end
+    end
+
+    # Check exit condition
+    if max_delta < delta
+      return clusters
+    end
+
+    # Reset points for the next iteration
+    clusters.each do |cluster|
+      cluster.points = []
+    end
+  end
+end

data/lib/jkr/su_cmd

@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+
+import errno,os,pty,re,select,signal,string,sys
+
+dbg=0
+efd = None
+
+def LOG(s):
+    os.write(efd, s)
+
+#
+# (1) ./su_cmd whoami ---> exec "su -c whoami"
+# (2) wait for "Password: " prompt and send password
+# (3) get stdout of the child process
+#
+# It may kill the child process when it waited until timeout
+# got a strange string from the child process.
+#
+# Exit status is normally that of the child process (ssh), or
+# 255 when the child was killed.
+#
+
+#
+# Timeout for each 'read' operation.
+# It should be long enough so distant hosts can respond.
+#
+read_timeout = 5.0
+read_timeout_after_pw = 30.0
+
+# Probably you need not modify parameters below.
+write_timeout = 1.0
+
+def safe_read(fd, bytes, timeout, show_error):
+    """
+    Read string from child or timeout.
+    """
+    if timeout is None:
+        R,W,E = select.select([fd],[],[])
+    else:
+        R,W,E = select.select([fd],[],[],timeout)
+    if len(R) == 0:
+        if dbg>=2: LOG("read: read timeout\n")
+        return (-1, None)
+    try:
+        x = os.read(fd, bytes)
+    except OSError,e:
+        if show_error:
+           if dbg>=2: LOG("read: %s\n" % (e.args, ))
+        return (-1, e)
+    if dbg>=2: LOG("read => '%s'\n" % x)
+    return (0, x)
+
+def safe_write(fd, str, timeout, show_error):
+    """
+    Write a string to child or timeout.
+    """
+    R,W,E = select.select([],[fd],[],timeout)
+    if len(W) == 0:
+        if dbg>=2: LOG("write: write timeout\n")
+        return (-1, None)
+    try:
+        x = os.write(fd, str)
+    except OSError,e:
+        if show_error:
+            if dbg>=2: LOG("write: %s\n" % (e.args,))
+        return (-1, e)
+    if dbg>=2: LOG("write => %s\n" % x)
+    return (x, None)
+
+def cleanup(pid):
+    """
+    Check if pid exists. If so, kill it with SIGKILL.
+    """
+    try:
+        os.kill(pid, 0)
+    except OSError,e:
+        if e.args[0] == errno.ESRCH:    # no such process
+            return
+    try:
+        os.kill(pid, signal.SIGKILL)
+    except OSError,e:
+        if e.args[0] == errno.ESRCH:    # no such process
+            return
+
+def wait_for_password_prompt(fd, passphrase):
+    bytes_to_read = 1
+    output_s = ""
+    while 1:
+        r,s = safe_read(fd, bytes_to_read, read_timeout, 1)
+        if r == -1: return -1
+        output_s = output_s + s
+        if dbg>=2: LOG("[%s]\n" % output_s)
+        m = re.search("Password: ", output_s)
+        if m: break
+
+    r,s = safe_write(fd, "%s\r\n" % passphrase, write_timeout, 1)
+    if r == -1: return -1
+    while 1:
+        r,s = safe_read(fd, bytes_to_read, read_timeout, 1)
+        if r == -1: return -1
+        output_s = output_s + s
+        if dbg>=2: LOG("[%s]\n" % output_s)
+        m = re.search("Password: (.*)\r\n", output_s)
+        if m: break
+    return 0
+
+def parent(fd, passphrase):
+    """
+    Main procedure of the parent.
+    Input passphrase if asked.
+    """
+    if wait_for_password_prompt(fd, passphrase) == -1:
+        return -1
+    bytes_to_read = 1
+    while 1:
+        r,s = safe_read(fd, bytes_to_read, read_timeout_after_pw, 1)
+        if r == -1: return -1
+        os.write(1, s)
+    return 0
+
+def main(argv):
+    global efd
+    passphrase = os.environ.get("SU_PASSWORD")
+    if passphrase is None:
+        sys.stderr.write("su_cmd: SU_PASSWORD not set\n")
+        os._exit(255)
+    user = os.environ.get("SU_USER")
+    os.environ["LANG"] = "C"
+    # fork with pty
+    pid,master = pty.fork()
+    assert pid != -1
+    if pid == 0:
+        # child. run su
+        if user is None:
+            cmd = [ "su", "-c", string.join(argv[1:], " ") ]
+        else:
+            cmd = [ "su", user, "-c", string.join(argv[1:], " ") ]
+        os.execvp(cmd[0], cmd)
+    else:
+        if dbg>=2:
+            efd = 2 # os.open("su_cmd.log", os.O_WRONLY|os.O_CREAT|os.O_TRUNC)
+        # parent. talk to child.
+        r = parent(master, passphrase)
+        # ensure child is gone
+        if dbg>=2: LOG("cleanup\n")
+        cleanup(pid)
+        # write whatever we get from child
+        # os.write(1, s)
+        # wait for child to disappear
+        if dbg>=2: LOG("wait for child to terminate\n")
+        qid,status = os.wait()
+        assert pid == qid
+        if dbg>=2: LOG("child finished\n")
+        if os.WIFEXITED(status):
+            # child normally exited. forward its status
+            os._exit(os.WEXITSTATUS(status))
+        else:
+            # child was killed. return 255
+            os._exit(255)
+        if dbg>=2: os.close(efd)
+
+if __name__ == "__main__":
+    main(sys.argv)

data/lib/jkr/sysinfo.rb

@@ -0,0 +1,34 @@
+
+module Jkr
+  class SysInfo
+    class << self
+      def gather
+        ret = Hash.new
+        ret[:proc] = Hash.new
+
+        # gather infomation under /proc
+        ret[:proc][:cpuinfo] = `cat /proc/cpuinfo`
+        ret[:proc][:meminfo] = `cat /proc/meminfo`
+        ret[:proc][:interrupts] = `cat /proc/interrupts`
+        ret[:proc][:mdstat] = `cat /proc/mdstat`
+        ret[:proc][:mounts] = `cat /proc/mounts`
+
+        ret[:sys] = Hash.new
+        ret[:sys][:block] = Hash.new
+        Dir.glob("/sys/block/*").each do |block_path|
+          block = File.basename(block_path).to_sym
+          ret[:sys][:block][block] = Hash.new
+          ret[:sys][:block][block][:queue] = Hash.new
+          Dir.glob("#{block_path}/queue/scheduler") do |path|
+            ret[:sys][:block][block][:queue][:scheduler] = `cat #{path}`
+          end
+          Dir.glob("#{block_path}/queue/nr_requests") do |path|
+            ret[:sys][:block][block][:queue][:nr_requests] = `cat #{path}`
+          end
+        end
+
+        ret
+      end
+    end
+  end
+end

data/lib/jkr/trial.rb

@@ -1,11 +1,11 @@
 
 require 'fileutils'
+require 'json'
 require 'jkr/utils'
 
-class Jkr
+module Jkr
   class Trial
     attr_reader :params
-    
     def self.make_trials(resultset_dir, plan)
       var_combs = [{}]
       plan.vars.each do |key, vals|
@@ -16,26 +16,81 @@ class Jkr
         }.flatten
       end
 
-      var_combs.map do |var_comb|
+      params_list = var_combs.map{|var_comb| plan.params.merge(var_comb)}
+
+      plan.param_filters.each do |filter|
+        params_list = params_list.select(&filter)
+      end
+
+      params_list = params_list * plan.routine_nr_run
+
+      params_list.map do |params|
         result_dir = Utils.reserve_next_dir(resultset_dir)
-        Trial.new(result_dir, plan, plan.params.merge(var_comb))
+        Trial.new(result_dir, plan, params)
       end
     end
 
-    def self.run(env, plan)
+    def self.pretty_time(seconds)
+      hour = seconds / 3600
+      min = (seconds - hour * 3600) / 60
+      sec = seconds - hour * 3600 - min * 60
+
+      sprintf("%02d:%02d:%02d", hour, min, sec)
+    end
+
+    def self.run(env, plan, delete_files_on_error = true)
       plan_suffix = File.basename(plan.file_path, ".plan")
+      plan_suffix += "_#{plan.short_desc}" if plan.short_desc
       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
+      plan.resultset_dir = resultset_dir
+      FileUtils.mkdir_p(File.join(resultset_dir, "plan"))
+      FileUtils.mkdir_p(File.join(resultset_dir, "script"))
+
+      begin
+        trials = self.make_trials(resultset_dir, plan)
+
+        plan_dest_dir = File.join(resultset_dir, "plan")
+        script_dest_dir = File.join(resultset_dir, "script")
+
+        _plan = plan
+        begin
+          if _plan == plan # copy main plan file
+            FileUtils.copy_file(_plan.file_path,
+                                File.expand_path(File.basename(_plan.file_path), resultset_dir))
+          else
+            FileUtils.copy_file(_plan.file_path,
+                                File.expand_path(File.basename(_plan.file_path),
+                                               plan_dest_dir))
+          end
+
+          plan.used_scripts.each do |script_path|
+            FileUtils.copy_file(script_path,
+                                File.expand_path(File.basename(script_path),
+                                                 script_dest_dir))
+          end
+        end while _plan = _plan.base_plan
+
+        params = plan.params.merge(plan.vars)
+        plan.freeze
+
+        # show estimated execution time if available
+        if plan.exec_time_estimate
+          puts("")
+          puts("== estimated execution time: #{pretty_time(plan.exec_time_estimate.call(plan))} ==")
+          puts("")
+        end
+
+        plan.do_prep()
+        trials.each do |trial|
+          trial.run
+        end
+        plan.do_cleanup()
+      rescue Exception => err
+        if delete_files_on_error
+          FileUtils.rm_rf(resultset_dir)
+        end
+        raise err
       end
-      plan.cleanup.call(plan)
     end
 
     def initialize(result_dir, plan, params)
@@ -46,9 +101,29 @@ class Jkr
     private :initialize
 
     def run()
+      plan = @plan
+      File.open("#{@result_dir}/params.json", "w") do |f|
+        f.puts(@params.to_json)
+      end
+
+      # reset plan.metastore
+      plan.metastore.clear
+
+      # define utility functions for plan.routine object
       Jkr::TrialUtils.define_routine_utils(@result_dir, @plan, @params)
-      @plan.routine.call(@plan, @params)
+
+      @plan.metastore[:trial_start_time] = Time.now
+      @plan.do_routine(@plan, @params)
+      @plan.metastore[:trial_end_time] = Time.now
+
       Jkr::TrialUtils.undef_routine_utils(@plan)
+
+      # save plan.metastore
+      Marshal.dump(@plan.metastore,
+                   File.open("#{@result_dir}/metastore.msh", "w"))
+      File.open("#{@result_dir}/metastore.json", "w") do |f|
+        f.puts(@plan.metastore.to_json)
+      end
     end
   end
 end

data/lib/jkr/userutils.rb

@@ -4,7 +4,7 @@ require 'time'
 require 'date'
 require 'csv'
 
-class Jkr
+module Jkr
   class SysUtils
     def self.cpu_cores()
       self.num_cores()
@@ -34,19 +34,22 @@ class Jkr
         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 = []
+      #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 = file.read.split(separator).map do |x|
+        proc.call(x)
+      end.compact
 
       result
     end
@@ -55,6 +58,67 @@ class Jkr
       self.read_blockseq(io_or_filepath, "\n", &block)
     end
 
+    def self.read_sar(sar_filepath)
+      labels = nil
+      date = nil
+      last_time = nil
+      idx = 0
+      self.read_rowseq(sar_filepath){|rowstr|
+        if rowstr =~ /^Linux/ && rowstr =~ /(\d{2})\/(\d{2})\/(\d{2})/
+          y = $~[3].to_i; m = $~[1].to_i; d = $~[2].to_i
+          date = Date.new(2000 + y, m, d)
+          next
+        else
+          row = Hash.new
+
+          time, *vals = rowstr.split
+
+          if vals.size == 0
+            next
+          end
+          if vals.every?{|val| val =~ /\A\d+(?:\.\d+)?\Z/ }
+            vals = vals.map(&:to_f)
+          else
+            # label line
+            labels = vals
+            next
+          end
+
+          unless date
+            raise StandardError.new("cannot find date information in sar log")
+          end
+          unless labels
+            raise StandardError.new("no label information")
+          end
+
+          unless time =~ /(\d{2}):(\d{2}):(\d{2})/
+            if time =~ /Average/
+              next
+            end
+            raise StandardError.new("Invalid time format: #{time}")
+          else
+            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
+
+            row[:time] = time
+            row[:data] = Hash.new
+            labels.each_with_index do |label,idx|
+              row[:data][label] = vals[idx]
+            end
+            row[:labels] = labels
+
+            last_time = time
+          end
+        end
+        row
+      }
+    end
+
     def self.read_mpstat_avg(io_or_filepath)
       self.read_blockseq(io_or_filepath){|blockstr|
         if blockstr =~ /^Average:/
@@ -82,13 +146,23 @@ class Jkr
       }.last
     end
 
+    # Format of returned value
+    # [{
+    #    :time => <Time>,
+    #    :labels => [:cpu, :usr, :nice, :sys, :iowait, :irq, ...],
+    #    :data => [{:cpu => "all", :usr => 0.11, :nice => 0.00, ...],
+    #              {:cpu => 0, :usr => 0.12, :nice => 0.00, ...},
+    #               ...]
+    #  },
+    #  ...]
+    #
     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})$/
+        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)
@@ -104,11 +178,25 @@ class Jkr
           rows = blockstr.lines.map(&:strip)
           header = rows.shift.split
           next if header.shift =~ /Average/
-          result[:labels] = header
+          if header.first =~ /\AAM|PM\Z/
+            header.shift
+          end
+          result[:labels] = header.map do |label|
+            {
+              "CPU" => :cpu, "%usr" => :usr, "%user" => :usr,
+              "%nice" => :nice, "%sys" => :sys, "%iowait" => :iowait,
+              "%irq" => :irq, "%soft" => :soft, "%steal" => :steal,
+              "%guest" => :guest, "%idle" => :idle
+            }[label] || label
+          end
           time = nil
           result[:data] = rows.map { |row|
             vals = row.split
             wallclock = vals.shift
+            if vals.first =~ /\AAM|PM\Z/
+              vals.shift
+            end
+
             unless time
               unless wallclock =~ /(\d{2}):(\d{2}):(\d{2})/
                 raise RuntimeError.new("Cannot extract wallclock time from mpstat data")
@@ -126,19 +214,121 @@ class Jkr
             if vals.size != result[:labels].size
               raise RuntimeError.new("Invalid mpstat data")
             end
-            vals.map{|val|
-              begin
-                Float(val)
-              rescue ArgumentError
-                val
-              end
+
+            record = Hash.new
+            vals.each_with_index{|val, idx|
+              label = result[:labels][idx]
+              val = if val =~ /\A\d+\Z/
+                      val.to_i
+                    else
+                      begin
+                        Float(val)
+                      rescue ArgumentError
+                        val
+                      end
+                    end
+              record[label] = val
             }
+
+            record
           }
           result
         end
       end
     end
 
+    #
+    # This function parses _io_or_filepath_ as an iostat log and
+    # returns the parsed result.
+    #
+    # _block_ :: If given, invoked for each iostat record like
+    #            block.call(t, record)
+    #            t ... wallclock time of the record
+    #            record ... e.g. {"sda" => {"rrqm/s" => 0.0, ...}, ...}
+    #
+    def self.read_iostat(io_or_filepath, &block)
+      hostname = `hostname`.strip
+      date = nil
+      last_time = nil
+      sysname_regex = Regexp.new(Regexp.quote("#{`uname -s`.strip}"))
+      self.read_blockseq(io_or_filepath) do |blockstr|
+        if blockstr =~ sysname_regex
+          # the first line
+          if blockstr =~ /(\d{2})\/(\d{2})\/(\d{2,4})/
+            if $~[3].size == 2
+              y = $~[3].to_i + 2000
+            else
+              y = $~[3].to_i
+            end
+            m = $~[1].to_i
+            d = $~[2].to_i
+            date = Date.new(y, m, d)
+            next
+          end
+        else
+          rows = blockstr.lines.map(&:strip)
+          timestamp = rows.shift
+          time = nil
+          unless date
+            raise RuntimeError.new("Cannot detect date: #{io_or_filepath}")
+          end
+
+          if timestamp =~ /(\d{2})\/(\d{2})\/(\d{2}) (\d{2}):(\d{2}):(\d{2})/
+            y = $~[3].to_i; m = $~[1].to_i; d = $~[2].to_i
+            time = Time.local(date.year, date.month, date.day, $~[4].to_i, $~[5].to_i, $~[6].to_i)
+          elsif date && timestamp =~ /Time: (\d{2}):(\d{2}):(\d{2}) (AM|PM)/
+            if $~[4] == "PM"
+              hour = $~[1].to_i
+              if $~[1].to_i != 12
+                hour += 12
+              end
+            elsif $~[4] == "AM" && $~[1].to_i == 12
+              hour = 0
+            else
+              hour = $~[1].to_i
+            end
+            time = Time.local(date.year, date.month, date.day,
+                              hour, $~[2].to_i, $~[3].to_i)
+          elsif date && timestamp =~ /Time: (\d{2}):(\d{2}):(\d{2})/
+            time = Time.local(date.year, date.month, date.day,
+                              $~[1].to_i, $~[2].to_i, $~[3].to_i)
+          end
+
+          unless time
+            unless date
+              raise StandardError.new("Cannot find date in your iostat log: #{io_or_filepath}")
+            end
+            raise StandardError.new("Cannot find timestamp in your iostat log: #{io_or_filepath}")
+          end
+
+          labels = rows.shift.split
+          unless labels.shift =~ /Device:/
+            raise StandardError.new("Invalid iostat log: #{io_or_filepath}")
+          end
+
+          record = Hash.new
+          rows.each do |row|
+            vals = row.split
+            dev = vals.shift
+            unless vals.size == labels.size
+              raise StandardError.new("Invalid iostat log: #{io_or_filepath}")
+            end
+            record_item = Hash.new
+            labels.each do |label|
+              record_item[label] = vals.shift.to_f
+            end
+            record[dev] = record_item
+          end
+
+          if block.is_a? Proc
+            block.call(time, record)
+          end
+
+          [time, record]
+        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")
@@ -152,5 +342,93 @@ class Jkr
       end
       result
     end
+
+    class << self
+      def read_top(io_or_filepath, opt = {}, &proc)
+        opt[:start_time] ||= Time.now
+
+        def block_filter(filter, block)
+          if filter.is_a? Symbol
+            filters = {
+              :kernel_process => /\A(kworker|ksoftirqd|migration|watchdog|kintegrityd|kblockd|events|kondemand|aio|crypto|ata|kmpathd|kconservative|rpciod|xfslogd|xfsdatad|xfsconvertd)\//
+            }
+            raise ArgumentError.new("Invalid filter: #{filter.inspect}") unless filters[filter]
+            filter = filters[filter]
+          elsif filter.is_a? Regexp
+            filter = filter
+          else
+            raise ArgumentError.new("Invalid filter: #{filter.inspect}")
+          end
+
+          block = block.select do |record|
+            ! (record[:command] =~ filter)
+          end
+        end
+
+        def parse_block(block, opt)
+          y = opt[:start_time].year
+          m = opt[:start_time].month
+          d = opt[:start_time].day
+
+          lines = block.lines.map(&:strip)
+          head_line = lines.shift
+
+          unless head_line =~ /(\d{2}):(\d{2}):(\d{2})/
+            raise ArgumentError.new("Invalid top(3) data")
+          end
+          time = Time.local(y, m, d, $~[1].to_i, $~[2].to_i, $~[3].to_i)
+
+          while ! (lines[0] =~ /\APID/)
+            line = lines.shift
+          end
+          labels = lines.shift.split.map do |key|
+            {"PID" => :pid, "USER" => :user, "PR" => :pr, "NI" => :ni,
+              "VIRT" => :virt, "RES" => :res, "SHR" => :shr, "S" => :s,
+              "%CPU" => :cpu, "%MEM" => :mem, "TIME+" => :time_plus,
+              "COMMAND" => :command}[key] || key
+          end
+
+          lines = lines.select{|line| ! line.empty?}
+          records = lines.map do |line|
+            record = Hash.new
+            record[:time] = time
+            line.split.each_with_index do |val, idx|
+              key = labels[idx]
+              if val =~ /\A(\d+)([mg]?)\Z/
+                record[key] = Integer($~[1])
+                if ! $~[2].empty?
+                  record[key] *= {'g' => 2**20, 'm' => 2**10}[$~[2]]
+                end
+              elsif val =~ /\A(\d+\.\d+)([mg]?)\Z/
+                record[key] = Float($~[1])
+                if ! $~[2].empty?
+                  record[key] *= {'g' => 2**20, 'm' => 2**10}[$~[2]]
+                end
+              elsif val =~ /\A(\d+):(\d+\.\d+)\Z/
+                record[key] = Integer($~[1])*60 + Float($~[2])
+              else
+                record[key] = val
+              end
+            end
+
+            record
+          end
+
+          if opt[:filter]
+            records = block_filter(opt[:filter], records)
+          end
+
+          if opt[:top_k]
+            records = records.first(opt[:top_k])
+          end
+
+          records
+        end
+
+        File.open(io_or_filepath, "r").read.split("\n\n\n").map do |block|
+          parse_block(block, opt)
+        end
+      end
+    end
   end
 end