ruby-prof 0.10.8 → 0.11.0.rc1

data/ext/ruby_prof/ruby_prof.h

@@ -1,190 +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.
-*/
-
-#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
+/* 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.10.8" // for easy parsing from rake files
+/* 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   10
-#define RUBY_PROF_VERSION_MIC   
+#define RUBY_PROF_VERSION_MIN   11
+#define RUBY_PROF_VERSION_MIC   0

data/lib/ruby-prof.rb

@@ -1,12 +1,15 @@
-# require the .so file...
-require  File.dirname(__FILE__) + "/../ext/ruby_prof/ruby_prof_ext"
+# encoding: utf-8
+
+# Load the C-based binding.
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "#{$1}/ruby_prof"
+rescue LoadError
+  require "ruby_prof"
+end
+
 
 module RubyProf
-  
-  if RUBY_VERSION < '1.8.7'
-    require File.dirname(__FILE__) + '/ruby-prof/symbol_to_proc'
-  end
-  
   def self.camelcase(phrase)
     ('_' + phrase).gsub(/_([a-z])/){|b| b[1..1].upcase}
   end
@@ -20,15 +23,15 @@ module RubyProf
 
   # 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 ['result', 'method_info', 'call_info']
+  for name in ['profile', 'method_info', 'call_info']
     require lib_dir + name
   end
   
-  require File.dirname(__FILE__) + '/ruby-prof/rack' # do we even need to load this every time?
+  # 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
@@ -64,4 +67,4 @@ module RubyProf
   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)
@@ -18,6 +20,10 @@ 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
@@ -30,6 +36,10 @@ module RubyProf
       @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

data/lib/ruby-prof/aggregate_call_info.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RubyProf
   class AggregateCallInfo
     attr_reader :call_infos

data/lib/ruby-prof/call_info.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module RubyProf
   class CallInfo
     def depth

data/lib/ruby-prof/call_stack_printer.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'erb'
 require 'fileutils'
 
@@ -6,10 +8,6 @@ module RubyProf
   class CallStackPrinter < AbstractPrinter
     include ERB::Util
 
-    def initialize(result)
-      super(result)
-    end
-
     # Specify print options.
     #
     # options - Hash table

data/lib/ruby-prof/call_tree_printer.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 
 module RubyProf
   # Generate profiling information in calltree format

data/lib/ruby-prof/compatibility.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+# These methods are here for backwards compatability with previous RubyProf releases
+module RubyProf
+  # Measurements
+  def self.cpu_frequency
+    Measure::CpuTime.frequency
+  end
+
+  def self.cpu_frequency=(value)
+    Measure::CpuTime.frequency = value
+  end
+
+  def self.measure_allocations
+    Measure::Allocations.measure
+  end
+
+  def self.measure_cpu_time
+    Measure::CpuTime.measure
+  end
+  
+  def self.measure_gc_runs
+    Measure::GcRuns.measure
+  end
+
+  def self.measure_gc_time
+    Measure::GcTime.measure
+  end
+
+  def self.measure_memory
+    Measure::Memory.measure
+  end
+
+  def self.measure_process_time
+    Measure::ProcessTime.measure
+  end
+
+  def self.measure_wall_time
+    Measure::WallTime.measure
+  end
+  
+  # call-seq:
+  # measure_mode -> measure_mode
+  #
+  # Returns what ruby-prof is measuring.  Valid values include:
+  #
+  # *RubyProf::PROCESS_TIME - Measure process time.  This is default.  It is implemented using the clock functions in the C Runtime library.
+  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows
+  # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
+  # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
+  # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+  
+  def self.measure_mode
+    @measure_mode ||= RubyProf::WALL_TIME
+  end
+  
+  # call-seq:
+  # measure_mode=value -> void
+  #
+  # Specifies what ruby-prof should measure.  Valid values include:
+  #
+  # *RubyProf::PROCESS_TIME - Measure process time.  This is default.  It is implemented using the clock functions in the C Runtime library.
+  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows
+  # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
+  # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
+  # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+  def self.measure_mode=(value)
+    @measure_mode = value
+  end
+  
+  # call-seq:
+  # exclude_threads= -> void
+  #
+  # Specifies what threads ruby-prof should exclude from profiling
+  
+  def self.exclude_threads
+    @exclude_threads ||= Array.new
+  end
+  
+  def self.exclude_threads=(value)
+    @exclude_threads = value
+  end
+  
+  # Profiling
+  def self.start
+    if running?
+      raise(RuntimeError, "RubyProf is already running");
+    end
+    @profile = Profile.new(self.measure_mode, self.exclude_threads)
+    @profile.start
+  end
+
+  def self.pause
+    unless running?
+      raise(RuntimeError, "RubyProf.start was not yet called");
+    end
+    @profile.pause
+  end
+
+  def self.running?
+    if defined?(@profile) and @profile
+      @profile.running?
+    else
+      false
+    end
+  end
+
+  def self.resume
+    unless running?
+      raise(RuntimeError, "RubyProf.start was not yet called");
+    end
+    @profile.resume
+  end
+
+  def self.stop
+    unless running?
+      raise(RuntimeError, "RubyProf.start was not yet called");
+    end
+    result = @profile.stop
+    @profile = nil
+    result
+  end
+
+  def self.profile(&block)
+    if running?
+      raise(RuntimeError, "RubyProf is already running");
+    end
+    Profile.profile(self.measure_mode, self.exclude_threads, &block)
+  end
+end