viiite 0.1.0

data/examples/bench_sort.rash

@@ -0,0 +1,100 @@
+{:bench => :quicksort, :i => 1, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.000931978225708008)}
+{:bench => :bubblesort, :i => 1, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.02,0.0,0.0,0.0,0.0198590755462646)}
+{:bench => :quicksort, :i => 2, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.000818967819213867)}
+{:bench => :bubblesort, :i => 2, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.00999999999999998,0.0,0.0,0.0,0.0110490322113037)}
+{:bench => :quicksort, :i => 3, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.000854969024658203)}
+{:bench => :bubblesort, :i => 3, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.0112569332122803)}
+{:bench => :quicksort, :i => 4, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.000792026519775391)}
+{:bench => :bubblesort, :i => 4, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.02,0.0,0.0,0.0,0.0127270221710205)}
+{:bench => :quicksort, :i => 5, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.000833034515380859)}
+{:bench => :bubblesort, :i => 5, :size => 100, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.010761022567749)}
+{:bench => :quicksort, :i => 1, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00189709663391113)}
+{:bench => :bubblesort, :i => 1, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.06,0.0,0.0,0.0,0.051987886428833)}
+{:bench => :quicksort, :i => 2, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0019068717956543)}
+{:bench => :bubblesort, :i => 2, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.06,0.0,0.0,0.0,0.0540499687194824)}
+{:bench => :quicksort, :i => 3, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00184392929077148)}
+{:bench => :bubblesort, :i => 3, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.06,0.0,0.0,0.0,0.053170919418335)}
+{:bench => :quicksort, :i => 4, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00193214416503906)}
+{:bench => :bubblesort, :i => 4, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.06,0.0,0.0,0.0,0.0532131195068359)}
+{:bench => :quicksort, :i => 5, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00188493728637695)}
+{:bench => :bubblesort, :i => 5, :size => 200, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.04,0.0,0.0,0.0,0.0441248416900635)}
+{:bench => :quicksort, :i => 1, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.0118849277496338)}
+{:bench => :bubblesort, :i => 1, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.12,0.0,0.0,0.0,0.11739706993103)}
+{:bench => :quicksort, :i => 2, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0030369758605957)}
+{:bench => :bubblesort, :i => 2, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.12,0.0,0.0,0.0,0.120995044708252)}
+{:bench => :quicksort, :i => 3, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00286102294921875)}
+{:bench => :bubblesort, :i => 3, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.12,0.0,0.0,0.0,0.117074012756348)}
+{:bench => :quicksort, :i => 4, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00310397148132324)}
+{:bench => :bubblesort, :i => 4, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.11,0.0,0.0,0.0,0.112523078918457)}
+{:bench => :quicksort, :i => 5, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00554203987121582)}
+{:bench => :bubblesort, :i => 5, :size => 300, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.12,0.0,0.0,0.0,0.116988897323608)}
+{:bench => :quicksort, :i => 1, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.00453591346740723)}
+{:bench => :bubblesort, :i => 1, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.19,0.0,0.0,0.0,0.197253942489624)}
+{:bench => :quicksort, :i => 2, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.00448203086853027)}
+{:bench => :bubblesort, :i => 2, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.21,0.0,0.0,0.0,0.26711893081665)}
+{:bench => :quicksort, :i => 3, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.00516200065612793)}
+{:bench => :bubblesort, :i => 3, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.2,0.0,0.0,0.0,0.215794086456299)}
+{:bench => :quicksort, :i => 4, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00426316261291504)}
+{:bench => :bubblesort, :i => 4, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.21,0.0,0.0,0.0,0.210376024246216)}
+{:bench => :quicksort, :i => 5, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.00404000282287598)}
+{:bench => :bubblesort, :i => 5, :size => 400, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.2,0.0,0.0,0.0,0.198137998580933)}
+{:bench => :quicksort, :i => 1, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0100000000000002,0.0,0.0,0.0,0.0057070255279541)}
+{:bench => :bubblesort, :i => 1, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.31,0.0,0.0,0.0,0.315191030502319)}
+{:bench => :quicksort, :i => 2, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.00999999999999979,0.0,0.0,0.0,0.00527501106262207)}
+{:bench => :bubblesort, :i => 2, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.31,0.0,0.0,0.0,0.315762042999268)}
+{:bench => :quicksort, :i => 3, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0100000000000002,0.0,0.0,0.0,0.0150480270385742)}
+{:bench => :bubblesort, :i => 3, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.32,0.0,0.0,0.0,0.317266941070557)}
+{:bench => :quicksort, :i => 4, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0100000000000002,0.0,0.0,0.0,0.00540494918823242)}
+{:bench => :bubblesort, :i => 4, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.32,0.0,0.0,0.0,0.3280189037323)}
+{:bench => :quicksort, :i => 5, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0100000000000002,0.0,0.0,0.0,0.0057520866394043)}
+{:bench => :bubblesort, :i => 5, :size => 500, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.31,0.0,0.0,0.0,0.31823205947876)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 1, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0004265308380126953)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 1, :bench => :bubblesort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0036416053771972656)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 2, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0003561973571777344)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 2, :bench => :bubblesort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.003675222396850586)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 3, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0003838539123535156)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 3, :bench => :bubblesort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0036492347717285156)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 4, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00033593177795410156)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 4, :bench => :bubblesort, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.003430604934692383)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 5, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0003409385681152344)}
+{:ruby => "ruby 1.9.3dev", :size => 100, :i => 5, :bench => :bubblesort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0037250518798828125)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 1, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0049359798431396484)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 1, :bench => :bubblesort, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.01381993293762207)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 2, :bench => :quicksort, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.0007574558258056641)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 2, :bench => :bubblesort, :tms => Viiite::Tms(0.020000000000000018,0.0,0.0,0.0,0.019170284271240234)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 3, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.000804901123046875)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 3, :bench => :bubblesort, :tms => Viiite::Tms(0.019999999999999962,0.0,0.0,0.0,0.019022464752197266)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 4, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0008702278137207031)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 4, :bench => :bubblesort, :tms => Viiite::Tms(0.020000000000000018,0.0,0.0,0.0,0.02009725570678711)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 5, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0008249282836914062)}
+{:ruby => "ruby 1.9.3dev", :size => 200, :i => 5, :bench => :bubblesort, :tms => Viiite::Tms(0.020000000000000018,0.0,0.0,0.0,0.01993274688720703)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 1, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0012989044189453125)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 1, :bench => :bubblesort, :tms => Viiite::Tms(0.03999999999999998,0.0,0.0,0.0,0.03730130195617676)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 2, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0013666152954101562)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 2, :bench => :bubblesort, :tms => Viiite::Tms(0.030000000000000027,0.0,0.0,0.0,0.037523508071899414)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 3, :bench => :quicksort, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.0013306140899658203)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 3, :bench => :bubblesort, :tms => Viiite::Tms(0.039999999999999925,0.0,0.0,0.0,0.039438724517822266)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 4, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0012905597686767578)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 4, :bench => :bubblesort, :tms => Viiite::Tms(0.040000000000000036,0.0,0.0,0.0,0.035891056060791016)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 5, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0013623237609863281)}
+{:ruby => "ruby 1.9.3dev", :size => 300, :i => 5, :bench => :bubblesort, :tms => Viiite::Tms(0.040000000000000036,0.0,0.0,0.0,0.03461289405822754)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 1, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.001710653305053711)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 1, :bench => :bubblesort, :tms => Viiite::Tms(0.06999999999999995,0.0,0.0,0.0,0.06537675857543945)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 2, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0019588470458984375)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 2, :bench => :bubblesort, :tms => Viiite::Tms(0.06999999999999995,0.0,0.0,0.0,0.06493997573852539)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 3, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0017993450164794922)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 3, :bench => :bubblesort, :tms => Viiite::Tms(0.07000000000000006,0.0,0.0,0.0,0.06435179710388184)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 4, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0017900466918945312)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 4, :bench => :bubblesort, :tms => Viiite::Tms(0.06999999999999995,0.0,0.0,0.0,0.06733965873718262)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 5, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0017752647399902344)}
+{:ruby => "ruby 1.9.3dev", :size => 400, :i => 5, :bench => :bubblesort, :tms => Viiite::Tms(0.07000000000000006,0.0,0.0,0.0,0.06759476661682129)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 1, :bench => :quicksort, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.0022673606872558594)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 1, :bench => :bubblesort, :tms => Viiite::Tms(0.09999999999999987,0.0,0.0,0.0,0.10301375389099121)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 2, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.0025730133056640625)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 2, :bench => :bubblesort, :tms => Viiite::Tms(0.1100000000000001,0.0,0.0,0.0,0.10222816467285156)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 3, :bench => :quicksort, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.028038501739501953)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 3, :bench => :bubblesort, :tms => Viiite::Tms(0.10000000000000009,0.0,0.0,0.0,0.10360383987426758)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 4, :bench => :quicksort, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.002351999282836914)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 4, :bench => :bubblesort, :tms => Viiite::Tms(0.08999999999999986,0.0,0.0,0.0,0.10294198989868164)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 5, :bench => :quicksort, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.00250244140625)}
+{:ruby => "ruby 1.9.3dev", :size => 500, :i => 5, :bench => :bubblesort, :tms => Viiite::Tms(0.10000000000000009,0.0,0.0,0.0,0.09821605682373047)}

