ruby-prof 0.8.1-x86-mingw32 → 0.11.0.rc1-x86-mingw32

data/ext/ruby_prof/ruby_prof.h

@@ -1,188 +1,54 @@
-/*
- * 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  =================*/
-#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;
-
-/* 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
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_PROF_H__
+#define __RUBY_PROF_H__
+
+#include <stdio.h>
+#include <ruby.h>
+
+#if RUBY_VERSION == 186
+# error 1.8.6 is not supported.  Please upgrade to 1.8.7 or 1.9.2 or higher.
+#endif
+
+#if RUBY_VERSION == 190
+# error 1.9.0 is not supported.  Please upgrade to 1.9.2 or higher.
+#endif
+
+#if RUBY_VERSION == 191
+# error 1.9.1 is not supported.  Please upgrade to 1.9.2 or higher.
+#endif
+
+#ifndef RUBY_VM
+#include <node.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"
+
+#include "rp_measure.h"
+#include "rp_method.h"
+#include "rp_call_info.h"
+#include "rp_stack.h"
+#include "rp_thread.h"
+
+extern VALUE mProf;
+extern VALUE cProfile;
+
+void method_key(prof_method_key_t* key, VALUE klass, ID mid);
+
+typedef struct
+{
+    VALUE running;
+    prof_measurer_t* measurer;
+    double measurement;
+    VALUE threads;
+    st_table* threads_tbl;
+    st_table* exclude_threads_tbl;
+    thread_data_t* last_thread_data;
+} prof_profile_t;
+
+
+#endif //__RUBY_PROF_H__

data/ext/ruby_prof/version.h

@@ -1,4 +1,7 @@
-#define RUBY_PROF_VERSION  "0.8.1"
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#define RUBY_PROF_VERSION  "0.11.0" // for easy parsing from rake files
 #define RUBY_PROF_VERSION_MAJ   0
-#define RUBY_PROF_VERSION_MIN   8
-#define RUBY_PROF_VERSION_MIC   1
+#define RUBY_PROF_VERSION_MIN   11
+#define RUBY_PROF_VERSION_MIC   0

data/lib/ruby-prof.rb

@@ -1,25 +1,38 @@
-# require the  .so file
-me = File.dirname(__FILE__) + '/'
+# encoding: utf-8
+
+# Load the C-based binding.
 begin
-  # fat binaries
-  require "#{me}/#{RUBY_VERSION[0..2]}/ruby_prof"
-rescue Exception
-  require "#{me}/../ext/ruby_prof/ruby_prof"
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "#{$1}/ruby_prof"
+rescue LoadError
+  require "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"
 
 module RubyProf
-  # See if the user specified the clock mode via 
+  def self.camelcase(phrase)
+    ('_' + phrase).gsub(/_([a-z])/){|b| b[1..1].upcase}
+  end
+  
+  lib_dir = File.dirname(__FILE__) + '/ruby-prof/'
+  
+  for file in ['abstract_printer', 'aggregate_call_info', 'flat_printer', 'flat_printer_with_line_numbers', 
+    'graph_printer', 'graph_html_printer', 'call_tree_printer', 'call_stack_printer', 'multi_printer', 'dot_printer']
+    autoload camelcase(file), lib_dir + file
+  end
+
+  # A few need to be loaded manually their classes were already defined by the .so file so autoload won't work for them.
+  # plus we need them anyway
+  for name in ['profile', 'method_info', 'call_info']
+    require lib_dir + name
+  end
+  
+  # Compatability layer for suporting old api
+  require lib_dir + 'compatibility' 
+  
+  # we don't require unprof.rb, as well, purposefully
+  
+  # Checks 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"]
@@ -48,9 +61,10 @@ module RubyProf
     when "memory"
       RubyProf.measure_mode = RubyProf::MEMORY
     else
+      # the default...
       RubyProf.measure_mode = RubyProf::PROCESS_TIME
     end
   end
 end
 
-RubyProf::figure_measure_mode
+RubyProf::figure_measure_mode

data/lib/ruby-prof/abstract_printer.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RubyProf
   class AbstractPrinter
     def initialize(result)
@@ -7,7 +9,7 @@ module RubyProf
     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
@@ -18,18 +20,26 @@ module RubyProf
     #   :print_file  - True or false. Specifies if a method's source
     #                  file should be printed.  Default value if false.
     #
+    #   :sort_method - Specifies method used for sorting method infos.
+    #                  Available values are :total_time, :self_time,
+    #                  :wait_time, :children_time
+    #                  Default value is :total_time
     def setup_options(options = {})
       @options = options
-    end      
+    end
 
     def min_percent
       @options[:min_percent] || 0
     end
-    
+
     def print_file
       @options[:print_file] || false
     end
-    
+
+    def sort_method
+      @options[:sort_method] || :total_time
+    end
+
     def method_name(method)
       name = method.full_name
       if print_file
@@ -38,4 +48,4 @@ module RubyProf
       name
     end
   end
-end 
+end

data/lib/ruby-prof/aggregate_call_info.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RubyProf
   class AggregateCallInfo
     attr_reader :call_infos
@@ -27,7 +29,7 @@ module RubyProf
     end
 
     def total_time
-      aggregate(:total_time)
+      aggregate_minimal(:total_time)
     end
 
     def self_time
@@ -39,7 +41,7 @@ module RubyProf
     end
 
     def children_time
-      aggregate(:children_time)
+      aggregate_minimal(:children_time)
     end
 
     def called
@@ -55,8 +57,14 @@ module RubyProf
     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
+end

data/lib/ruby-prof/call_info.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RubyProf
   class CallInfo
     def depth
@@ -43,5 +45,70 @@ module RubyProf
     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
+end