ruby-prof-danielhoey 0.8.1

data/ext/ruby_prof/ruby_prof.h

@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
+ *                     Charlie Savage <cfis@savagexi.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* ruby-prof tracks the time spent executing every method in ruby programming.
+   The main players are:
+
+     prof_result_t     - Its one field, values,  contains the overall results
+     thread_data_t     - Stores data about a single thread.  
+     prof_stack_t      - The method call stack in a particular thread
+     prof_method_t     - Profiling information for each method
+     prof_call_info_t  - Keeps track a method's callers and callees. 
+
+  The final resulut is a hash table of thread_data_t, keyed on the thread
+  id.  Each thread has an hash a table of prof_method_t, keyed on the
+  method id.  A hash table is used for quick look up when doing a profile.
+  However, it is exposed to Ruby as an array.
+  
+  Each prof_method_t has two hash tables, parent and children, of prof_call_info_t.
+  These objects keep track of a method's callers (who called the method) and its
+  callees (who the method called).  These are keyed the method id, but once again,
+  are exposed to Ruby as arrays.  Each prof_call_into_t maintains a pointer to the
+  caller or callee method, thereby making it easy to navigate through the call 
+  hierarchy in ruby - which is very helpful for creating call graphs.      
+*/
+
+/* #define DEBUG */
+
+#ifndef RUBY_PROF_H
+#define RUBY_PROF_H
+
+#include <stdio.h>
+
+#include <ruby.h>
+
+#ifndef RUBY_VM
+#include <node.h>
+#include <st.h>
+typedef rb_event_t rb_event_flag_t;
+#define rb_sourcefile() (node ? node->nd_file : 0)
+#define rb_sourceline() (node ? nd_line(node) : 0)
+#endif
+
+#include "version.h"
+
+/* ================  Constants  =================*/
+#define INITIAL_STACK_SIZE 8
+#define INITIAL_CALL_INFOS_SIZE 2
+
+
+/* ================  Measurement  =================*/
+#include "measurement.h"
+#include "measure_process_time.h"
+#include "measure_wall_time.h"
+#include "measure_cpu_time.h"
+#include "measure_allocations.h"
+#include "measure_memory.h"
+#include "measure_gc_runs.h"
+#include "measure_gc_time.h"
+
+prof_measure_t (*get_measurement)() = measure_process_time;
+double (*convert_measurement)(prof_measure_t) = convert_process_time;
+
+/* ================  DataTypes  =================*/
+static VALUE mProf;
+static VALUE cResult;
+static VALUE cMethodInfo;
+static VALUE cCallInfo;
+
+/* Profiling information for each method. */
+typedef struct {
+    VALUE klass;                            /* The method's class. */
+    ID mid;                                 /* The method id. */
+    int depth;                              /* The recursion depth. */
+    int key;                                /* Cache calculated key */
+} prof_method_key_t;
+
+struct prof_call_infos_t;
+
+/* Profiling information for each method. */
+typedef struct {
+    prof_method_key_t *key;                 /* Method key */
+    const char *source_file;                /* The method's source file */
+    int line;                               /* The method's line number. */
+    int active;                             /* Is this  recursion depth. */
+    struct prof_call_infos_t *call_infos;   /* Call info objects for this method */
+    VALUE object;                           /* Cahced ruby object */
+} prof_method_t;
+
+/* Callers and callee information for a method. */
+typedef struct prof_call_info_t {
+    prof_method_t *target; /* Use target instead of method to avoid conflict with Ruby method */
+    struct prof_call_info_t *parent;
+    st_table *call_infos;
+    int called;
+    prof_measure_t total_time;
+    prof_measure_t self_time;
+    prof_measure_t wait_time;
+    int line;  
+    VALUE object;
+    VALUE children;
+} prof_call_info_t;
+
+/* Array of call_info objects */
+typedef struct prof_call_infos_t {
+    prof_call_info_t **start;
+    prof_call_info_t **end;
+    prof_call_info_t **ptr;
+    VALUE object;
+} prof_call_infos_t;
+
+
+/* Temporary object that maintains profiling information
+   for active methods - there is one per method.*/
+typedef struct {
+    /* Caching prof_method_t values significantly
+       increases performance. */
+    prof_call_info_t *call_info;
+    prof_measure_t start_time;
+    prof_measure_t wait_time;
+    prof_measure_t child_time;
+    unsigned int line;
+} prof_frame_t;
+
+/* Current stack of active methods.*/
+typedef struct {
+    prof_frame_t *start;
+    prof_frame_t *end;
+    prof_frame_t *ptr;
+} prof_stack_t;
+
+/* Profiling information for a thread. */
+typedef struct {
+    VALUE thread_id;                  /* Thread id */
+    st_table* method_table;           /* Methods called in the thread */
+    prof_stack_t* stack;              /* Active methods */
+    prof_measure_t last_switch;       /* Point of last context switch */
+} thread_data_t;
+
+typedef struct {
+    VALUE threads;
+} prof_result_t;
+
+
+/* ================  Variables  =================*/
+static int measure_mode;
+static st_table *threads_tbl = NULL;
+static st_table *exclude_threads_tbl = NULL;
+
+/* TODO - If Ruby become multi-threaded this has to turn into
+   a separate stack since this isn't thread safe! */
+static thread_data_t* last_thread_data = NULL;
+
+
+/* Forward declarations */
+static VALUE prof_call_infos_wrap(prof_call_infos_t *call_infos);
+static VALUE prof_call_info_wrap(prof_call_info_t *call_info);
+static VALUE prof_method_wrap(prof_method_t *result);
+
+#endif