data/examples/bench_sort.rb

@@ -0,0 +1,38 @@
+class Array
+
+  def self.random(size)
+    Array.new(size){ Kernel.rand }
+  end
+
+  def quicksort(list = self)
+     return list if list.nil? or list.size <= 1
+     less, more = list[1..-1].partition { |i| i < list[0] }
+     quicksort(less) + [list[0]] + quicksort(more)
+  end
+
+  def bubblesort(list = self)
+    slist = list.clone
+    for i in 0..(slist.length - 1)
+      for j in 0..(slist.length - i - 2)
+      	if ( slist[j + 1] <=> slist[j] ) == -1
+      		slist[j], slist[j + 1] = slist[j + 1], slist[j]
+      	end
+      end
+    end
+    slist
+  end
+
+end
+
+require 'viiite'
+Viiite.bm do |b|
+  b.variation_point :ruby, Viiite.which_ruby
+  b.range_over([100, 200, 300, 400, 500], :size) do |size|
+    b.range_over(1..5, :i) do
+      bench_case = Array.random(size)
+      b.report(:quicksort) { bench_case.quicksort }
+      b.report(:bubblesort){ bench_case.bubblesort }
+    end
+  end
+end
+

data/examples/raw.rash

@@ -0,0 +1,6 @@
+{:ruby => "ruby 1.9.2p136", :bench => :for, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.007596015930175781)}
+{:ruby => "ruby 1.9.2p136", :bench => :times, :tms => Viiite::Tms(0.009999999999999953,0.0,0.0,0.0,0.0069234371185302734)}
+{:ruby => "ruby 1.9.2p136", :bench => :upto, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.007051944732666016)}
+{:ruby => "ruby 1.9.2p136", :bench => :for, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.0076732635498046875)}
+{:ruby => "ruby 1.9.2p136", :bench => :times, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00760650634765625)}
+{:ruby => "ruby 1.9.2p136", :bench => :upto, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.007064342498779297)}

