viiite 0.1.0 → 0.2.0

data/lib/viiite/command/plot/to_gnuplot.rb

@@ -0,0 +1,65 @@
+module Viiite
+  class Command
+    class Plot
+
+      options do |opt|
+        opt.on("--gnuplot=[TERM]",
+               "Render output as a gnuplot text (and terminal)") do |value|
+          @render = :gnuplot
+          @gnuplot_term = (value || "dumb").to_sym
+          @graph_style = load_style("to_gnuplot_graph.rash", __FILE__) unless @graph_style
+          @serie_style = load_style("to_gnuplot_serie.rash", __FILE__) unless @serie_style
+        end
+      end
+
+      def to_gnuplot_query(lispy, op)
+        lispy = Alf.lispy
+        op = lispy.summarize(op, [@graph, @series, @abscissa].compact,
+                                 {:y => "avg{ #{@ordinate} }"})
+        op = lispy.join(op, @serie_style) if @serie_style
+        op = lispy.rename(op, @graph  => :graph, @abscissa => :x, @series => :serie)
+        op = lispy.group(op, [:x, :y], :data)
+        op = lispy.rename(op, :serie => :title)
+        op = lispy.group(op, [:graph], :series, {:allbut => true})
+        op = lispy.join(op, @graph_style) if @graph_style
+        op = lispy.rename(op, :graph => :title)
+        op
+      end
+
+      def to_gnuplot(lispy, op)
+        puts "set terminal #{@gnuplot_term}"
+        GnuplotUtils.to_plots(op.to_a, $stdout)
+      end
+
+      module GnuplotUtils
+        extend self
+        def to_data(rel)
+          [rel.collect{|t| t[:x]}, rel.collect{|t| t[:y]}]
+        end
+        def to_dataset(tuple)
+          ds = Gnuplot::DataSet.new(to_data(tuple[:data]))
+          tuple.each_pair do |k,v|
+            next if k == :data
+            ds.send(:"#{k}=", v) if ds.respond_to?(:"#{k}=")
+          end
+          ds
+        end
+        def to_plot(graph)
+          Gnuplot::Plot.new do |plot|
+            graph.each_pair do |k,v|
+              next if k == :series
+              plot.set(k.id2name, v)
+            end
+            plot.data = graph[:series].collect{|d| to_dataset(d)}
+          end
+        end
+        def to_plots(graphs, buffer = "")
+          graphs.each do |tuple|
+            buffer << to_plot(tuple).to_gplot << "\n"
+          end
+        end
+      end # module Utils
+
+    end # class Plot
+  end # class Command
+end # module Viiite

data/lib/viiite/command/plot/to_highcharts.rb

@@ -0,0 +1,38 @@
+module Viiite
+  class Command
+    class Plot
+
+      options do |opt|
+        opt.on("--highcharts=[TERM]",
+               "Render output for highcharts.js") do |value|
+          @render = :highcharts
+          @highcharts_term = (value || "json").to_sym
+          @graph_style = load_style("to_highcharts_graph.rb", __FILE__) unless @graph_style
+        end
+      end
+
+      def to_highcharts_query(lispy, op)
+        lispy = Alf.lispy
+        op = lispy.summarize(op, [@graph, @series, @abscissa].compact,
+                                 {:y => "avg{ #{@ordinate} }"})
+        op = lispy.rename(op, @graph  => :graph, @abscissa => :x, @series => :serie)
+        op = lispy.summarize(op,
+                             [:x, :y],
+                             {:data => lispy.collect{ [x, y] }},
+                             {:allbut => true})
+        op = lispy.rename(op, :serie => :name)
+        op = lispy.group(op, [:name, :data], :series)
+        op = lispy.join(op, @graph_style) if @graph_style
+        op = lispy.extend(op, :title => lambda{ title.merge(:text => graph) })
+        op = lispy.project(op, [:graph], {:allbut => true})
+        op
+      end
+
+      def to_highcharts(lispy, op)
+        require 'json'
+        puts op.to_a.to_json
+      end
+
+    end # class Plot
+  end # class Command
+end # module Viiite

data/lib/viiite/command/plot/to_highcharts_graph.rb