data/ext/ruby_prof/version.h

@@ -0,0 +1,4 @@
+#define RUBY_PROF_VERSION  "0.8.1"
+#define RUBY_PROF_VERSION_MAJ   0
+#define RUBY_PROF_VERSION_MIN   8
+#define RUBY_PROF_VERSION_MIC   1

data/lib/ruby-prof.rb

@@ -0,0 +1,59 @@
+# require the  .so file
+me = File.dirname(__FILE__) + '/'
+begin
+  # fat binaries
+  require "#{me}/#{RUBY_VERSION[0..2]}/ruby_prof"
+rescue Exception
+  require "#{me}/../ext/ruby_prof/ruby_prof"
+end
+
+require "ruby-prof/method_info"
+require "ruby-prof/call_info"
+require "ruby-prof/aggregate_call_info"
+require "ruby-prof/flat_printer"
+require "ruby-prof/flat_printer_with_line_numbers"
+require "ruby-prof/graph_printer"
+require "ruby-prof/graph_html_printer"
+require "ruby-prof/call_tree_printer"
+require "ruby-prof/symbol_to_proc" # for 1.8's benefit
+#require "ruby-prof/result"
+require "ruby-prof/call_tree/abstract_printer"
+require "ruby-prof/call_tree/text_printer"
+require "ruby-prof/call_tree/html_printer"
+
+module RubyProf
+  # See if the user specified the clock mode via 
+  # the RUBY_PROF_MEASURE_MODE environment variable
+  def self.figure_measure_mode
+    case ENV["RUBY_PROF_MEASURE_MODE"]
+    when "wall" || "wall_time"
+      RubyProf.measure_mode = RubyProf::WALL_TIME
+    when "cpu" || "cpu_time"
+      if ENV.key?("RUBY_PROF_CPU_FREQUENCY")
+        RubyProf.cpu_frequency = ENV["RUBY_PROF_CPU_FREQUENCY"].to_f
+      else
+        begin
+          open("/proc/cpuinfo") do |f|
+            f.each_line do |line|
+              s = line.slice(/cpu MHz\s*:\s*(.*)/, 1)
+              if s
+                RubyProf.cpu_frequency = s.to_f * 1000000
+                break
+              end
+            end
+          end
+        rescue Errno::ENOENT
+        end
+      end
+      RubyProf.measure_mode = RubyProf::CPU_TIME
+    when "allocations"
+      RubyProf.measure_mode = RubyProf::ALLOCATIONS
+    when "memory"
+      RubyProf.measure_mode = RubyProf::MEMORY
+    else
+      RubyProf.measure_mode = RubyProf::PROCESS_TIME
+    end
+  end
+end
+
+RubyProf::figure_measure_mode

