railsbench 0.8.4

data/lib/railsbench/gc_info.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__) + "/perf_utils.rb")
+require "set"
+
+# Entry Format:
+#
+# Garbage collection started
+# objects processed: 0223696
+# live objects     : 0192126
+# freelist objects : 0000000
+# freed objects    : 0031570
+# kept 0000370 / freed 0000609 objects of type OBJECT
+# kept 0001071 / freed 0000062 objects of type CLASS
+# kept 0000243 / freed 0000061 objects of type ICLASS
+# kept 0000041 / freed 0000061 objects of type FLOAT
+# kept 0013974 / freed 0015432 objects of type STRING
+# kept 0000651 / freed 0000002 objects of type REGEXP
+# kept 0000617 / freed 0009948 objects of type ARRAY
+# kept 0000646 / freed 0001398 objects of type HASH
+# kept 0000004 / freed 0000121 objects of type BIGNUM
+# kept 0000006 / freed 0000005 objects of type FILE
+# kept 0000400 / freed 0000253 objects of type DATA
+# kept 0000001 / freed 0000093 objects of type MATCH
+# kept 0000067 / freed 0000136 objects of type VARMAP
+# kept 0000167 / freed 0000939 objects of type SCOPE
+# kept 0173634 / freed 0002389 objects of type NODE
+# GC time: 47 msec
+
+GCAttributes = [:processed, :live, :freelist, :freed, :time]
+GCSummaries  = [:min, :max, :mean, :stddev, :stddev_percentage]
+
+class GCLogEntry
+  attr_accessor *GCAttributes
+  attr_accessor :live_objects, :freed_objects
+  def initialize
+    @live_objects = {}
+    @freed_objects = {}
+  end
+end
+
+class GCInfo
+
+  attr_reader(*GCAttributes)
+  attr_reader :entries, :num_requests, :collections, :garbage_produced, :time_total, :topology
+  attr_reader :live_objects, :freed_objects, :object_types
+
+  GCAttributes.each do |attr|
+    GCSummaries.each do |method|
+      attr_reader "#{attr}_#{method}"
+    end
+  end
+
+  def initialize(file)
+    @entries = []
+    @num_requests = 0
+    @topology = []
+    @object_types = Set.new
+
+    file.each_line do |line|
+      case line
+      when /^Garbage collection started$/
+        @entries << GCLogEntry.new
+      when /^objects processed\s*:\s*(\d+)$/
+        @entries.last.processed = $1.to_i
+      when /^live objects\s*:\s*(\d+)$/
+        @entries.last.live = $1.to_i
+      when /^freelist objects\s*:\s*(\d+)$/
+        @entries.last.freelist = $1.to_i
+      when /^freed objects\s*:\s*(\d+)$/
+        @entries.last.freed = $1.to_i
+      when /^GC time\s*:\s*(\d+)\s*msec$/
+        @entries.last.time = $1.to_i
+      when /^number of requests processed: (\d+)$/
+        @num_requests = $1.to_i
+      when /^HEAP\[\s*(\d+)\]: size=\s*(\d+)$/
+        @topology << $2.to_i
+      when /^kept (\d+) \/ freed (\d+) objects of type ([a-zA-Z]+)/
+        @object_types.add($3)
+        @entries.last.live_objects[$3] = $1.to_i
+        @entries.last.freed_objects[$3] = $2.to_i
+      end
+    end
+
+    @time_total = @entries.map{|e| e.time}.sum
+    @collections = @entries.length
+    @garbage_produced = @entries.map{|e| e.freed}.sum
+    @live_objects = @entries.map{|e| e.live_objects}
+    @freed_objects = @entries.map{|e| e.freed_objects}
+
+    GCAttributes.each do |attr|
+      a = @entries.map{|e| e.send attr}
+      a.pop
+
+      [:min, :max, :mean].each do |method|
+        instance_variable_set "@#{attr}_#{method}", (a.send method)
+      end
+      mean = instance_variable_get "@#{attr}_mean"
+      stddev = instance_variable_set "@#{attr}_stddev", (a.send :stddev, mean)
+      instance_variable_set "@#{attr}_stddev_percentage", stddev_percentage(stddev, mean)
+    end
+  end
+
+end
+
+
+### Local Variables: ***
+### mode:ruby ***
+### End: ***
+
+#    Copyright (C) 2006  Stefan Kaes
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