@@ -0,0 +1,29 @@
+Alf::Relation[{
+  :chart => {
+    :renderTo          => 'container',
+    :defaultSeriesType => 'line',
+    :marginRight       => 170,
+    :marginBottom      => 25
+  },
+  :title => {
+    :x => -20
+  },
+  :yAxis => {
+    :title => {
+      :text => 'Time (sec.)'
+    },
+    :plotLines => [{
+      :value => 0,
+      :width => 1,
+      :color => '#808080'
+    }]
+  },
+  :legend => {
+    :layout => 'vertical',
+    :align  => 'right',
+    :verticalAlign => 'top',
+    :x => -10,
+    :y => 100,
+    :borderWidth => 0
+  }
+}]

data/lib/viiite/command/plot/to_text.rb

@@ -0,0 +1,30 @@
+module Viiite
+  class Command
+    class Plot
+
+      options do |opt|
+        @render = :text
+        opt.on('--text', "Render output as a text table") do
+          @render = :text
+        end
+      end
+
+      def to_text_query(lispy, op)
+        lispy = Alf.lispy
+        op = lispy.summarize(op, [@graph, @series, @abscissa].compact,
+                                 {:y => "avg{ #{@ordinate} }"})
+        op = lispy.rename(op, @graph  => :graph, @abscissa => :x, @series => :serie)
+        op = lispy.group(op, [:x, :y], :data)
+        op = lispy.rename(op, :serie => :title)
+        op = lispy.group(op, [:graph], :series, {:allbut => true})
+        op = lispy.rename(op, :graph => :title)
+        op
+      end
+
+      def to_text(lispy, op)
+        Alf::Renderer.text(op).execute($stdout)
+      end
+
+    end # class Plot
+  end # class Command
+end # module Viiite

data/lib/viiite/command/report.rb

@@ -10,6 +10,7 @@ module Viiite
     # #{summarized_options}
     #
     class Report < Quickl::Command(__FILE__, __LINE__)
+      include Commons
 
       options do |opt|
 
@@ -20,28 +21,49 @@ module Viiite
         end
 
         @hierarchy = false
-        opt.on('-h', "--hierarchy", "Make a hierarchical regrouping") do
+        opt.on('-h', "--hierarchy",
+               "Make a hierarchical regrouping") do
           @hierarchy = true
         end
 
+        @stddev = false
+        opt.on("--stddev=[FIELD]",
+               "Add the standard deviation on FIELD") do |field|
+          @stddev = field || "tms.total"
+        end
+
+        @ff = "%.6f"
+        opt.on("--ff=FORMAT",
+               "Specify the floating point format") do |val|
+          @ff = val
+        end
       end
 
       def query(op)
         lispy = Alf.lispy
-        op = lispy.summarize(op, @regroup, :measure => lispy.avg{tms})
-        @regroup[1..-1].each do |grouping|
-          op = lispy.group(op, [grouping] + [:measure], :measure)
-        end if @hierarchy 
+        aggs = {:user   => lispy.avg{tms.utime},
+                :system => lispy.avg{tms.stime},
+                :total  => lispy.avg{tms.total},
+                :real   => lispy.avg{tms.real}}
+        aggs[:stddev] = "stddev{ #{@stddev} }" if @stddev
+        op = lispy.summarize(op, @regroup, aggs)
+        depend = [:user, :system, :total, :real]
+        depend += [:stddev] if @stddev
+        @regroup[1..-1].reverse.each do |grouping|
+          op = lispy.group(op, [grouping] + depend, :measure)
+          depend = [:measure]
+        end if @hierarchy
         op
       end
 
-      def execute(args)
-        raise Quickl::InvalidArgument if args.size > 1
-        op = query Alf::Reader.reader(args.first || $stdin)
-        Alf::Renderer.text(op).execute($stdout)
+      def execute(argv)
+        op = single_source(argv) do |bdb, arg|
+          bdb.dataset(arg)
+        end
+        op = query(op)
+        Alf::Renderer.text(op, {:float_format => @ff}).execute($stdout)
       end
 
     end # class Report
   end # class Command
 end # module Viiite
-

data/lib/viiite/command/run.rb

@@ -1,6 +1,6 @@
 module Viiite
   class Command