data/lib/ruby-prof/abstract_printer.rb

@@ -0,0 +1,41 @@
+module RubyProf
+  class AbstractPrinter
+    def initialize(result)
+      @result = result
+      @output = nil
+      @options = {}
+    end
+
+    # Specify print options.
+    # 
+    # options - Hash table
+    #   :min_percent - Number 0 to 100 that specifes the minimum
+    #                  %self (the methods self time divided by the
+    #                  overall total time) that a method must take
+    #                  for it to be printed out in the report.
+    #                  Default value is 0.
+    #
+    #   :print_file  - True or false. Specifies if a method's source
+    #                  file should be printed.  Default value if false.
+    #
+    def setup_options(options = {})
+      @options = options
+    end      
+
+    def min_percent
+      @options[:min_percent] || 0
+    end
+    
+    def print_file
+      @options[:print_file] || false
+    end
+    
+    def method_name(method)
+      name = method.full_name
+      if print_file
+        name += " (#{method.source_file}:#{method.line}}"
+      end
+      name
+    end
+  end
+end 

data/lib/ruby-prof/aggregate_call_info.rb

@@ -0,0 +1,62 @@
+module RubyProf
+  class AggregateCallInfo
+    attr_reader :call_infos
+    def initialize(call_infos)
+      if call_infos.length == 0
+        raise(ArgumentError, "Must specify at least one call info.")
+      end
+      @call_infos = call_infos
+    end
+
+    def target
+      call_infos.first.target
+    end
+
+    def parent
+      call_infos.first.parent
+    end
+
+    def line
+      call_infos.first.line
+    end
+
+    def children
+      call_infos.inject(Array.new) do |result, call_info|
+        result.concat(call_info.children)
+      end
+    end
+
+    def total_time
+      aggregate(:total_time)
+    end
+
+    def self_time
+      aggregate(:self_time)
+    end
+
+    def wait_time
+      aggregate(:wait_time)
+    end
+
+    def children_time
+      aggregate(:children_time)
+    end
+
+    def called
+      aggregate(:called)
+    end
+
+    def to_s
+      "#{call_infos.first.full_name}"
+    end
+
+    private
+
+    def aggregate(method_name)
+      self.call_infos.inject(0) do |sum, call_info|
+        sum += call_info.send(method_name)
+        sum
+      end
+    end
+  end
+end

data/lib/ruby-prof/call_info.rb

@@ -0,0 +1,47 @@
+module RubyProf
+  class CallInfo
+    def depth
+      result = 0
+      call_info = self.parent
+
+      while call_info
+        result += 1
+        call_info = call_info.parent
+      end
+      result
+    end
+
+    def children_time
+      children.inject(0) do |sum, call_info|
+        sum += call_info.total_time
+      end
+    end
+
+    def stack
+      @stack ||= begin
+        methods = Array.new
+        call_info = self
+
+        while call_info
+          methods << call_info.target
+          call_info = call_info.parent
+        end
+        methods.reverse
+      end
+    end
+
+    def call_sequence
+      @call_sequence ||= begin
+        stack.map {|method| method.full_name}.join('->')
+      end
+    end
+
+    def root?
+      self.parent.nil?
+    end
+
+    def to_s
+      "#{call_sequence}"
+    end
+  end
+end

data/lib/ruby-prof/call_tree/abstract_printer.rb