data/lib/viiite/command/graph_style.rash

@@ -0,0 +1 @@
+{:grid => nil}

data/lib/viiite/command/help.rb

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,88 @@
+module Viiite
+  class Command < Quickl::Delegator(__FILE__, __LINE__)
+    # 
+    # Report benchmarking results as a plot
+    #
+    # SYNOPSIS
+    #   viiite #{command_name} [BENCHFILE]
+    #
+    # OPTIONS
+    # #{summarized_options}
+    #
+    class Plot < Quickl::Command(__FILE__, __LINE__)
+    
+      # 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
+        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
+        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
+        end
+
+        @series = :bench
+        opt.on("--series=ATTR",
+               "Specify the attribute to split series") do |value|
+          @series = value.to_sym
+        end
+
+        @graph = :ruby
+        opt.on('--graph=ATTR', 
+               "Specify the attribute to split graphs") do |value|
+          @graph = value.to_sym
+        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
+      end
+      
+      def execute(args)
+        raise Quickl::InvalidArgument if args.size > 1
+        op = query Alf::Reader.reader(args.first || $stdin)
+        case @render
+        when :text
+          Alf::Renderer.text(op).execute($stdout)
+        when :gnuplot
+          $stdout << "set terminal #{@term}\n"
+          Viiite::Formatter::Plot::to_plots(op.to_a, $stdout)
+        end
+      end
+    
+    end # class Plot
+  end # class Command
+end # module Viiite