-    # 
+    #
     # Run a benchmark and output raw data
     #
     # SYNOPSIS
@@ -10,12 +10,35 @@ module Viiite
     # #{summarized_options}
     #
     class Run < Quickl::Command(__FILE__, __LINE__)
-      
-      def execute(args)
-        raise Quickl::InvalidArgument if args.size > 1
-        input  = Alf::Reader.reader(args.first || $stdin)
-        output = $stdout
-        Alf::Renderer.rash(input).execute(output)
+      include Commons
+
+      options do |opt|
+        @runs = 1
+        opt.on("--runs=[NB]",
+               "Run the benchmark NB times") do |val|
+          @runs = val.to_i
+          @run_key = :run unless @run_key
+        end
+        @run_key = nil
+        opt.on("--run-key=[KEY]",
+               "Specify the run key (default to :run)") do |val|
+          @run_key = val.to_sym
+        end
+      end
+
+      def execute(argv)
+        argv = requester.bdb.to_rel.collect{|t| t[:name]} if argv.empty?
+        argv.each do |name|
+          benchmark = single_source([name]) do |bdb, arg|
+            bdb.benchmark(arg)
+          end
+          @runs.times do |run|
+            benchmark.each do |tuple|
+              tuple[@run_key] = run if @run_key
+              puts Alf::Tools.to_ruby_literal(tuple)
+            end
+          end
+        end
       end
 
     end # class Run

data/lib/viiite/errors.rb

@@ -0,0 +1,5 @@
+module Viiite
+  class Error < StandardError; end
+  class NoSuchBenchmarkError < Error; end
+  class InvalidPattern < Error; end
+end

data/lib/viiite/loader.rb

@@ -1,3 +1,3 @@
 require "alf"
-require "quickl"
-require "gnuplot"
+require "gnuplot"
+require "json"

data/lib/viiite/tms.rb

@@ -1,36 +1,30 @@
 module Viiite
-  class Tms
+  class Tms < Struct.new(:utime, :stime, :cutime, :cstime, :real)
 
     FMTSTR = "%10.6u %10.6y %10.6t %10.6r"
-    FIELDS = [:utime, :stime, :cutime, :cstime, :real]
 
-    def initialize(tms)
-      @tms = tms
+    def initialize(utime, stime, cutime, cstime, real)
+      super # ensure we have all 5 non-nil arguments
     end
 
     def self.coerce(arg)
       case arg
       when Viiite::Tms
         arg
-      when Benchmark::Tms
-        Viiite::Tms.new arg.to_a[1..-1]
       when Numeric
-        Viiite::Tms.new [arg, 0.0, 0.0, 0.0, 0.0]
+        Viiite::Tms.new arg, 0.0, 0.0, 0.0, 0.0
       when Hash
-        Viiite::Tms.new FIELDS.collect{|f| arg[f] || 0.0}
+        Viiite::Tms.new(*members.collect{|f| arg[f] || 0.0})
       when Array
-        Viiite::Tms.new arg
+        Viiite::Tms.new(*arg)
       else
         raise ArgumentError, "Invalid value #{arg.inspect} for Viiite::Tms"
       end
     end
 
-    def utime;  @tms[0]; end
-    def stime;  @tms[1]; end
-    def cutime; @tms[2]; end
-    def cstime; @tms[3]; end
-    def real;   @tms[4]; end
-    def total;  cutime + cstime + stime + utime; end
+    def total
+      cutime + cstime + stime + utime
+    end
 
     def to_ruby_literal
       "Viiite::Tms(#{to_a.collect{|f| f.inspect}.join(',')})"
@@ -46,22 +40,9 @@ module Viiite
     end
 
     def to_h
-      @to_h ||= Hash[FIELDS.collect{|f| [f, send(f)]}]
-    end
-
-    def to_a
-      @to_a ||= FIELDS.collect{|f| send(f)}
-    end
-
-    def hash
-      to_a.hash
+      @to_h ||= Hash[members.zip(values)]
     end
 
-    def ==(other)
-      other.is_a?(Tms) && (other.to_a == self.to_a)
-    end
-    alias :eql? :==
-
     def format(arg0 = nil, *args)
       fmtstr = (arg0 || FMTSTR).dup
       fmtstr.gsub!(/(%[-+\.\d]*)u/){"#{$1}f" % utime}
