Pistos-ramaze 2008.09

data/benchmark/results.txt

@@ -0,0 +1,131 @@
+====== simple ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end
+</code>
+
+=== webrick ===
+  Mem usage before:       20.32MB
+  Time taken for tests:   7.747022 seconds
+  Failed requests:        0
+  Requests per second:    129.08 [#/sec] (mean)
+  Time per request:       77.470 [ms] (mean)
+  Time per request:       7.747 [ms] (mean, across all concurrent requests)
+  Mem usage after:        25.43MB
+
+=== mongrel ===
+  Mem usage before:       20.25MB
+  Time taken for tests:   2.205161 seconds
+  Failed requests:        0
+  Requests per second:    453.48 [#/sec] (mean)
+  Time per request:       22.052 [ms] (mean)
+  Time per request:       2.205 [ms] (mean, across all concurrent requests)
+  Mem usage after:        21.91MB
+
+=== evented_mongrel ===
+  Mem usage before:       22.64MB
+  Time taken for tests:   1.311583 seconds
+  Failed requests:        0
+  Requests per second:    762.44 [#/sec] (mean)
+  Time per request:       13.116 [ms] (mean)
+  Time per request:       1.312 [ms] (mean, across all concurrent requests)
+  Mem usage after:        27.03MB
+
+====== no_template ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :None
+
+  def index
+    "Hello, World!"
+  end
+end
+</code>
+
+=== evented_mongrel ===
+  Mem usage before:       22.63MB
+  Time taken for tests:   1.151947 seconds
+  Failed requests:        0
+  Requests per second:    868.10 [#/sec] (mean)
+  Time per request:       11.519 [ms] (mean)
+  Time per request:       1.152 [ms] (mean, across all concurrent requests)
+  Mem usage after:        27.11MB
+
+====== no_informer ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Inform.loggers = []
+</code>
+
+=== evented_mongrel ===
+  Mem usage before:       22.63MB
+  Time taken for tests:   1.202878 seconds
+  Failed requests:        0
+  Requests per second:    831.34 [#/sec] (mean)
+  Time per request:       12.029 [ms] (mean)
+  Time per request:       1.203 [ms] (mean, across all concurrent requests)
+  Mem usage after:        27.07MB
+
+====== no_sessions ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Inform.loggers = []
+Ramaze::Global.sessions = false
+</code>
+
+=== evented_mongrel ===
+  Mem usage before:       22.63MB
+  Time taken for tests:   0.835254 seconds
+  Failed requests:        0
+  Requests per second:    1197.24 [#/sec] (mean)
+  Time per request:       8.353 [ms] (mean)
+  Time per request:       0.835 [ms] (mean, across all concurrent requests)
+  Mem usage after:        26.38MB
+
+====== minimal ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :None
+
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Global.sourcereload = false
+Ramaze::Global.sessions = false
+Ramaze::Inform.loggers = []
+</code>
+
+=== evented_mongrel ===
+  Mem usage before:       22.62MB
+  Time taken for tests:   0.647273 seconds
+  Failed requests:        0
+  Requests per second:    1544.94 [#/sec] (mean)
+  Time per request:       6.473 [ms] (mean)
+  Time per request:       0.647 [ms] (mean, across all concurrent requests)
+  Mem usage after:        26.42MB
+

data/benchmark/run.rb

@@ -0,0 +1,362 @@
+require "optparse"
+require "timeout"
+require "net/http"
+
+class String
+  def /(o) File.join(self, o.to_s) end
+end
+
+class RamazeBenchmark
+
+  class BasicWriter
+    def initialize
+      @ljust = 24
+    end
+
+    def write(key, val)
+      if key == "Name"
+        puts "====== #{val} ======"
+      else
+        puts((key.to_s + ":").ljust(@ljust) + val.to_s)
+      end
+    end
+
+    def flush
+      puts
+      $stdout.flush
+    end
+
+    def close; end
+  end
+
+  class CSVWriter
+    def initialize
+      @keys, @vals = [], []
+    end
+
+    def write(key, val)
+      @keys << key
+      @vals << (val =~ /^\d[\d.]+/ ? $& : val)
+    end
+
+    def flush
+      unless @header
+        puts FasterCSV.generate{|csv| csv << @keys }
+        @header = true
+      end
+
+      puts FasterCSV.generate{|csv| csv << @vals }
+      @keys, @vals = [], []
+    end
+
+    def close; end
+  end
+
+  class GruffWriter
+    RPS = "Requests per second"
+
+    def initialize
+      @benchmarks = {}
+      @order = []
+    end
+
+    def write(key, val)
+      @benchmark ||= {}
+      @benchmark[key] = (val =~ /^\d[\d.]+/ ? $&.to_f : val)
+    end
+
+    def flush
+      if @benchmark["Requests per second"]
+        name = @benchmark["Name"]
+        @benchmarks[name] ||= []
+        @benchmarks[name] << @benchmark
+        @order << name unless @order.include?(name)
+      end
+      @benchmark = nil
+    end
+
+    def close
+      g = Gruff::SideBar.new(800)
+      g.title = "Ramaze Benchmark"
+      setup_gruff_data(g)
+      g.labels = gruff_labels
+      g.sort = false
+      g.hide_legend = true if graph_type == :simple
+      g.x_axis_label = "requests/sec"
+      g.minimum_value = 0
+      g.write
+    end
+
+    private
+
+    def gruff_labels
+      table = {}
+      @order.each_with_index do |bname, idx|
+        table[idx] = bname
+      end
+      return table
+    end
+
+    def adapters
+      @benchmarks.to_a[0][1].map{|bm| bm["Adapter"]}.uniq
+    end
+
+    def paths
+      @benchmarks.to_a[0][1].map{|bm| bm["Path"]}.uniq
+    end
+
+    def graph_type
+      case [adapters.size > 1, paths.size > 1]
+      when [true , true ]; :both
+      when [true , false]; :adapter
+      when [false, true ]; :path
+      else :simple; end
+    end
+
+    def setup_gruff_data(g)
+      case graph_type
+      when :simple
+        g.data("", @order.map{|name| @benchmarks[name][0][RPS] }, '#6886B4')
+      when :adapter
+        adapters.each do |adapter|
+          g.data(adapter, @order.map{|name|
+                   @benchmarks[name].find{|bm| bm["Adapter"] == adapter}[RPS]
+                 })
+        end
+      when :path
+        paths.each do |path|
+          g.data(path, @order.map{|name|
+                   @benchmarks[name].find{|bm| bm["Path"] == path}[RPS]
+                 })
+        end
+      when :both
+        adapters.each do |adapter|
+          paths.each do |path|
+            g.data("#{adapter}, #{path}", @order.map{|name|
+                     @benchmarks[name].find{|bm|
+                       bm["Adapter"] == adapter && bm["Path"] == path
+                     }[RPS]
+                   })
+          end
+        end
+      end
+    end
+  end
+
+  attr_accessor :requests, :adapters, :port, :log, :display_code, :target
+  attr_accessor :concurrent, :paths, :benchmarker, :informer, :sessions
+  attr_accessor :show_log, :ignored_tags, :formats
+
+  def initialize()
+    @adapters = [:webrick]
+    @port = rand(32768-1)+32768
+    @requests = 100
+    @concurrent = 10
+    @signal = 'SIGKILL'
+    @host = "127.0.0.1"
+    @paths = ["/"]
+    @target = /.+/
+    @informer = true
+    @sessions = true
+    @ignored_tags = [:debug, :dev]
+    @formats = ["text"]
+    @writers = []
+    yield self
+  end
+
+  def start
+    # setup writers
+    @formats.each do |format|
+      case format
+      when "csv"  ; @writers << CSVWriter.new
+      when "gruff"; @writers << GruffWriter.new
+      when "text" ; @writers << BasicWriter.new
+      end
+    end
+
+    # benchmarks
+    __DIR__ = File.expand_path(File.dirname(__FILE__))
+    Dir[__DIR__/"suite"/"*.rb"].each do |filename|
+      @adapters.each do |adapter|
+        @paths.each do |path|
+          benchmark(filename, adapter, path) if @target.match(filename)
+        end
+      end
+    end
+
+    # close writers
+    @writers.each do |writer|
+      writer.close
+    end
+  end
+
+  # start to measure
+  def benchmark(filename, adapter, path)
+    # output informations
+    l :Name,       filename.scan(/\/([^\/]+)\.rb/).to_s
+    l :Adapter,    adapter
+    l :Requests,   @requests
+    l :Concurrent, @concurrent
+    l :Path,       path
+    l :Informer,   @informer
+    l :Sessions,   @sessions
+    if @display_code
+      l :Code, "<code ruby>\n#{File.read(filename)}\n</code>\n\n"
+    end
+
+    # real benchmark
+    ramaze(filename, adapter) do |pid|
+      l "Mem usage before", "#{memsize(pid)}MB"
+      ab(path).each do |line|
+        l *line.split(/:\s*/)
+      end
+      l "Mem usage after", "#{memsize(pid)}MB"
+    end
+
+    # flush writers
+    @writers.each do |writer|
+      writer.flush
+    end
+  end
+
+  private
+
+  # memory usage size
+  def memsize(pid)
+    (`ps -p #{pid} -o rss=`.strip.to_f/10.24).round/100.0
+  end
+
+  # output
+  def l(key, val)
+    @writers.each do |writer|
+      writer.write(key.to_s, val)
+    end
+  end
+
+  # url of ramaze server
+  def url(path)
+    "http://#{@host}:#{@port}#{path}"
+  end
+
+  # apache benchmark
+  def ab(path)
+    re = /^(Fail|Req|Time|Total transferred|Document Length|Transfer rate)/
+    `ab -c #{@concurrent} -n #{@requests} #{url(path)}`.split("\n").grep(re)
+  end
+
+  # startup
+  def ramaze(filename, adapter)
+    pid = fork do
+      begin
+        require filename
+        Ramaze::Log.ignored_tags = @ignored_tags
+        if @informer
+          unless @show_log
+            Ramaze::Log.loggers = [Ramaze::Logging::Logger::Informer.new("/dev/null")]
+          end
+        else
+          Ramaze::Log.loggers = []
+        end
+        Ramaze::Global.sessions = @sessions
+        Ramaze::Global.sourcereload = false
+        Ramaze.start :adapter => adapter, :port => @port
+      rescue LoadError => ex; l :Error, ex; end
+    end
+
+    yield pid if wait_to_startup
+
+    Process.kill(@signal, pid)
+    Process.waitpid2(pid)
+  end
+
+  # wait for ramaze to start up
+  def wait_to_startup
+    begin
+      Timeout.timeout(5) do
+        loop do
+          begin
+            sleep 1; Net::HTTP.new(@host, @port).head("/"); return true
+          rescue Errno::ECONNREFUSED; end
+        end
+      end
+    rescue Timeout::Error
+      l "Error", "failed to start benchmark script"; return false
+    end
+  end
+end
+
+Signal.trap(:INT, proc{exit})
+
+RamazeBenchmark.new do |bm|
+  OptionParser.new(false, 24, "  ") do |opt|
+    opt.on('-a', '--adapters NAMES', '[webrick] Specify adapters') do |adapters|
+      bm.adapters = adapters.split(",")
+    end
+
+    opt.on('--formats (text|csv|gruff)', '[text] Specify output formats') do |formats|
+      bm.formats = formats.split(",")
+      bm.formats.each do |format|
+        case format
+        when "csv"  ; require "fastercsv"
+        when "gruff"; require "gruff"
+        end
+      end
+    end
+
+    opt.on('-n', '--requests NUM', '[100] Number of requests') do |n|
+      bm.requests = n
+    end
+
+    opt.on('-c', '--concurrent NUM', '[10] Number of multiple requests') do |n|
+      bm.concurrent = n
+    end
+
+    opt.on('--code', 'Display benchmark code') do |n|
+      bm.display_code = true
+    end
+
+    opt.on('-p', '--port NUM',
+           '[random(32768-65535)] Specify port number') do |n|
+      bm.port = n
+    end
+
+    opt.on('--paths PATHS', '[/] Specify request paths') do |paths|
+      bm.paths = paths.split(",")
+    end
+
+    opt.on('--no-informer', 'Disable informer') do
+      bm.informer = false
+    end
+
+    opt.on('--ignored-tags TAGS',
+           '[debug,dev] Specify ignored tags for Ramaze::Log') do |tags|
+      bm.ignored_tags = tags.split(",").map{|e| e.to_sym }
+    end
+
+    opt.on('--show-log', 'Show log') do
+      bm.show_log = true
+    end
+
+    opt.on('--no-sessions', 'Disable sessions') do
+      bm.sessions = false
+    end
+
+    opt.on('--target REGEXP',
+           '[/.+/] Specify benchmark scripts to measure') do |name|
+      bm.target = Regexp.compile(name)
+    end
+
+    opt.on('-h', '--help', 'Show this message') do
+      puts opt.help
+      exit
+    end
+
+    begin
+      opt.parse!(ARGV)
+    rescue OptionParser::ParseError => ex
+      puts "[ERROR] " + ex
+      puts opt.help
+      exit
+    end
+  end
+end.start

data/benchmark/suite/minimal.rb

@@ -0,0 +1,13 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :None
+
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Global.sourcereload = false
+Ramaze::Global.sessions = false
+Ramaze::Log.loggers = []

data/benchmark/suite/no_informer.rb

@@ -0,0 +1,9 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Log.loggers = []

data/benchmark/suite/no_sessions.rb

@@ -0,0 +1,10 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Log.loggers = []
+Ramaze::Global.sessions = false

data/benchmark/suite/no_template.rb

@@ -0,0 +1,9 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :None
+
+  def index
+    "Hello, World!"
+  end
+end

data/benchmark/suite/simple.rb

@@ -0,0 +1,7 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end

data/benchmark/suite/template_amrita2.rb

@@ -0,0 +1,17 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Amrita2
+
+  def index
+    @data = { :hello => "Hello, World!" }
+    %q[
+     <<html<
+       <<body<
+         <<%<
+           <% 10.times do %>
+             <span><%= $_[:hello] %></span>
+           <% end %>
+    ]
+  end
+end

data/benchmark/suite/template_builder.rb

@@ -0,0 +1,12 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Builder
+
+  def index
+    @hello = "Hello, World!"
+    %q[
+      xml.html {|h| h.body {|b| 10.times { b.span @hello } }}
+    ]
+  end
+end

data/benchmark/suite/template_erubis.rb

@@ -0,0 +1,10 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Erubis
+
+  def index
+    @hello = "Hello, World!"
+    '<html><body><% 10.times do %><span><%= @hello %></span><% end %></body></html>'
+  end
+end

data/benchmark/suite/template_ezamar.rb

@@ -0,0 +1,10 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Ezamar
+
+  def index
+    @hello = "Hello, World!"
+    '<html><body><? 10.times do ?><span>#{@hello}</span><?r end ?></body></html>'
+  end
+end

data/benchmark/suite/template_haml.rb

@@ -0,0 +1,15 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Haml
+
+  def index
+    @hello = "Hello, World!"
+    %{
+%html
+  %body
+    - 10.times do
+      %span= @hello
+    }
+  end
+end

data/benchmark/suite/template_liquid.rb

@@ -0,0 +1,13 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Liquid
+
+  def index
+    @hash = {
+      :hello => "Hello, World!",
+      :counter => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    }
+    '<html><body>{% for i in counter %}<span>{{hello}}</span>{% endfor %}</body></html>'
+  end
+end

data/benchmark/suite/template_markaby.rb

@@ -0,0 +1,11 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Markaby
+  helper :markaby
+
+  def index
+    @hello = "Hello, World!"
+    mab { html { body { 10.times { span @hello } } } }
+  end
+end

data/benchmark/suite/template_nagoro.rb

@@ -0,0 +1,10 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Nagoro
+
+  def index
+    @hello = "Hello, World!"
+    '<html><body><span times=10>#{@hello}</span></body></html>'
+  end
+end

data/benchmark/suite/template_redcloth.rb

@@ -0,0 +1,15 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :RedCloth
+  layout :layout
+
+  def index
+    @hello = "Hello, World!"
+    '<% 10.times do %> %<%= @hello %>% <% end %>'
+  end
+
+  def layout
+    '<html><body><%= @content %></body></html>'
+  end
+end

data/benchmark/suite/template_tenjin.rb

@@ -0,0 +1,10 @@
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :Tenjin
+
+  def index
+    @context = {:hello => "Hello, World!"}
+    '<html><body><?rb 10.times do ?><span>${@hello}</span><?rb end ?></body></html>'
+  end
+end