data/lib/viiite/command/report.rb

@@ -0,0 +1,47 @@
+module Viiite
+  class Command
+    #
+    # Report benchmarking results as a table
+    #
+    # SYNOPSIS
+    #   viiite #{command_name} [BENCHFILE]
+    #
+    # OPTIONS
+    # #{summarized_options}
+    #
+    class Report < Quickl::Command(__FILE__, __LINE__)
+
+      options do |opt|
+
+        @regroup = [:bench]
+        opt.on("--regroup=x,y,z", Array,
+               "Regroup by x, then y, then z, ...") do |group|
+          @regroup = group
+        end
+
+        @hierarchy = false
+        opt.on('-h', "--hierarchy", "Make a hierarchical regrouping") do
+          @hierarchy = true
+        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 
+        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)
+      end
+
+    end # class Report
+  end # class Command
+end # module Viiite
+

data/lib/viiite/command/run.rb

@@ -0,0 +1,23 @@
+module Viiite
+  class Command
+    # 
+    # Run a benchmark and output raw data
+    #
+    # SYNOPSIS
+    #   viiite #{command_name} [BENCHFILE]
+    #
+    # OPTIONS
+    # #{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)
+      end
+
+    end # class Run
+  end # class Command
+end # module Viiite

data/lib/viiite/command/serie_style.rash

@@ -0,0 +1 @@
+{:with => "linespoints"}

data/lib/viiite/command.rb

@@ -0,0 +1,45 @@
+module Viiite
+  #
+  # viiite - Benchmark ruby scripts the easy way
+  #
+  # SYNOPSIS
+  #   viiite [--version] [--help] COMMAND [cmd opts] ARGS...
+  #
+  # OPTIONS
+  # #{summarized_options}
+  #
+  # COMMANDS
+  # #{summarized_subcommands}
+  #
+  # DESCRIPTION
+  #   This command helps you benchmarking ruby applications and manipulating
+  #   benchmark results very simply.
+  #
+  # See 'viiite help COMMAND' for more information on a specific command.
+  #
+  class Command < Quickl::Delegator(__FILE__, __LINE__)
+
+    # Install options
+    options do |opt|
+      opt.on("-Idirectory", 
+             "specify $LOAD_PATH directory (may be used more than once)") do |val|
+        $LOAD_PATH.unshift val
+      end
+      opt.on('-rlibrary',
+             "require the library, before executing viiite") do |lib|
+        require(lib)
+      end
+      opt.on_tail("--help", "Show help") do
+        raise Quickl::Help
+      end
+      opt.on_tail("--version", "Show version") do
+        raise Quickl::Exit, "viiite #{Viiite::VERSION} (c) 2011, Bernard Lambeau"
+      end
+    end
+    
+  end # class Command
+end # module Viiite
+require "viiite/command/help"
+require "viiite/command/run"
+require "viiite/command/report"
+require "viiite/command/plot"

data/lib/viiite/formatter/plot.rb

@@ -0,0 +1,38 @@
+module Viiite
+  class Formatter
+    class Plot < Formatter
+
+      def self.to_data(rel)
+        [rel.collect{|t| t[:x]}, rel.collect{|t| t[:y]}]
+      end
+
+      def self.to_dataset(tuple)
+        ds = Gnuplot::DataSet.new(to_data(tuple[:data]))
+        tuple.each_pair do |k,v|
+          next if k == :data
+          if ds.respond_to?(:"#{k}=")
+            ds.send(:"#{k}=", v)
+          end 
+        end
+        ds
+      end
+
+      def self.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 self.to_plots(graphs, buffer = "")
+        graphs.each do |tuple|
+          buffer << to_plot(tuple).to_gplot << "\n"
+        end
+      end
+
+    end # class Plot
+  end # class Formatter
+end # module Viiite

data/lib/viiite/formatter.rb

