viiite 0.1.0 → 0.2.0

data/lib/viiite/bdb.rb

@@ -0,0 +1,28 @@
+require 'fileutils'
+require 'viiite/bdb/utils'
+require 'viiite/bdb/immediate'
+require 'viiite/bdb/cached'
+module Viiite
+  class BDB
+    include Utils
+
+    DEFAULT_OPTIONS = {
+      :folder       => "benchmarks",
+      :cache        => true,
+      :cache_mode   => "w",
+      :pattern      => "**/*.rb",
+    }
+
+    def self.new(options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+      folder = options[:folder]
+      bdb = BDB::Immediate.new(folder, options[:pattern])
+      if cache = options[:cache]
+        cache = File.join(folder, '.cache') unless cache.is_a?(String)
+        bdb = BDB::Cached.new(bdb, cache, options[:cache_mode])
+      end
+      bdb
+    end
+
+  end # class BDB
+end # module Viiite

data/lib/viiite/bdb/cached.rb

@@ -0,0 +1,63 @@
+module Viiite
+  class BDB
+    class Cached < SimpleDelegator
+      include Utils
+
+      attr_reader :cache_folder
+      attr_reader :cache_mode
+
+      def initialize(delegate, cache_folder, cache_mode = "w")
+        super delegate
+        @cache_folder = cache_folder
+        @cache_mode   = cache_mode
+      end
+
+      def cached?
+        true
+      end
+
+      def benchmark(name)
+        bench = super(name)
+        cache = cache_file(name)
+        Proxy.new(bench, cache, cache_mode)
+      end
+
+      def dataset(name)
+        if File.exists?(cache_file = cache_file(name))
+          Alf::Reader.reader(cache_file, self)
+        else
+          benchmark(name)
+        end
+      end
+
+      private
+
+      def cache_file(name)
+        bench_file(cache_folder, name, ".rash")
+      end
+
+      class Proxy < DelegateClass(Benchmark)
+        include Alf::Iterator
+
+        def initialize(benchmark, cache_file, cache_mode)
+          @benchmark  = benchmark
+          @cache_file = cache_file
+          @cache_mode = cache_mode
+          super(@benchmark)
+        end
+
+        def each
+          FileUtils.mkdir_p(File.dirname(@cache_file))
+          File.open(@cache_file, @cache_mode) do |io|
+            @benchmark.each do |tuple|
+              io << Alf::Tools.to_ruby_literal(tuple) << "\n"
+              yield(tuple)
+            end
+          end
+        end
+
+      end # class Proxy
+
+    end # class Cached
+  end # class BDB
+end # module Viiite

data/lib/viiite/bdb/immediate.rb

@@ -0,0 +1,46 @@
+module Viiite
+  class BDB
+    class Immediate
+      include Utils
+      include Alf::Iterator
+
+      attr_reader :folder
+
+      def initialize(folder, pattern = DEFAULT_OPTIONS[:pattern])
+        @folder = folder
+        if pattern =~ /(\.\w+)$/
+          @pattern = pattern
+          @ext = $1
+        else
+          raise InvalidPattern, "The benchmark suite pattern must end with a unique extension " <<
+                                "(for deducing benchmark file from name): #{pattern}"
+        end
+      end
+
+      def each
+        Dir[File.join(folder, @pattern)].each do |f|
+          yield(:name => f[1+folder.size..-1-@ext.size], :file => f)
+        end
+      end
+
+      def cached?
+        false
+      end
+
+      def benchmark(name)
+        if File.exists?(file = bench_file(folder, name.to_s, @ext))
+          return Alf::Reader.reader(file, self)
+        else
+          raise NoSuchBenchmarkError, "No such benchmark #{name}"
+        end
+      end
+
+      def dataset(name)
+        benchmark(name)
+      rescue NoSuchBenchmarkError => ex
+        raise Alf::NoSuchDatasetError, ex.message, ex.backtrace
+      end
+
+    end # class Immediate
+  end # class BDB
+end # module Viiite

data/lib/viiite/bdb/utils.rb

@@ -0,0 +1,16 @@
+module Viiite
+  class BDB
+    module Utils
+
+      def replace_extension(file, ext)
+        old_ext = File.extname(file)
+        "#{file[0..-(1+old_ext.size)]}#{ext}"
+      end
+
+      def bench_file(folder, name, ext)
+        File.join(folder, replace_extension(name, ext))
+      end
+
+    end # module Utils
+  end # class BDB
+end # module Viiite

data/lib/viiite/benchmark.rb

@@ -0,0 +1,35 @@
+require 'viiite/benchmark/runner'
+module Viiite
+  class Benchmark
+    include Runner
+    include Alf::Iterator
+
+    attr_reader :definition
+
+    def initialize(definition)
+      @definition = definition
+    end
+
+    @benchmarks = []
+    def self.new(arg, *others)
+      case arg
+      when String
+        load File.expand_path(arg)
+        @benchmarks.pop
+      when IO, StringIO
+        Kernel.eval(arg.read, TOPLEVEL_BINDING)
+        @benchmarks.pop
+      else
+        bench = super(arg)
+        @benchmarks << bench
+        bench
+      end
+    end
+
+    def each(&reporter)
+      self.dup._each(&reporter)
+    end
+
+    Alf::Reader.register(:viiite, [".viiite", ".rb"], self)
+  end # class Benchmark
+end # module Viiite

data/lib/viiite/benchmark/runner.rb

@@ -0,0 +1,50 @@
+module Viiite
+  class Benchmark
+    module Runner
+
+      def with(hash)
+        if block_given?
+          org_tuple = @tuple
+          @tuple = org_tuple.merge(hash)
+          res = yield
+          @tuple = org_tuple
+          res
+        else
+          @tuple.merge!(hash)
+        end
+      end
+
+      def range_over(range, name)
+        range.each do |value|
+          with(name => value){ yield value }
+        end
+      end
+
+      def variation_point(name, value, &proc)
+        with({name => value}, &proc)
+      end
+
+      def report(hash = {}, &block)
+        hash = {:bench => hash.to_sym} unless hash.is_a?(Hash)
+        with(hash) {
+          GC.start
+          tms = Viiite.measure(&block)
+          with(:tms => tms){ output }
+        }
+      end
+
+      protected
+
+      def _each(&reporter)
+        @tuple, @reporter = {}, reporter
+        self.instance_eval(&definition)
+        @tuple, @reporter = nil, nil
+      end
+
+      def output
+        @reporter.call @tuple.dup
+      end
+
+    end # module Runner
+  end # class Benchmark
+end # module Viiite

data/lib/viiite/command.rb

@@ -21,7 +21,7 @@ module Viiite
 
     # Install options
     options do |opt|
-      opt.on("-Idirectory", 
+      opt.on("-Idirectory",
              "specify $LOAD_PATH directory (may be used more than once)") do |val|
         $LOAD_PATH.unshift val
       end
@@ -29,6 +29,32 @@ module Viiite
              "require the library, before executing viiite") do |lib|
         require(lib)
       end
+
+      @bdb_options = {}
+      opt.on('--suite=FOLDER',
+             "Specify the folder of the benchmark suite (defaults to 'benchmarks')") do |val|
+        unless File.directory?(val)
+          raise Quickl::InvalidArgument, "Missing folder #{val}"
+        end
+        @bdb_options[:folder] = val
+      end
+      opt.on('--pattern=GLOB',
+             "Specify the pattern to find benchmarks in the suite folder (defaults to '**/*.rb')") do |glob|
+        @bdb_options[:pattern] = glob
+      end
+      opt.on('--[no-]cache=[FOLDER]',
+             'Specify the cache heuristic and folder (defaults to --cache)') do |folder|
+        @bdb_options[:cache] = folder
+      end
+      opt.on('--cache-mode=MODE',
+             'Specify the exact mode for accessing cache files') do |mode|
+        @bdb_options[:cache_mode] = mode
+      end
+      opt.on('-a', '--append',
+             "Shortcut to --cache-mode=a"){ @bdb_options[:cache_mode] = 'a' }
+      opt.on('-w', '--write',
+             "Shortcut to --cache-mode=w"){ @bdb_options[:cache_mode] = 'w' }
+
       opt.on_tail("--help", "Show help") do
         raise Quickl::Help
       end
@@ -36,9 +62,14 @@ module Viiite
         raise Quickl::Exit, "viiite #{Viiite::VERSION} (c) 2011, Bernard Lambeau"
       end
     end
-    
+
+    def bdb
+      @bdb ||= BDB.new(@bdb_options)
+    end
+
   end # class Command
 end # module Viiite
+require "viiite/command/commons"
 require "viiite/command/help"
 require "viiite/command/run"
 require "viiite/command/report"

data/lib/viiite/command/commons.rb

@@ -0,0 +1,22 @@
+module Viiite
+  class Command
+    module Commons
+
+      def single_source(argv)
+        raise Quickl::InvalidArgument if argv.size > 1
+        if arg = argv.first
+          if File.exists?(arg.to_s)
+            Alf::Reader.reader(arg.to_s)
+          elsif requester && requester.respond_to?(:bdb)
+            block_given? ? yield(requester.bdb, arg) : requester.bdb.dataset(arg)
+          else
+            raise Quickl::InvalidArgument, "Missing benchmark #{arg}"
+          end
+        else
+          Alf::Reader.reader($stdin)
+        end
+      end
+
+    end # module Commons
+  end # class Command
+end # module Viiite

data/lib/viiite/command/help.rb

@@ -1,24 +1,23 @@
 module Viiite
   class Command
-    # 
+    #
     # Show help about a specific command
     #
     # SYNOPSIS
     #   viiite #{command_name} COMMAND
     #
     class Help < Quickl::Command(__FILE__, __LINE__)
-      
+
       # Let NoSuchCommandError be passed to higher stage
       no_react_to Quickl::NoSuchCommand
-      
+
       # Command execution
       def execute(args)
         sup = Quickl.super_command(self)
         sub = (args.size != 1) ? sup : Quickl.sub_command!(sup, args.first)
         puts Quickl.help(sub)
       end
-      
+
     end # class Help
   end # class Command
 end # module Viiite
-

data/lib/viiite/command/plot.rb

@@ -1,6 +1,6 @@
 module Viiite
   class Command < Quickl::Delegator(__FILE__, __LINE__)
-    # 
+    #
     # Report benchmarking results as a plot
     #
     # SYNOPSIS
@@ -10,35 +10,27 @@ module Viiite
     # #{summarized_options}
     #
     class Plot < Quickl::Command(__FILE__, __LINE__)
-    
+      include Commons
+
       # Install options
       options do |opt|
         @render = :text
-        opt.on('--text', "Render output as a text table") do
-          @render = :text
-        end
 
-        opt.on("--gnuplot=[TERM]", 
-               "Render output as a gnuplot text (and terminal)") do |value|
-          @render = :gnuplot
-          @term = (value || "dumb").to_sym
+        @serie_style = nil
+        opt.on('--serie-style=FILE', "Specify a style file to use for series") do |value|
+          @serie_style = load_style(value)
         end
-        
-        @serie_style = File.expand_path("../serie_style.rash", __FILE__)
-        opt.on('--style=FILE', "Specify a style file to use for series") do |value|
-          @serie_style = value
-        end
-        
-        @graph_style = File.expand_path("../graph_style.rash", __FILE__)
-        opt.on('--style=FILE', "Specify a style file to use for graphs") do |value|
-          @graph_style = value
+
+        @graph_style = nil
+        opt.on('--graph-style=FILE', "Specify a style file to use for graphs") do |value|
+          @graph_style = load_style(value)
         end
-        
+
         @abscissa = :size
         opt.on('-x abscissa', "Specify the abscissa attribute") do |value|
           @abscissa = value.to_sym
         end
-        
+
         @ordinate = "tms.total"
         opt.on('-y ordinate', "Specify the ordinate attribute") do |value|
           @ordinate = value
@@ -51,38 +43,46 @@ module Viiite
         end
 
         @graph = :ruby
-        opt.on('--graph=ATTR', 
+        opt.on('--graph=ATTR',
                "Specify the attribute to split graphs") do |value|
           @graph = value.to_sym
         end
+
+        @debug = false
+        opt.on('-d',
+               'Print the query result instead of rendering') do
+          @debug = true
+        end
       end
-    
-      def query(op)
-        lispy = Alf.lispy
-        op = lispy.summarize(op, [@graph, @series, @abscissa].compact, 
-                                 {:y => "avg{ #{@ordinate} }"})
-        op = lispy.join(op, Alf::Reader.reader(@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, Alf::Reader.reader(@graph_style))
-        op = lispy.rename(op, :graph => :title)
-        op
+
+      def load_style(file, reference = nil)
+        if reference
+          file = File.join("..", file)
+          file = File.expand_path(file, reference)
+        end
+        if File.extname(file) == ".rb"
+          Kernel.eval(File.read(file))
+        else
+          Alf::Reader.reader(file).to_rel
+        end
       end
-      
-      def execute(args)
-        raise Quickl::InvalidArgument if args.size > 1
-        op = query Alf::Reader.reader(args.first || $stdin)
-        case @render
-        when :text
+
+      def execute(argv)
+        lispy = Alf.lispy
+        op = single_source(argv) do |bdb, arg|
+          bdb.dataset(arg)
+        end
+        op = send(:"to_#{@render}_query", lispy, op)
+        if @debug
           Alf::Renderer.text(op).execute($stdout)
-        when :gnuplot
-          $stdout << "set terminal #{@term}\n"
-          Viiite::Formatter::Plot::to_plots(op.to_a, $stdout)
+        else
+          send(:"to_#{@render}", lispy, op)
         end
       end
-    
+
     end # class Plot
   end # class Command
 end # module Viiite
+require 'viiite/command/plot/to_text'
+require 'viiite/command/plot/to_gnuplot'
+require 'viiite/command/plot/to_highcharts'