benchmark-bigo 0.1.0 → 1.0.0

data/lib/benchmark/bigo/report.rb

@@ -9,15 +9,6 @@ module Benchmark
       def initialize
         @per_iterations = 0
         @entries = {}
-        @logscale = false
-      end
-
-      def logscale?
-        @logscale
-      end
-
-      def logscale!
-        @logscale = true
       end
 
       def add_entry label, microseconds, iters, ips, ips_sd, measurement_cycle
@@ -28,103 +19,28 @@ module Benchmark
         @entries[group_label].last
       end
 
-      def scaled_iterations
-        (@per_iterations.to_f * 50 )
-      end
-
-      def chart_hash group_label
+      # retrieve benchmark data for a particular label
+      def data_for group_label
         @entries[group_label].collect do |report|
           size = report.label.split(' ').last.to_i
-          seconds_per_scaled_iters = scaled_iterations / report.ips.to_f
+          microseconds_per_iters = 1000000.0 / report.ips.to_f
 
           {label: size,
-           seconds_per_scaled_iters: seconds_per_scaled_iters,
+           microseconds_per_iters: microseconds_per_iters,
            ips: report.ips
           }
         end
       end
 
-      def chart_for group_label
-        chart_hash = chart_hash group_label
-        Hash[chart_hash.collect{|h| [h[:label], h[:seconds_per_scaled_iters]]}]
-      end
-
-      def chart_data
+      # retrieve a summary of data for the benchmark report
+      def data
         @entries.keys.map do |k|
-          data = chart_for k
-          {name: k, data: data }
-        end
-      end
-
-      def chart_opts chart_data
-
-        axis_type = logscale? ? 'logarithmic' : 'linear'
-
-        if chart_data.is_a? Array
-          min = chart_data.collect{|d| d[:data].values.min}.min
-          max = chart_data.collect{|d| d[:data].values.max}.max
-
-        elsif chart_data.is_a? Hash
-          min = chart_data[:data].values.min
-          max = chart_data[:data].values.max
+          key_data = data_for(k)
+          data = Hash[key_data.collect{|h| [h[:label], h[:microseconds_per_iters]]}]
+          {name: k, data: data}
         end
-
-        orange = "#f0662d"
-        purple = "#8062a6"
-        light_green = "#7bc545"
-        med_blue = "#0883b2"
-        yellow = "#ffaa00"
-
-        {
-          discrete: true,
-          width: "800px",
-          height: "500px",
-          min: (min * 0.8).floor,
-          max: (max * 1.2).ceil,
-          library: {
-            colors: [orange, purple, light_green, med_blue, yellow],
-            xAxis: {type: axis_type, title: {text: "Size"}},
-            yAxis: {type: axis_type, title: {text: "Seconds per #{scaled_iterations.to_i} Iterations"}}
-          }
-        }
       end
 
-      def comparison_chart_data chart_data, sizes
-        sample_size = sizes.first
-
-        # can't take log of 1,
-        # so it can't be used as the sample
-        if sample_size == 1
-          sample_size = sizes[1]
-        end
-
-        sample = chart_data[:data][sample_size]
-
-        logn_sample = sample/Math.log10(sample_size)
-        n_sample = sample/sample_size
-        nlogn_sample = sample/(sample_size * Math.log10(sample_size))
-        n2_sample = sample/(sample_size * sample_size)
-
-        logn_data = {}
-        n_data = {}
-        nlogn_data = {}
-        n2_data = {}
-
-        sizes.each do |n|
-          logn_data[n] = Math.log10(n) * logn_sample
-          n_data[n] = n * n_sample
-          nlogn_data[n] = n * Math.log10(n) * nlogn_sample
-          n2_data[n] = n * n * n2_sample
-        end
-
-        comparison_data = []
-        comparison_data << chart_data
-        comparison_data << {name: 'log n', data: logn_data}
-        comparison_data << {name: 'n', data: n_data}
-        comparison_data << {name: 'n log n', data: nlogn_data}
-        comparison_data << {name: 'n_sq', data: n2_data}
-        comparison_data
-      end
     end
   end
 end

data/lib/benchmark/bigo/templates/chart.erb

@@ -12,6 +12,7 @@
 
     <%= line_chart chart[:data], chart[:opts] %>
   <% end %>
+  <h5>Ruby Version: <%= RUBY_VERSION %></h5>
   </body>
 </html>
 

data/lib/benchmark/bigo/termplot.rb