@@ -0,0 +1,5 @@
+module Viiite
+  class Formatter
+  end # class Formatter
+end # module Viiite
+require 'viiite/formatter/plot'

data/lib/viiite/loader.rb

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

data/lib/viiite/runner.rb

@@ -0,0 +1,59 @@
+module Viiite
+  class Runner
+    include Alf::Iterator
+
+    def initialize(defn)
+      @defn = defn
+    end
+
+    ### DSL
+    
+    def with(hash)
+      if block_given?
+        @stack << @stack.last.merge(hash)
+        res = yield
+        @stack.pop
+        res
+      else
+        @stack.last.merge!(hash)
+      end  
+    end
+
+    def range_over(range, name, &block)
+      range.each do |value|
+        with(name => value){ block.call(value) }
+      end
+    end
+  
+    def variation_point(name, value, &proc)
+      h = {name => value}
+      with(h, &proc)
+    end
+    
+    def report(hash = {}, &block)
+      hash = {:bench => hash} unless hash.is_a?(Hash)
+      with(hash) {
+        with(:tms => Viiite.measure{block.call}){ output }
+      }
+    end
+
+    ### Alf contract
+    
+    def each(&reporter)
+      self.dup._each(&reporter)
+    end
+    
+    protected    
+
+    def _each(&reporter)
+      @stack, @reporter = [ {} ], reporter
+      self.instance_eval &@defn
+      @stack, @reporter = nil, nil
+    end
+    
+    def output
+      @reporter.call @stack.last.dup
+    end
+
+  end # class Runner
+end # module Viiite

data/lib/viiite/tms.rb

@@ -0,0 +1,89 @@
+module Viiite
+  class Tms
+
+    FMTSTR = "%10.6u %10.6y %10.6t %10.6r"
+    FIELDS = [:utime, :stime, :cutime, :cstime, :real]
+
+    def initialize(tms)
+      @tms = tms
+    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]
+      when Hash
+        Viiite::Tms.new FIELDS.collect{|f| arg[f] || 0.0}
+      when Array
+        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 to_ruby_literal
+      "Viiite::Tms(#{to_a.collect{|f| f.inspect}.join(',')})"
+    end
+
+    def *(x);     memberwise(:*, x)     end
+    def +(other); memberwise(:+, other) end
+    def -(other); memberwise(:-, other) end
+    def /(other); memberwise(:/, other) end
+
+    def coerce(other)
+      [self, other]
+    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
+    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}
+      fmtstr.gsub!(/(%[-+\.\d]*)y/){"#{$1}f" % stime}
+      fmtstr.gsub!(/(%[-+\.\d]*)U/){"#{$1}f" % cutime}
+      fmtstr.gsub!(/(%[-+\.\d]*)Y/){"#{$1}f" % cstime}
+      fmtstr.gsub!(/(%[-+\.\d]*)t/){"#{$1}f" % total}
+      fmtstr.gsub!(/(%[-+\.\d]*)r/){"(#{$1}f)" % real}
+      arg0 ? Kernel::format(fmtstr, *args) : fmtstr
+    end
+    alias :to_s :format
+
+    private
+
+    def memberwise(op, x)
+      case x
+      when Viiite::Tms
+        Viiite::Tms.new FIELDS.collect{|f| __send__(f).__send__(op, x.send(f))}
+      else
+        Viiite::Tms.new FIELDS.collect{|f| __send__(f).__send__(op, x)}
+      end
+    end
+
+  end # class Tms
+end # module Viiite

data/lib/viiite/version.rb

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

data/lib/viiite/viiite_file.rb

@@ -0,0 +1,20 @@
+def viiite_clean_binding
+  binding
+end
+
+module Viiite
+  class ViiiteFile < Alf::Reader
+
+    # (see Alf::Reader#each)
+    def each
+      op = if input.is_a?(String)
+        Kernel.eval(input_text, viiite_clean_binding, input)
+      else
+        Kernel.eval(input_text, viiite_clean_binding)
+      end
+      op.each(&Proc.new)
+    end
+    
+    Alf::Reader.register(:viiite, [".viiite", ".rb"], self)
+  end # class ViiiteFile
+end # module Viiite