@@ -79,11 +60,20 @@ module Viiite
     def memberwise(op, x)
       case x
       when Viiite::Tms
-        Viiite::Tms.new FIELDS.collect{|f| __send__(f).__send__(op, x.send(f))}
+        Viiite::Tms.new(*values.zip(x.values).collect {|a,b| a.send(op, b)})
       else
-        Viiite::Tms.new FIELDS.collect{|f| __send__(f).__send__(op, x)}
+        Viiite::Tms.new(*values.collect{|v| v.send(op, x)})
       end
     end
 
+    if RUBY_VERSION < '1.9'
+      public
+      def members; super.map(&:to_sym); end
+      def self.members; super.map(&:to_sym); end
+    end
   end # class Tms
+
+  def self.Tms(*args)
+    Viiite::Tms.new(*args)
+  end
 end # module Viiite

data/lib/viiite/version.rb

@@ -1,14 +1,14 @@
 module Viiite
   module Version
-  
+
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
-  
+
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')
     end
-  
-  end 
+
+  end
   VERSION = Version.to_s
 end

data/spec/fixtures/bdb/Array/bench_sort.rb

@@ -0,0 +1,7 @@
+Viiite.bench do |b|
+  b.variation_point :ruby, Viiite.which_ruby
+  b.range_over([100, 1000], :size) do |size|
+    bench_case = Array.new(size) { rand }
+    b.report(:"Array#sort") { bench_case.sort }
+  end
+end

data/spec/fixtures/{bench_iteration.rb → bdb/bench_iteration.rb}

@@ -1,9 +1,7 @@
-require 'viiite'
-n = 15000
-Viiite.bm do |r|
+Viiite.bench do |r|
+  n = 1000
   r.variation_point :ruby, Viiite.which_ruby
   r.report(:for)   { for i in 1..n; a = "1"; end }
   r.report(:times) { n.times do   ; a = "1"; end }
   r.report(:upto)  { 1.upto(n) do ; a = "1"; end }
 end
-

data/spec/fixtures/command/bench_iteration.rb

@@ -0,0 +1,3 @@
+Viiite.bench do |r|
+  r.report(:times) { 15.times do; a = "1"; end }
+end

data/spec/fixtures/saved/Array/bench_sort.rash

@@ -0,0 +1,12 @@
+{:ruby => "jruby 1.6.3", :size => 100, :bench => :"Array#sort", :tms => Viiite::Tms(0.00200009346008301,0.0,0.0,0.0,0.00200009346008301)}
+{:ruby => "jruby 1.6.3", :size => 1000, :bench => :"Array#sort", :tms => Viiite::Tms(0.0189998149871826,0.0,0.0,0.0,0.0199999809265137)}
+{:size => 100, :bench => :"Array#sort", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00038504600524902344), :ruby => "rubinius 2.0.0dev"}
+{:size => 1000, :bench => :"Array#sort", :tms => Viiite::Tms(0.0040000000000000036,0.0,0.0,0.0,0.005118131637573242), :ruby => "rubinius 2.0.0dev"}
+{:bench => :"Array#sort", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,8.20159912109375e-05), :size => 100, :ruby => "ruby 1.8.7"}
+{:bench => :"Array#sort", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00109100341796875), :size => 1000, :ruby => "ruby 1.8.7"}
+{:ruby => "rubinius 1.2.5dev", :size => 100, :bench => :"Array#sort", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0003991127014160156)}
+{:ruby => "rubinius 1.2.5dev", :size => 1000, :bench => :"Array#sort", :tms => Viiite::Tms(0.02800199999999997,0.0,0.0,0.0,0.04252505302429199)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :bench => :"Array#sort", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,8.368492126464844e-05)}
+{:ruby => "ruby 1.9.3dev", :size => 1000, :bench => :"Array#sort", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0011630058288574219)}
+{:ruby => "ruby 1.9.2p290", :size => 100, :bench => :"Array#sort", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,8.0108642578125e-05)}
+{:ruby => "ruby 1.9.2p290", :size => 1000, :bench => :"Array#sort", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0011208057403564453)}