data/lib/railsbench/perf_info.rb

@@ -0,0 +1,145 @@
+require File.expand_path(File.dirname(__FILE__) + "/perf_utils.rb")
+
+# example of raw performance data
+
+# /home/skaes/railsbench/script/perf_bench 100 -bm=all -mysql_session -patched_gc -links -OT
+#                                       user     system      total        real
+# loading environment               0.954000   1.938000   2.892000 (  2.890000)
+# /empty/index                      0.093000   0.000000   0.093000 (  0.172000)
+# /welcome/index                    0.156000   0.000000   0.156000 (  0.172000)
+# /rezept/index                     0.125000   0.015000   0.140000 (  0.203000)
+# /rezept/myknzlpzl                 0.125000   0.000000   0.125000 (  0.203000)
+# /rezept/show/413                  0.406000   0.094000   0.500000 (  0.594000)
+# /rezept/cat/Hauptspeise           0.547000   0.094000   0.641000 (  0.688000)
+# /rezept/cat/Hauptspeise?page=5    0.531000   0.047000   0.578000 (  0.688000)
+# /rezept/letter/G                  0.422000   0.078000   0.500000 (  0.609000)
+# GC.collections=0, GC.time=0.0
+#                                       user     system      total        real
+# loading environment               0.813000   2.078000   2.891000 (  2.890000)
+# /empty/index                      0.125000   0.016000   0.141000 (  0.157000)
+# /welcome/index                    0.109000   0.000000   0.109000 (  0.187000)
+# /rezept/index                     0.110000   0.031000   0.141000 (  0.219000)
+# /rezept/myknzlpzl                 0.109000   0.016000   0.125000 (  0.219000)
+# /rezept/show/413                  0.422000   0.078000   0.500000 (  0.625000)
+# /rezept/cat/Hauptspeise           0.437000   0.125000   0.562000 (  0.656000)
+# /rezept/cat/Hauptspeise?page=5    0.453000   0.125000   0.578000 (  0.688000)
+# /rezept/letter/G                  0.438000   0.000000   0.438000 (  0.594000)
+# GC.collections=0, GC.time=0.0
+#                                       user     system      total        real
+# loading environment               0.938000   1.968000   2.906000 (  2.906000)
+# /empty/index                      0.109000   0.000000   0.109000 (  0.172000)
+# /welcome/index                    0.094000   0.031000   0.125000 (  0.171000)
+# /rezept/index                     0.110000   0.047000   0.157000 (  0.219000)
+# /rezept/myknzlpzl                 0.140000   0.016000   0.156000 (  0.203000)
+# /rezept/show/413                  0.422000   0.047000   0.469000 (  0.593000)
+# /rezept/cat/Hauptspeise           0.515000   0.015000   0.530000 (  0.672000)
+# /rezept/cat/Hauptspeise?page=5    0.484000   0.063000   0.547000 (  0.672000)
+# /rezept/letter/G                  0.453000   0.015000   0.468000 (  0.610000)
+# GC.collections=0, GC.time=0.0
+
+
+PerfAttributes = [:gc_calls, :gc_time, :load_time, :total_time]
+PerfSummaries  = [:min, :max, :mean, :stddev, :stddev_percentage]
+
+class PerfEntry
+  attr_accessor *PerfAttributes
+  attr_accessor :keys, :timings
+  def initialize
+    @keys = []
+    @timings = {}
+  end
+end
+
+class PerfInfo
+
+  attr_reader :options, :iterations, :keys
+  attr_reader :entries, :runs, :request_count, :requests_per_key
+
+  def gc_stats?
+    @gc_stats
+  end
+
+  PerfSummaries.each do |method|
+    PerfAttributes.each do |attr|
+      attr_reader "#{attr}_#{method}"
+    end
+    class_eval "def timings_#{method}(key); @timings[:#{method}][key]; end"
+  end
+
+  def initialize(file)
+    @entries = []
+    file.each_line do |line|
+      case line
+      when /^.*perf_([a-zA-Z.]+)\s+(\d+)\s+(.*)$/
+        @iterations = $2.to_i
+        @options = $3
+      when /\s+user\s+system\s+total\s+real/
+        @entries << PerfEntry.new
+      when /^(.*)\s+([\d\.]+)\s+([\d\.]+)\s+([\d\.]+)\s+\(\s*([\d\.]+)\s*\)$/
+        key, time = $1.strip, $5.to_f
+        if key == "loading environment"
+          @entries.last.load_time = time
+        else
+          @entries.last.keys << key
+          @entries.last.timings[key] = time
+        end
+      when /^GC.collections=(\d+), GC.time=([\d\.]+)$/
+        @entries.last.gc_calls, @entries.last.gc_time = [$1.to_i,$2.to_f]
+        @gc_stats = true
+      end
+    end
+
+    @entries.each{ |e| e.total_time =  e.timings.values.sum }
+    @keys = @entries.first.keys
+    @runs = @entries.length
+    if @keys.length == 1 && @keys[0] =~ /\((\d+) urls\)$/
+      @requests_per_key = $1.to_i
+    else
+      @requests_per_key = 1
+    end
+    @request_count = @iterations * @keys.length * @requests_per_key
+    @timings = PerfSummaries.inject({}){ |hash, method| hash[method] = Hash.new; hash }
+
+    @keys.each do |k|
+      a = @entries.map{|e| e.timings[k]}
+      [:min, :max, :mean].each do |method|
+        @timings[method][k] = a.send(method)
+      end
+      mean = @timings[:mean][k]
+      stddev = @timings[:stddev][k] = a.send(:stddev, mean)
+      @timings[:stddev_percentage][k] = stddev_percentage(stddev, mean)
+    end
+
+    PerfAttributes.each do |attr|
+      a = @entries.map{|e| e.send attr}
+      [:min, :max, :mean].each do |method|
+        instance_variable_set "@#{attr}_#{method}", (a.send method)
+      end
+      mean = instance_variable_get "@#{attr}_mean"
+      stddev = instance_variable_set "@#{attr}_stddev", (a.send :stddev, mean)
+      instance_variable_set "@#{attr}_stddev_percentage", stddev_percentage(stddev, mean)
+    end
+
+  end
+end
+
+
+### Local Variables: ***
+### mode:ruby ***
+### End: ***
+
+#    Copyright (C) 2006  Stefan Kaes
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