@@ -0,0 +1,70 @@
+require 'tempfile'
+
+class Benchmark::BigO::TermPlot
+
+  def initialize report_data, sizes
+    @data = report_data
+    @sizes = sizes
+    @dat_file = Tempfile.new 'termplot'
+  end
+
+  def generate
+
+    write_dat_file
+
+    begin
+      IO.popen("gnuplot", "w") { |io| io.puts commands }
+    rescue
+      puts "You need to have gnuplot installed!"
+      puts "brew install gnuplot"
+    end
+  end
+
+  def write_dat_file
+    File.open(@dat_file.path, 'w') do |file|
+      dat_lines.each do |line|
+        file.puts line
+      end
+    end
+  end
+
+  def dat_lines
+    lines = []
+    @sizes.each do |size|
+      line = [size] + @data.collect{|d| d[:data][size] }
+      lines << line.join('   ')
+    end
+    lines
+  end
+
+  def title_for index
+    @data[index][:name]
+  end
+
+  def commands
+
+    cmds = []
+    cmds << "set term dumb"
+    cmds << "set key top left vertical inside width 3"
+
+    data_idx = 0
+
+    while data_idx < @data.length
+
+      if data_idx == 0
+        str = "plot '#{@dat_file.path}'"
+      else
+        str = "\"\""
+      end
+
+      str += " using 1:#{data_idx+2} title '#{title_for(data_idx)}' with lines"
+      str += ",\\" unless data_idx == @data.length-1
+
+      cmds << str
+
+      data_idx += 1
+    end
+
+    cmds
+  end
+end

data/lib/benchmark/bigo/version.rb

@@ -1,8 +1,8 @@
 module Benchmark
   module BigO
     class Version
-      MAJOR = 0
-      MINOR = 1
+      MAJOR = 1
+      MINOR = 0
       PATCH = 0
 
       def self.to_s

data/test/benchmark/test_bigo.rb

@@ -1,5 +1,6 @@
 require "minitest/autorun"
 require "benchmark/bigo"
+require "tempfile"
 
 class TestBenchmarkBigo < MiniTest::Test
   def setup
@@ -11,146 +12,237 @@ class TestBenchmarkBigo < MiniTest::Test
     $stdout = @old_stdout
   end
 
-  def test_bigo
-    #skip('pass')
+  def test_bigo_defaults
+    report = Benchmark.bigo do |x|
+      x.config(:time => 1, :warmup => 1)
+      x.generate :array
+
+      # size 100 will sleep for .1 seconds, size 200 will sleep for .2 seconds
+      x.report("sleep") { |_, size| sleep(size / 1000.0) }
+    end
+
+    assert_equal 1, report.entries.keys.length
+    rep = report.entries["sleep"]
+
+    assert_equal 10, rep.size
+
+    10.times do |i|
+      size = 100 + i*100
+      assert_equal "sleep #{size}", rep[i].label
+
+      iterations = 1000.0 / size
+      assert_equal iterations.ceil, rep[i].iterations
+      assert_in_delta iterations, rep[i].ips, 0.4
+    end
+  end
+
+  def test_bigo_config_options
 
     report = Benchmark.bigo do |x|
-      x.config(:time => 1, :warmup => 1, :increments => 2)
+      x.config(:time => 1, :warmup => 1,
+               :steps => 3, :step_size => 200, :min_size => 50)
       x.generate :array
 
       x.report("#at") {|array, size| array.at rand(size) }
-      x.report("#index") {|array, size| array.index rand(size) }
-      x.report("sleep") { |a,b| sleep(0.25) }
+
+      # size 100 will sleep for .1 seconds, size 200 will sleep for .2 seconds
+      x.report("sleep") { |_, size| sleep(size / 1000.0) }
     end
 
-    assert_equal 3, report.entries.length
+    assert_equal 2, report.entries.length
 
     assert report.entries.keys.include?("#at")
-    assert report.entries.keys.include?("#index")
     assert report.entries.keys.include?("sleep")
 
     at_rep = report.entries["#at"]
-    index_rep = report.entries["#index"]
     sleep_rep = report.entries["sleep"]
 
-    assert_equal 2, at_rep.size
-    assert_equal 2, index_rep.size
-    assert_equal 2, sleep_rep.size
+    assert_equal 3, at_rep.size
+    assert_equal 3, sleep_rep.size
 
-    assert_equal "#at 100", at_rep[0].label
-    assert_equal "#at 200", at_rep[1].label
+    assert_equal "#at 50", at_rep[0].label
+    assert_equal "#at 250", at_rep[1].label
+    assert_equal "#at 450", at_rep[2].label
 
