acunote-ruby-prof 0.9.2

data/ext/ruby_prof/ruby_prof.h

@@ -0,0 +1,190 @@
+/*
+ * 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.
+*/
+
+#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  =================*/
+#ifdef HAVE_LONG_LONG
+typedef unsigned LONG_LONG prof_measure_t; // long long is 8 bytes on 32-bit
+#else
+typedef unsigned long prof_measure_t;
+#endif
+
+#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"
+
+static prof_measure_t (*get_measurement)() = measure_process_time;
+static double (*convert_measurement)(prof_measure_t) = convert_process_time;
+
+/* ================  DataTypes  =================*/
+static VALUE mProf;
+static VALUE cResult;
+static VALUE cMethodInfo;
+static VALUE cCallInfo;
+
+/* nasty hack to avoid compilation warnings related to 64/32 bit conversions */
+#ifndef SIZEOF_ST_INDEX_T
+#define st_index_t int
+#endif
+
+/* Profiling information for each method. */
+typedef struct {
+    VALUE klass;                            /* The method's class. */
+    ID mid;                                 /* The method id. */
+    int depth;                              /* The recursion depth. */
+    st_index_t 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. */
+    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.9.2" // for easy parsing from rake files
+#define RUBY_PROF_VERSION_MAJ   0
+#define RUBY_PROF_VERSION_MIN   9
+#define RUBY_PROF_VERSION_MIC   2

data/lib/ruby-prof.rb

@@ -0,0 +1,62 @@
+# 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/result"
+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/call_stack_printer"
+require "ruby-prof/multi_printer"
+require "ruby-prof/dot_printer"
+require "ruby-prof/symbol_to_proc" # for 1.8's backward compatibility benefit
+require "ruby-prof/rack"
+
+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
+      # the default...
+      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,68 @@
+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_minimal(:total_time)
+    end
+
+    def self_time
+      aggregate(:self_time)
+    end
+
+    def wait_time
+      aggregate(:wait_time)
+    end
+
+    def children_time
+      aggregate_minimal(: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)
+      end
+    end
+
+    def aggregate_minimal(method_name)
+      self.call_infos.inject(0) do |sum, call_info|
+        sum += call_info.send(method_name) if call_info.minimal?
+        sum
+      end
+    end
+  end
+end

data/lib/ruby-prof/call_info.rb

@@ -0,0 +1,112 @@
+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
+
+    def minimal?
+      @minimal
+    end
+
+    def compute_minimality(parent_methods)
+      if parent_methods.include?(target)
+        @minimal = false
+      else
+        @minimal = true
+        parent_methods << target unless children.empty?
+      end
+      children.each {|ci| ci.compute_minimality(parent_methods)}
+      parent_methods.delete(target) if @minimal && !children.empty?
+    end
+
+    # eliminate call info from the call tree.
+    # adds self and wait time to parent and attaches called methods to parent.
+    # merges call trees for methods called from both praent end self.
+    def eliminate!
+      # puts "eliminating #{self}"
+      return unless parent
+      parent.add_self_time(self)
+      parent.add_wait_time(self)
+      children.each do |kid|
+        if call = parent.find_call(kid)
+          call.merge_call_tree(kid)
+        else
+          parent.children << kid
+          # $stderr.puts "setting parent of #{kid}\nto #{parent}"
+          kid.parent = parent
+        end
+      end
+      parent.children.delete(self)
+    end
+
+    # find a sepcific call in list of children. returns nil if not found.
+    # note: there can't be more than one child with a given target method. in other words:
+    # x.children.grep{|y|y.target==m}.size <= 1 for all method infos m and call infos x
+    def find_call(other)
+      matching = children.select { |kid| kid.target == other.target }
+      raise "inconsistent call tree" unless matching.size <= 1
+      matching.first
+    end
+
+    # merge two call trees. adds self, wait, and total time of other to self and merges children of other into children of self.
+    def merge_call_tree(other)
+      # $stderr.puts "merging #{self}\nand #{other}"
+      self.called += other.called
+      add_self_time(other)
+      add_wait_time(other)
+      add_total_time(other)
+      other.children.each do |other_kid|
+        if kid = find_call(other_kid)
+          # $stderr.puts "merging kids"
+          kid.merge_call_tree(other_kid)
+        else
+          other_kid.parent = self
+          children << other_kid
+        end
+      end
+      other.children.clear
+      other.target.call_infos.delete(other)
+    end
+
+  end
+end