data/lib/railsbench/perf_utils.rb

@@ -0,0 +1,65 @@
+# some utility methods
+
+class Array
+  def index_map
+    res = {}
+    each_with_index{|element, index| res[index] = element}
+    res
+  end
+
+  def restrict_to(index_set)
+    res = []
+    each_with_index{|e,i| res << e if index_set.include?(i)}
+    res
+  end
+
+  def sum
+    inject(0.0){|r,v| r += v }
+  end
+
+  def mean
+    sum/length
+  end
+
+  def stddev(mean=nil)
+    mean ||= self.mean
+    r = inject(0.0){|r,v| r += (v-mean)*(v-mean) }
+    Math.sqrt(r/(length-1))
+  end
+end
+
+def stddev_percentage(stddev, mean)
+  stddev.zero? ? 0.0 : (stddev/mean)*100
+end
+
+def die(msg, error_code=1)
+  $stderr.puts msg
+  exit error_code
+end
+
+class File
+  def self.open_or_die(filename, &block)
+    filename = filename.sub(/^\/([cdefgh])(\/)/, '\1:\2') if RUBY_PLATFORM =~ /win32/
+    begin
+      if stat(filename).readable?
+        open(filename, &block)
+      else
+        die "file #{filename} is unreadable"
+      end
+    rescue
+      die "file #{filename} does not exist"
+    end
+  end
+end
+
+def truncate(text, length = 32, truncate_string = "...")
+  if text.nil? then return "" end
+  l = truncate_string.length + 1
+
+  if $KCODE == "NONE"
+    text.length > length ? text[0..(length - l)] + truncate_string : text
+  else
+    chars = text.split(//)
+    chars.length > length ? chars[0..(length - l)].join + truncate_string : text
+  end
+end

data/lib/railsbench/railsbenchmark.rb

@@ -0,0 +1,397 @@
+class RailsBenchmark
+
+  attr_accessor :gc_frequency, :iterations, :url_spec
+  attr_accessor :http_host, :remote_addr, :server_port
+  attr_accessor :relative_url_root
+  attr_accessor :perform_caching, :cache_template_loading
+  attr_accessor :session_data
+
+  def error_exit(msg)
+    STDERR.puts msg
+    raise msg
+  end
+
+  def patched_gc?
+    @patched_gc
+  end
+
+  def relative_url_root=(value)
+    ActionController::AbstractRequest.relative_url_root = value
+    @relative_url_root = value
+  end
+
+  def initialize(options={})
+    unless @gc_frequency = options[:gc_frequency]
+      @gc_frequency = 0
+      ARGV.each{|arg| @gc_frequency = $1.to_i if arg =~ /-gc(\d+)/ }
+    end
+
+    @iterations = (options[:iterations] || 100).to_i
+
+    @remote_addr = options[:remote_addr] || '127.0.0.1'
+    @http_host =  options[:http_host] || '127.0.0.1'
+    @server_port = options[:server_port] || '80'
+
+    @session_data = options[:session_data] || {}
+
+    @url_spec = options[:url_spec]
+
+    ENV['RAILS_ENV'] = 'benchmarking'
+
+    require ENV['RAILS_ROOT'] + "/config/environment"
+    require 'dispatcher' # make edge rails happy
+
+    # we don't want local error template output, which crashes anyway
+    ActionController::Rescue.class_eval "def local_request?; false; end"
+
+    # make sure an error code gets returned for 1.1.6
+    ActionController::Rescue.class_eval <<-"end_eval"
+      def rescue_action_in_public(exception)
+        case exception
+          when ActionController::RoutingError, ActionController::UnknownAction
+            render_text(IO.read(File.join(RAILS_ROOT, 'public', '404.html')), "404 Not Found")
+          else
+            render_text(IO.read(File.join(RAILS_ROOT, 'public', '500.html')), "500 Internal Error")
+        end
+      end
+    end_eval
+
+    if ARGV.include?('-path')
+      $:.each{|f| STDERR.puts f}
+      exit
+    end
+
+    log_level = options[:log]
+    log_level = Logger::DEBUG if ARGV.include?('-log')
+    ARGV.each{|arg| arg =~ /-log=([a-zA-Z]*)/ && (log_level = eval("Logger::#{$1.upcase}")) }
+
+    if log_level
+      RAILS_DEFAULT_LOGGER.level = log_level
+      #ActiveRecord::Base.logger.level = log_level
+      #ActionController::Base.logger.level = log_level
+      #ActionMailer::Base.logger = level = log_level if defined?(ActionMailer)
+    else
+      ActiveRecord::Base.logger = nil
+      ActionController::Base.logger = nil
+      ActionMailer::Base.logger = nil if defined?(ActionMailer)
+    end
+
+    if options.has_key?(:perform_caching)
+      ActionController::Base.perform_caching = options[:perform_caching]
+    else
+      ActionController::Base.perform_caching = false if ARGV.include?('-nocache')
+      ActionController::Base.perform_caching = true if ARGV.include?('-cache')
+    end
+
+    if options.has_key?(:cache_template_loading)
+      ActionView::Base.cache_template_loading = options[:cache_template_loading]
+    else
+      ActionView::Base.cache_template_loading = true
+    end
+
+    self.relative_url_root = options[:relative_url_root] || ''
+
+    @patched_gc = GC.collections.is_a?(Numeric) rescue false
+
+    if ARGV.include? '-headers_only'
+      require File.dirname(__FILE__) + '/write_headers_only'
+    end
+
+  end
+
+  def establish_test_session
+    session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.stringify_keys
+    session_options = session_options.merge('new_session' => true)
+    @session = CGI::Session.new(Hash.new, session_options)
+    @session_data.each{ |k,v| @session[k] = v }
+    @session.update
+    @session_id = @session.session_id
+  end
+
+  def delete_test_session
+    @session.delete
+    @session = nil
+  end
+
+  # can be redefined in subclasses to clean out test sessions
+  def delete_new_test_sessions
+  end
+
+  def setup_test_urls(name)
+    raise "There is no benchmark named '#{name}'" unless @url_spec[name]
+    @urls = self.class.parse_url_spec(@url_spec, name)
+  end
+
+  def setup_initial_env
+    ENV['REMOTE_ADDR'] = remote_addr
+    ENV['HTTP_HOST'] = http_host
+    ENV['SERVER_PORT'] = server_port.to_s
+    ENV['REQUEST_METHOD'] = 'GET'
+  end
+
+  def setup_request_env(uri, query_string, new_session)
+    ENV['REQUEST_URI'] = @relative_url_root + uri
+    ENV['QUERY_STRING'] = query_string || ''
+    ENV['CONTENT_LENGTH'] = (query_string || '').length.to_s
+    ENV['HTTP_COOKIE'] = new_session ? '' : "_session_id=#{@session_id}"
+  end
+
+  def warmup
+    error_exit "No urls given for performance test" unless @urls && @urls.size>0
+    setup_initial_env
+    @urls.each do |entry|
+      error_exit "No uri given for benchmark entry: #{entry.inspect}" unless entry['uri']
+      setup_request_env(entry['uri'], entry['query_string'], entry['new_session'])
+      Dispatcher.dispatch
+    end
+  end
+
+  def run_urls_without_benchmark(gc_stats)
+    # support for running Ruby Performance Validator
+    # or Ruby Memory Validator
+    svl = nil
+    begin
+      if ARGV.include?('-svlPV')
+        require 'svlRubyPV'
+        svl = SvlRubyPV.new
+      elsif ARGV.include?('-svlMV')
+        require 'svlRubyMV'
+        svl = SvlRubyMV.new
+      end
+    rescue LoadError
+      # SVL dll not available, do nothing
+    end
+
+    # support ruby-prof
+    ruby_prof = nil
+    ARGV.each{|arg| ruby_prof=$1 if arg =~ /-ruby_prof=(\d*\.?\d*)/ }
+    begin
+      if ruby_prof
+        require 'ruby-prof'
+        RubyProf.clock_mode = RubyProf::WALL_TIME
+        RubyProf.start
+      end
+    rescue LoadError
+      # ruby-prof not available, do nothing
+    end
+
+    # start profiler and trigger data collection if required
+    if svl
+      svl.startProfiler
+      svl.startDataCollection
+    end
+
+    setup_initial_env
+    GC.enable_stats if gc_stats
+    if gc_frequency==0
+      run_urls_without_benchmark_and_without_gc_control(@urls, iterations)
+    else
+      run_urls_without_benchmark_but_with_gc_control(@urls, iterations, gc_frequency)
+    end
+    if gc_stats
+      GC.enable if gc_frequency
+      GC.start
+      GC.dump
+      GC.disable_stats
+      GC.log "number of requests processed: #{@urls.size * iterations}"
+    end
+
+    # stop data collection if necessary
+    svl.stopDataCollection if svl
+
+    if defined? RubyProf
+      result = RubyProf.stop
+      # Print a flat profile to text
+      printer = RubyProf::GraphHtmlPrinter.new(result)
+      printer.print(STDERR, ruby_prof.to_f)
+    end
+
+    delete_test_session
+    delete_new_test_sessions
+  end
+
+  def run_urls(test)
+    setup_initial_env
+    if gc_frequency>0
+      run_urls_with_gc_control(test, @urls, iterations, gc_frequency)
+    else
+      run_urls_without_gc_control(test, @urls, iterations)
+    end
+    delete_test_session
+    delete_new_test_sessions
+  end
+
+  def run_url_mix(test)
+    if gc_frequency>0
+      run_url_mix_with_gc_control(test, @urls, iterations, gc_frequency)
+    else
+      run_url_mix_without_gc_control(test, @urls, iterations)
+    end
+    delete_test_session
+    delete_new_test_sessions
+  end
+
+  private
+
+  def run_urls_without_benchmark_but_with_gc_control(urls, n, gc_frequency)
+    urls.each do |entry|
+      setup_request_env(entry['uri'], entry['query_string'], entry['new_session'])
+      GC.enable; GC.start; GC.disable
+      request_count = 0
+      n.times do
+        Dispatcher.dispatch
+        if (request_count += 1) == gc_frequency
+          GC.enable; GC.start; GC.disable
+          request_count = 0
+        end
+      end
+    end
+  end
+
+  def run_urls_without_benchmark_and_without_gc_control(urls, n)
+    urls.each do |entry|
+      setup_request_env(entry['uri'], entry['query_string'], entry['new_session'])
+      n.times do
+        Dispatcher.dispatch
+      end
+    end
+  end
+
+  def run_urls_with_gc_control(test, urls, n, gc_freq)
+    gc_stats = patched_gc?
+    GC.clear_stats if gc_stats
+    urls.each do |entry|
+      request_count = 0
+      setup_request_env(entry['uri'], entry['query_string'], entry['new_session'])
+      test.report(entry['uri']) do
+        GC.disable_stats if gc_stats
+        GC.enable; GC.start; GC.disable
+        GC.enable_stats  if gc_stats
+        n.times do
+          Dispatcher.dispatch
+          if (request_count += 1) == gc_freq
+            GC.enable; GC.start; GC.disable
+            request_count = 0
+          end
+        end
+      end
+    end
+    if gc_stats
+      GC.disable_stats
+      Benchmark::OUTPUT.puts "GC.collections=#{GC.collections}, GC.time=#{GC.time/1E6}"
+      GC.clear_stats
+    end
+  end
+
+  def run_urls_without_gc_control(test, urls, n)
+    gc_stats = patched_gc?
+    GC.clear_stats if gc_stats
+    urls.each do |entry|
+      setup_request_env(entry['uri'], entry['query_string'], entry['new_session'])
+      GC.disable_stats if gc_stats
+      GC.start
+      GC.enable_stats  if gc_stats
+      test.report(entry['uri']) do
+        n.times do
+          Dispatcher.dispatch
+        end
+      end
+    end
+    if gc_stats
+      GC.disable_stats
+      Benchmark::OUTPUT.puts "GC.collections=#{GC.collections}, GC.time=#{GC.time/1E6}"
+      GC.clear_stats
+    end
+  end
+
+  def run_url_mix_without_gc_control(test, urls, n)
+    gc_stats = patched_gc?
+    GC.start
+    if gc_stats
+      GC.clear_stats; GC.enable_stats
+    end
+    test.report("url_mix (#{urls.length} urls)") do
+      n.times do
+        urls.each do |entry|
+          setup_request_env(entry['uri'], entry['query_string'], entry['new_session'])
+          Dispatcher.dispatch
+        end
+      end
+    end
+    if gc_stats
+      GC.disable_stats
+      Benchmark::OUTPUT.puts "GC.collections=#{GC.collections}, GC.time=#{GC.time/1E6}"
+      GC.clear_stats
+    end
+  end
+
+  def run_url_mix_with_gc_control(test, urls, n, gc_frequency)
+    gc_stats = patched_gc?
+    GC.enable; GC.start; GC.disable
+    if gc_stats
+      GC.clear_stats; GC.enable_stats
+    end
+    test.report("url_mix (#{urls.length} urls)") do
+      request_count = 0
+      n.times do
+        urls.each do |entry|
+          setup_request_env(entry['uri'], entry['query_string'], entry['new_session'])
+          Dispatcher.dispatch
+          if (request_count += 1) == gc_frequency
+            GC.enable; GC.start; GC.disable
+            request_count = 0
+          end
+        end
+      end
+    end
+    if gc_stats
+      GC.disable_stats
+      Benchmark::OUTPUT.puts "GC.collections=#{GC.collections}, GC.time=#{GC.time/1E6}"
+      GC.clear_stats
+    end
+  end
+
+  def self.parse_url_spec(url_spec, name)
+    res = url_spec[name]
+    if res.is_a?(String)
+      res = res.split(/, */).collect!{ |n| parse_url_spec(url_spec, n) }.flatten
+    elsif res.is_a?(Hash)
+      res = [ res ]
+    end
+    res
+  end
+
+end
+
+
+class RailsBenchmarkWithActiveRecordStore < RailsBenchmark
+
+  def initialize(options={})
+    super(options)
+    @session_class = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS[:database_manager].session_class rescue CGI::Session::ActiveRecordStore
+  end
+
+  def delete_new_test_sessions
+    @session_class.delete_all if @session_class.respond_to?(:delete_all)
+  end
+
+end
+
+
+__END__
+
+#  Copyright (C) 2005, 2006  Stefan Kaes
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA