zenprofile 1.0.2

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2008-09-17
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,10 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/zenprofile
+lib/spy_on.rb
+lib/zenprofile.rb
+lib/zenprofiler.rb
+misc/factorial.rb
+zenprofile-demo.sh

data/README.txt

@@ -0,0 +1,86 @@
+= zenprofile
+
+* http://rubyforge.org/projects/seattlerb
+
+== DESCRIPTION:
+
+zenprofiler helps answer WHAT is being called the most. spy_on helps
+answer WHERE those calls are being made. ZenProfiler provides a faster
+version of the standard library ruby profiler. It is otherwise pretty
+much the same as before. spy_on provides a clean way to redefine a
+bottleneck method so you can account for and aggregate all the calls
+to it.
+
+    % ruby -Ilib bin/zenprofile misc/factorial.rb 50000
+    Total time = 3.056884
+    Total time = 2.390000
+    
+              total     self              self    total
+    % time  seconds  seconds    calls  ms/call  ms/call  name
+     50.70     1.64     1.64    50000     0.03     0.05 Integer#downto
+     19.63     2.27     0.63   200000     0.00     0.00 Fixnum#*
+     14.19     2.73     0.46    50000     0.01     0.05 Factorial#factorial
+      9.93     3.05     0.32        1   320.36  3047.10 Range#each
+      5.54     3.23     0.18        2    89.40   178.79 ZenProfiler#start_hook
+
+Once you know that Integer#downto takes 50% of the entire run, you
+can use spy_on to find it. (See misc/factorial.rb for the actual code):
+
+    % SPY=1 ruby -Ilib misc/factorial.rb 50000
+    Spying on Integer#downto
+    
+    Integer.downto
+    
+    50000: total
+    50000: ./misc/factorial.rb:6:in `factorial' via 
+           ./misc/factorial.rb:6:in `factorial'
+
+== FEATURES/PROBLEMS:
+
+* 4x faster than stdlib ruby profiler by using event_hook to bypass set_trace_func
+* 1/14th the amount of code of ruby-prof. Much easier to play with.
+
+== SYNOPSIS:
+
+    % zenprofile [ruby-flags] misc/factorial.rb
+
+then:
+
+    Array.spy_on :select, :each
+
+run your code, then you'll see where the calls to Array#select and
+#each are coming from.
+
+== REQUIREMENTS:
+
+* event_hook
+* RubyInline
+
+== INSTALL:
+
+* sudo gem install zenprofile
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Ryan Davis, seattle.rb
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/zenprofiler.rb'
+
+Hoe.new('zenprofile', ZenProfiler::VERSION) do |p|
+  p.rubyforge_name = 'seattlerb'
+  p.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+
+  p.extra_deps << 'ZenTest'
+  p.extra_deps << 'event_hook'
+  p.extra_deps << 'RubyInline'
+end
+
+# vim: syntax=Ruby

data/bin/zenprofile

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'rbconfig'
+
+ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['RUBY_INSTALL_NAME'])
+dir = File.join(File.dirname(File.dirname(__FILE__)), 'lib')
+
+exec ruby, "-I#{dir}", '-rzenprofile', *ARGV

data/lib/spy_on.rb

@@ -0,0 +1,70 @@
+$: << '../../ZenTest/dev/lib'
+
+require 'zentest_mapping'
+
+##
+# require 'test/spy_on'
+#
+# class Array
+#   spy_on :select, :each
+# end
+#
+# class Hash
+#   spy_on :key?
+#   # spy_on :[]
+# end
+
+class Hash
+  alias_method :safe_idx, :[]
+  alias_method :safe_asgn, :[]=
+end
+
+class Module
+  include ZenTestMapping
+
+  def call_site(depth=1)
+    paths = caller(2).map { |path| path =~ /\(eval\)/ ? path : File.expand_path(path).sub(/#{File.expand_path Dir.pwd}/, '.') }
+    our = paths.reject { |path| path =~ /vendor.rails|rubygems/ }
+    return ["#{our.first} via "] + paths.first(depth)
+  end
+
+  def print_tally(tallies)
+    tallies.sort.each do |msg, tally|
+      puts
+      puts msg
+      puts
+      total = 0
+      tally.values.each do |n| total += n; end
+      puts "%5d: %s" % [total, "total"]
+
+      tally.sort_by { |caller, count| -count }.first(5).each do |caller, count|
+        puts "%5d: %s" % [count, caller.join("\n       ")]
+      end
+    end
+  end
+
+  def spy msg, old_msg = nil, depth = 1
+    puts "Spying on #{self}##{msg}"
+    old_msg ||= "old_#{normal_to_test(msg.to_s).sub(/^test_/, '')}"
+    alias_method old_msg, msg
+
+    class_eval "
+      @@tally_done = false
+      @@tally ||= Hash.new { |h,k| h.safe_asgn(k, Hash.new(0)) }
+      at_exit { at_exit { @@tally_done = true; print_tally @@tally if @@tally; @@tally = nil } }
+      def #{msg}(*args, &block)
+        unless @@tally_done then
+          site = self.class.call_site(#{depth})
+          x = @@tally.safe_idx('#{self}.#{msg}')
+          x.safe_asgn(site, x.safe_idx(site) + 1)
+        end
+        self.#{old_msg}(*args, &block)
+      end "
+  end
+
+  def spy_on *msgs
+    msgs.each do |msg|
+      spy msg
+    end
+  end
+end

data/lib/zenprofile.rb

@@ -0,0 +1,3 @@
+require 'zenprofiler'
+
+ZenProfiler.run

data/lib/zenprofiler.rb

@@ -0,0 +1,215 @@
+require 'rubygems'
+require 'inline'
+require 'singleton'
+$: << '../../event_hook/dev/lib' # TODO: remove
+require 'event_hook'
+
+##
+# ZenProfiler provides a faster version of the standard library ruby
+# profiler. It is otherwise pretty much the same as before.
+#
+# Invoke it via:
+#
+#    % zenprofile misc/factorial.rb
+#
+# or:
+#
+#    % ruby -rzenprofile misc/factorial.rb
+
+class ZenProfiler < EventHook
+  VERSION = '1.0.2'
+
+  @@start = nil
+  @@stack = [[0, 0, [nil, :toplevel]], [0, 0, [nil, :dummy]]]
+  @@map   = Hash.new { |h,k| h[k] = [0, 0.0, 0.0, k] }
+  @@map["#toplevel"] = [1, 0.0, 0.0, [nil, "#toplevel"]]
+  @@percent_time_threshold = 0.5
+
+  def self.run(fp = $stdout, opts = {})
+    at_exit {
+      ZenProfiler::print_profile fp, opts
+    }
+    ZenProfiler::start_hook
+  end
+
+  def self.start_hook
+    @@start  ||= Time.now.to_f
+    @@start2 ||= Process.times[0]
+    super
+  end
+
+  def self.percent_time_threshold
+    @@percent_time_threshold
+  end
+
+  def self.percent_time_threshold=(percent_time_threshold)
+    @@percent_time_threshold = percent_time_threshold
+  end
+
+  def self.print_profile(f, opts = {})
+    stop_hook
+
+    @@total = Time.now.to_f - @@start
+    @@total = 0.01 if @@total == 0
+    @@total2 = Process.times[0] - @@start2
+    @@map["#toplevel"][1] = @@total
+    data = @@map.values.sort_by { |vals| -vals[2] }
+    sum = 0
+
+    f.puts "Total time = %f" % @@total
+    f.puts "Total time = %f" % @@total2
+    f.puts
+    f.puts "          total     self              self    total"
+    f.puts "% time  seconds  seconds    calls  ms/call  ms/call  name"
+
+    @@total = data.inject(0) { |acc, (_, _, self_ms, _)| acc + self_ms }
+
+    data.each do |calls, total_ms, self_ms, name|
+      percent_time = self_ms / @@total * 100.0
+
+      next if percent_time < @@percent_time_threshold
+
+      sum += self_ms
+      klass = name.first
+      meth  = name.last.to_s
+
+      signature =
+        if klass.nil?
+          meth
+        elsif klass.kind_of?(Module)
+          klassname = klass.name rescue klass.to_s.sub(/#<\S+:(\S+)>/, '\\1')
+          "#{klassname}##{meth}"
+        else
+          "#{klass.class}##{meth}"
+        end
+
+      f.printf "%6.2f ",  percent_time
+      f.printf "%8.2f ", sum
+      f.printf "%8.2f ",  self_ms
+      f.printf "%8d ",    calls
+      f.printf "%8.2f ",  (self_ms * 1000.0 / calls)
+      f.printf "%8.2f ",  (total_ms * 1000.0 / calls)
+      f.printf "%s",      signature
+      f.puts
+    end
+  end
+
+  if ENV['PURERUBY'] then
+    def self.process event, obj, method, klass
+      case event
+      when CALL, CCALL
+        now = Process.times[0]
+        @@stack.push [now, 0.0]
+      when RETURN, CRETURN
+        key = [klass, method]
+        if tick = @@stack.pop
+          now = Process.times[0]
+          data = @@map[key]
+          data[0] += 1
+          cost = now - tick[0]
+          data[1] += cost
+          data[2] += cost - tick[1]
+          @@stack[-1][1] += cost if @@stack[-1]
+        end
+      end
+    end
+  else
+    class Inline::C # REFACTOR
+      def add_static name, init, type = "VALUE"
+        prefix      "static #{type} #{name};"
+        add_to_init "#{name} = #{init};"
+      end
+    end
+
+    inline(:C) do |builder|
+      builder.add_type_converter("rb_event_t", '', '')
+      builder.add_type_converter("ID", '', '')
+      builder.add_type_converter("NODE *", '', '')
+
+      builder.include '<time.h>'
+      builder.include '"node.h"'
+
+      builder.add_static 'profiler_klass',  'rb_path2class("ZenProfiler")'
+      builder.add_static 'eventhook_klass', 'rb_path2class("EventHook")'
+      builder.add_static 'stack',           'rb_cv_get(profiler_klass, "@@stack")'
+      builder.add_static 'map',             'rb_cv_get(profiler_klass, "@@map")'
+
+      builder.add_static 'id_allocate', 'rb_intern("allocate")'
+
+      builder.prefix "
+        #define id_call    INT2FIX(RUBY_EVENT_CALL)
+        #define id_ccall   INT2FIX(RUBY_EVENT_C_CALL)
+        #define id_return  INT2FIX(RUBY_EVENT_RETURN)
+        #define id_creturn INT2FIX(RUBY_EVENT_C_RETURN)
+      "
+
+      builder.prefix <<-'EOF'
+        VALUE time_now() {
+          return rb_float_new(((double) clock() / CLOCKS_PER_SEC));
+        }
+      EOF
+
+      builder.c_singleton <<-'EOF'
+      static void
+      process(VALUE event, VALUE recv, VALUE method, VALUE klass) {
+        static int profiling = 0;
+
+        if (method == id_allocate) return;
+        if (profiling) return;
+        profiling++;
+
+        VALUE now = time_now();
+
+        switch (event) {
+        case id_call:
+        case id_ccall:
+          {
+            VALUE time = rb_ary_new2(2);
+            rb_ary_store(time, 0, now);
+            rb_ary_store(time, 1, rb_float_new(0.0));
+            rb_ary_push(stack, time);
+          }
+          break;
+        case id_return:
+        case id_creturn:
+          {
+            if (TYPE(klass) == T_ICLASS) {
+              klass = RBASIC(klass)->klass;
+            } else if (FL_TEST(klass, FL_SINGLETON)) {
+              klass = recv;
+            }
+
+            VALUE key = rb_ary_new2(2);
+            rb_ary_store(key, 0, klass);
+            rb_ary_store(key, 1, method);
+
+            VALUE tick = rb_ary_pop(stack);
+            if (!RTEST(tick)) break;
+
+            VALUE data = rb_hash_aref(map, key);
+
+            rb_ary_store(data, 0, rb_ary_entry(data, 0) + 2); // omg I suck
+
+            double cost = NUM2DBL(now) - NUM2DBL(rb_ary_entry(tick, 0));
+
+            rb_ary_store(data, 1, rb_float_new(NUM2DBL(rb_ary_entry(data, 1))
+                                               + cost));
+
+            rb_ary_store(data, 2, rb_float_new(NUM2DBL(rb_ary_entry(data, 2))
+                                               + cost
+                                               - NUM2DBL(rb_ary_entry(tick, 1))));
+
+            VALUE toplevel = rb_ary_entry(stack, -1);
+            if (RTEST(toplevel)) {
+              VALUE tl_stats = rb_ary_entry(toplevel, 1);
+              rb_ary_store(toplevel, 1, rb_float_new(NUM2DBL(tl_stats) + cost));
+            }
+          }
+          break;
+        } // switch (event)
+        profiling--;
+      }
+      EOF
+    end
+  end
+end

data/misc/factorial.rb

@@ -0,0 +1,32 @@
+#!/usr/local/bin/ruby -w
+
+class Factorial
+  def factorial(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    return f
+  end
+end
+
+if ENV['SPY'] then
+  require 'spy_on'
+
+  Integer.spy_on :downto
+end
+
+if $0 == __FILE__ then
+  f = Factorial.new()
+
+  max = ARGV.shift || 1000000
+  max = max.to_i
+
+  tstart = Time.now
+
+  (1..max).each { |m| n = f.factorial(5); }
+
+  tend = Time.now
+
+  total = tend - tstart
+  avg = total / max
+#  printf "Iter = #{max}, T = %.8f sec, %.8f sec / iter\n", total, avg
+end

data/zenprofile-demo.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+N=$1
+
+if [ -z $N ]; then N=100_000; fi
+if [ -z $2 ]; then SKIP=no; else SKIP=yes; fi
+
+rm -rf ~/.ruby_inline
+sync; sync; sync
+
+echo N=$N
+
+if [ $SKIP = no ]; then
+    echo
+    echo ruby vanilla :
+    X=1 time ruby misc/factorial.rb $N
+
+    echo
+    echo ruby profiler:
+    X=1 time ruby -rprofile misc/factorial.rb $N 2>&1 | egrep -v "^ *0.00"
+fi
+
+echo
+echo zen profiler :
+export GEM_SKIP=RubyInline
+X=1 time ./bin/zenprofile misc/factorial.rb $N 2>&1 | egrep -v "^ *0.00"
+
+echo
+echo zen profiler pure ruby:
+export GEM_SKIP=RubyInline
+PURERUBY=1 time ./bin/zenprofile misc/factorial.rb $N 2>&1 | egrep -v "^ *0.00"
+
+# shugo's version
+# time ruby -I.:lib -runprof misc/factorial.rb $N 2>&1 | head

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification 
+name: zenprofile
+version: !ruby/object:Gem::Version 
+  version: 1.0.2
+platform: ruby
+authors: 
+- Ryan Davis
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDPjCCAiagAwIBAgIBADANBgkqhkiG9w0BAQUFADBFMRMwEQYDVQQDDApyeWFu
+  ZC1ydWJ5MRkwFwYKCZImiZPyLGQBGRYJemVuc3BpZGVyMRMwEQYKCZImiZPyLGQB
+  GRYDY29tMB4XDTA5MDMwNjE4NTMxNVoXDTEwMDMwNjE4NTMxNVowRTETMBEGA1UE
+  AwwKcnlhbmQtcnVieTEZMBcGCgmSJomT8ixkARkWCXplbnNwaWRlcjETMBEGCgmS
+  JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALda
+  b9DCgK+627gPJkB6XfjZ1itoOQvpqH1EXScSaba9/S2VF22VYQbXU1xQXL/WzCkx
+  taCPaLmfYIaFcHHCSY4hYDJijRQkLxPeB3xbOfzfLoBDbjvx5JxgJxUjmGa7xhcT
+  oOvjtt5P8+GSK9zLzxQP0gVLS/D0FmoE44XuDr3iQkVS2ujU5zZL84mMNqNB1znh
+  GiadM9GHRaDiaxuX0cIUBj19T01mVE2iymf9I6bEsiayK/n6QujtyCbTWsAS9Rqt
+  qhtV7HJxNKuPj/JFH0D2cswvzznE/a5FOYO68g+YCuFi5L8wZuuM8zzdwjrWHqSV
+  gBEfoTEGr7Zii72cx+sCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+  HQYDVR0OBBYEFEfFe9md/r/tj/Wmwpy+MI8d9k/hMA0GCSqGSIb3DQEBBQUAA4IB
+  AQAY59gYvDxqSqgC92nAP9P8dnGgfZgLxP237xS6XxFGJSghdz/nI6pusfCWKM8m
+  vzjjH2wUMSSf3tNudQ3rCGLf2epkcU13/rguI88wO6MrE0wi4ZqLQX+eZQFskJb/
+  w6x9W1ur8eR01s397LSMexySDBrJOh34cm2AlfKr/jokKCTwcM0OvVZnAutaovC0
+  l1SVZ0ecg88bsWHA0Yhh7NFxK1utWoIhtB6AFC/+trM0FQEB/jZkIS8SaNzn96Rl
+  n0sZEf77FLf5peR8TP/PtmIg7Cyqz23sLM4mCOoTGIy5OcZ8TdyiyINUHtb5ej/T
+  FBHgymkyj/AOSqKRIpXPhjC6
+  -----END CERTIFICATE-----
+
+date: 2009-05-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ZenTest
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: event_hook
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.12.2
+    version: 
+description: |-
+  zenprofiler helps answer WHAT is being called the most. spy_on helps
+  answer WHERE those calls are being made. ZenProfiler provides a faster
+  version of the standard library ruby profiler. It is otherwise pretty
+  much the same as before. spy_on provides a clean way to redefine a
+  bottleneck method so you can account for and aggregate all the calls
+  to it.
+  
+      % ruby -Ilib bin/zenprofile misc/factorial.rb 50000
+      Total time = 3.056884
+      Total time = 2.390000
+      
+                total     self              self    total
+      % time  seconds  seconds    calls  ms/call  ms/call  name
+       50.70     1.64     1.64    50000     0.03     0.05 Integer#downto
+       19.63     2.27     0.63   200000     0.00     0.00 Fixnum#*
+       14.19     2.73     0.46    50000     0.01     0.05 Factorial#factorial
+        9.93     3.05     0.32        1   320.36  3047.10 Range#each
+        5.54     3.23     0.18        2    89.40   178.79 ZenProfiler#start_hook
+  
+  Once you know that Integer#downto takes 50% of the entire run, you
+  can use spy_on to find it. (See misc/factorial.rb for the actual code):
+  
+      % SPY=1 ruby -Ilib misc/factorial.rb 50000
+      Spying on Integer#downto
+      
+      Integer.downto
+      
+      50000: total
+      50000: ./misc/factorial.rb:6:in `factorial' via 
+             ./misc/factorial.rb:6:in `factorial'
+email: 
+- ryand-ruby@zenspider.com
+executables: 
+- zenprofile
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/zenprofile
+- lib/spy_on.rb
+- lib/zenprofile.rb
+- lib/zenprofiler.rb
+- misc/factorial.rb
+- zenprofile-demo.sh
+has_rdoc: true
+homepage: http://rubyforge.org/projects/seattlerb
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: seattlerb
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: zenprofiler helps answer WHAT is being called the most
+test_files: []
+