@@ -0,0 +1,24 @@
+module RubyProf
+  class CallTreeAbstractPrinter
+    def initialize(call_tree, min_percentage=0)
+      @call_tree = call_tree
+      @min_percentage = min_percentage.to_f
+    end
+
+    def print(io)
+      print_methods(io, @call_tree.children)
+    end
+
+    def print_methods(io, methods, parent_time=nil)
+      methods.sort_by{|m| m.time}.reverse.each do |method|
+        io << format_method(method)
+        next if parent_time and method.time < parent_time * @min_percentage / 100
+        print_methods(io, method.children, method.time)
+      end
+    end
+
+    def format_method(method)
+      raise "abstract"
+    end
+  end
+end

data/lib/ruby-prof/call_tree/html_printer.rb

@@ -0,0 +1,89 @@
+require 'erb'
+require 'rexml/document'
+require 'cgi'
+
+module RubyProf
+  class CallTreeHtmlPrinter < CallTreeAbstractPrinter
+    def initialize(call_tree, min_percentage=2)
+      super(call_tree, min_percentage)
+      @total_time = call_tree.children.inject(0){|s, c| s+=c.time}
+    end
+
+    def print(io)
+      @result = print_methods(@call_tree.children, @call_tree.time)
+      @result = "<div id='main'>main (#{@total_time}s)\n  #{@result}\n</div>"
+      formatted_result = ''
+      REXML::Document.new(@result).write(formatted_result, 2)
+      @result = formatted_result
+      erb = ERB.new(page_template, nil, nil)
+      io << erb.result(binding)      
+    end
+
+    def print_methods(method_calls, parent_time)
+      result = ''
+      
+      significant_method_calls = method_calls.find_all{|call| call.time >= (parent_time * @min_percentage.to_f / 100) and percentage(call.time) >= @min_percentage/2}
+      significant_method_calls.sort_by{|m| m.time}.reverse.each do |method|
+        @method = method
+        if method.children.empty? 
+          erb = ERB.new(leaf_template, nil, nil)
+        else
+          erb = ERB.new(node_template, nil, nil)
+        end
+        result << erb.result(binding)
+      end
+    
+      return result
+      
+      @insignificant_method_calls = method_calls - significant_method_calls
+      unless @insignificant_method_calls.empty?
+        erb = ERB.new(insignificant_calls_template, nil, nil)
+        result << erb.result(binding)
+      end
+      
+      result
+    end
+    
+    def print_leaf(method_call)
+      @method = method_call
+      ERB.new(leaf_template, nil, nil).result(binding)
+    end
+
+    def percentage(time)
+      ((time * 100) / @total_time).to_i
+    end
+
+    def page_template
+     @page_template ||= File.read("#{File.dirname(__FILE__)}/html_printer_output.html.erb")
+    end
+
+    def node_template
+      %Q{<div class="call_tree_node" time="#{percentage(@method.time)}" onclick="CallTree.click(this, event)">#{call_summary(@method)}
+           <span class="nodes_not_shown">...</span>
+           <%= print_methods(@method.children, method.time) %>
+         </div>}.strip
+    end
+
+    def leaf_template
+      %Q{<div class="call_tree_node leaf" time="#{percentage(@method.time)}">#{call_summary(@method)}</div>}
+    end
+    
+    def insignificant_calls_template
+      %Q{<div class="hide_child_nodes" onclick="CallTree.click(this, event)">            
+           <div class="nodes_not_shown">...</div>
+           <% @insignificant_method_calls.each do |call| %>
+             <%= print_leaf(call) %>
+           <% end %>
+         </div>}.strip
+    end
+    
+    def call_summary(call)
+      klass, method = %w(klass method).collect{|m| CGI.escapeHTML(call.send(m).to_s)}
+      if percentage(call.time) < 1
+        "#{klass}::#{method}"
+      else
+        "<span class='klass_and_method'>#{klass}::#{method}</span> - <span class='percentage'>#{percentage(call.time)}%</span> <span class='extra_info'>(<span class='file'>#{call.file},</span> <span class='time'>#{(call.time*1000).to_i}ms,</span> <span class='call_count'>#{call.call_count} calls</span>)</span>"
+      end
+    end
+  end
+end