-    assert_equal "#index 100", index_rep[0].label
-    assert_equal "#index 200", index_rep[1].label
+    assert_equal "sleep 50", sleep_rep[0].label
+    assert_equal "sleep 250", sleep_rep[1].label
+    assert_equal "sleep 450", sleep_rep[2].label
 
-    assert_equal "sleep 100", sleep_rep[0].label
-    assert_equal "sleep 200", sleep_rep[1].label
+    assert_equal 20, sleep_rep[0].iterations
+    assert_in_delta 20.0, sleep_rep[0].ips, 0.6
 
-    assert_equal 4, sleep_rep[0].iterations
-    assert_in_delta 4.0, sleep_rep[0].ips, 0.2
+    assert_equal 4, sleep_rep[1].iterations
+    assert_in_delta 4.0, sleep_rep[1].ips, 0.2
 
   end
 
-  def test_bigo_alternate_config
-    #skip('pass')
+  def test_bigo_setters
     report = Benchmark.bigo do |x|
       x.time = 1
       x.warmup = 1
-      x.increments = 2
-      x.generate(:array)
-      x.report("sleep") { |a,b| sleep(0.25) }
+      x.steps = 3
+      x.step_size = 200
+      x.min_size = 50
+      x.generate :array
+
+      x.report("#at") {|array, size| array.at rand(size) }
+
+      # size 100 will sleep for .1 seconds, size 200 will sleep for .2 seconds
+      x.report("sleep") { |_, size| sleep(size / 1000.0) }
     end
 
-    rep = report.entries["sleep"]
-    assert_equal 2, rep.size
+    assert_equal 2, report.entries.length
 
-    assert_equal "sleep 100", rep[0].label
-    assert_equal 4, rep[0].iterations
-    assert_in_delta 4.0, rep[0].ips, 0.2
-  end
+    assert report.entries.keys.include?("#at")
+    assert report.entries.keys.include?("sleep")
 
-  def test_bigo_defaults
-    #skip('pass')
-    report = Benchmark.bigo do |x|
-      x.config(:time => 1, :warmup => 1)
-      x.generate :array
-      x.report("sleep") { |a,b| sleep(0.25) }
-    end
+    at_rep = report.entries["#at"]
+    sleep_rep = report.entries["sleep"]
 
-    assert_equal 1, report.entries.keys.length
-    rep = report.entries["sleep"]
+    assert_equal 3, at_rep.size
+    assert_equal 3, sleep_rep.size
 
-    assert_equal 5, rep.size
+    assert_equal "#at 50", at_rep[0].label
+    assert_equal "#at 250", at_rep[1].label
+    assert_equal "#at 450", at_rep[2].label
 
-    assert_equal "sleep 100", rep[0].label
-    assert_equal "sleep 200", rep[1].label
-    assert_equal "sleep 300", rep[2].label
-    assert_equal "sleep 400", rep[3].label
-    assert_equal "sleep 500", rep[4].label
+    assert_equal "sleep 50", sleep_rep[0].label
+    assert_equal "sleep 250", sleep_rep[1].label
+    assert_equal "sleep 450", sleep_rep[2].label
 
-    assert_equal 4, rep[0].iterations
-    assert_in_delta 4.0, rep[0].ips, 0.2
+    assert_equal 20, sleep_rep[0].iterations
+    assert_in_delta 20.0, sleep_rep[0].ips, 0.6
+
+    assert_equal 4, sleep_rep[1].iterations
+    assert_in_delta 4.0, sleep_rep[1].ips, 0.2
   end
 
-  def test_bigo_exponential
-    #skip('pass')
+  def test_bigo_generate_json
+    json_file = Tempfile.new 'data.json'
     report = Benchmark.bigo do |x|
-      x.config(:time => 1, :warmup => 1, :increments => 2)
+      x.config(:time => 1, :warmup => 1, :steps => 2)
       x.generate :array
-      x.exponential
-      x.report("sleep") { |a,b| sleep(0.25) }
+
+      x.report("#at") {|array, size| array.at rand(size) }
+      x.json! json_file.path
     end
 
-    rep = report.entries["sleep"]
+    json_data = json_file.read
+    assert json_data
+    data = JSON.parse json_data
+    assert data
+    assert_equal 1, data.size
+    assert_equal "#at", data[0]["name"]
+    assert data[0]["data"]
+    assert data[0]["data"]["100"]
+    assert data[0]["data"]["200"]
+  end
 
-    assert_equal "sleep 1", rep[0].label
-    assert_equal "sleep 10", rep[1].label
-    assert_equal 4, rep[0].iterations
-    assert_in_delta 4.0, rep[0].ips, 0.2
+  def test_bigo_generate_csv
+    csv_file = Tempfile.new 'data.csv'
+    report = Benchmark.bigo do |x|
+      x.config(:time => 1, :warmup => 1, :steps => 2)
+      x.generate :array
+
+      x.report("#at") {|array, size| array.at rand(size) }
+      x.csv! csv_file.path
+    end
+    data = CSV.read(csv_file.path)
+    assert data
+    assert_equal 2, data.size
+    assert_equal ['','100', '200'], data[0]
+    assert_equal "#at", data[1][0]
+    assert_equal data[1][0].size, 3
   end
 
-  def test_bigo_increments_config
-    #skip('pass')
+  def test_bigo_generate_chart
+    chart_file = Tempfile.new 'data.html'
     report = Benchmark.bigo do |x|
-      x.config(:time => 1, :warmup => 1, :increments => 3)
+      x.config(:time => 1, :warmup => 1, :steps => 2)
       x.generate :array
 
       x.report("#at") {|array, size| array.at rand(size) }
+      x.chart! chart_file.path
+      x.compare!
     end
 
-    assert_equal 1, report.entries.length
+    data = File.read(chart_file.path)
+    assert data
+    assert data.match('<h1>Growth Chart</h1>')
+    assert data.match('<h1>#at</h1>')
+  end
+
+  def test_generate_array
 
-    assert report.entries.keys.include?("#at")
+    job = Benchmark::BigO::Job.new({:suite => nil,
+                                    :quiet => true})
 
-    at_rep = report.entries["#at"]
+    job.generate :array
 
-    assert_equal 3, at_rep.size
+    job.report('test') {|array, size| array.at rand(size) }
+
+    # should create 10 job entries
+    assert_equal 10, job.list.size
 
-    assert_equal "#at 100", at_rep[0].label
-    assert_equal "#at 200", at_rep[1].label
-    assert_equal "#at 300", at_rep[2].label
+    # the generated object should be an Array
+    assert Array === job.list.first.generated
+
+    # the Array should have 100 elements
+    assert_equal 100, job.list.first.generated.size
+
+    # when sorted, the array should equal 0...100
+    assert_equal (0...100).to_a, job.list.first.generated.sort
   end
 
-  def test_bigo_increments_setter
-    #skip('pass')
-    report = Benchmark.bigo do |x|
-      x.config(:time => 1, :warmup => 1)
-      x.increments = 3
-      x.generate :array
+  def test_generate_string
 
-      x.report("#at") {|array, size| array.at rand(size) }
-    end
+    job = Benchmark::BigO::Job.new({:suite => nil,
+                                    :quiet => true})
 
-    assert_equal 1, report.entries.length
+    job.generate :string
 
-    assert report.entries.keys.include?("#at")
+    job.report('test') {|string, size| string[rand(size)] }
 
-    at_rep = report.entries["#at"]
+    # should create 10 job entries
+    assert_equal 10, job.list.size
 
-    assert_equal 3, at_rep.size
+    # the generated object should be a String
+    assert String === job.list.first.generated
+
+    # the String should have length 100
+    assert_equal 200, job.list.first.generated.length
+  end
+
+  def test_generate_size
+    job = Benchmark::BigO::Job.new({:suite => nil,
+                                    :quiet => true})
+
+    job.generate :size
+
+    job.report('test') {|size, _| size.to_i }
+
+    # should create 10 job entries
+    assert_equal 10, job.list.size
+
+    # the generated object should be an Integer
+    assert Integer === job.list.first.generated
+
+    # the Integer should be the size
+    assert_equal 100, job.list.first.generated
+    assert_equal 1000, job.list[-1].generated
+
+  end
+
+  def test_step
+    job = Benchmark::BigO::Job.new({:suite => nil,
+                                    :quiet => true})
+
+    job.min_size = 22
+    job.steps = 6
+    job.step_size = 10
 
-    assert_equal "#at 100", at_rep[0].label
-    assert_equal "#at 200", at_rep[1].label
-    assert_equal "#at 300", at_rep[2].label
+    assert_equal 22, job.step(0)
+    assert_equal 32, job.step(1)
+    assert_equal 42, job.step(2)
   end
 end