ruby-prof 0.5.2 → 0.6.0

data/CHANGES

@@ -1,3 +1,44 @@
+0.6.0 (2007-02-03)
+========================
+
+ruby-prof 0.6.0 adds support for Ruby 1.9 and memory profiling.
+
+Features
+--------
+* Added support for ruby 1.9 (Shugo Maeda)
+* Added support for outputting printer results to a String, Array or IO
+  object (Michael Granger)
+* Add new memory profiling mode.  Note this mode depends on a
+  patched Ruby interpreter (Alexander Dymo)
+
+Fixes
+-------
+* Improvements to GraphHtmlPrinter including updated documentation,
+  fixes for min_time support, ability to specify templates using
+  strings or filenames, and table layout fixes (Makoto Kuwata)
+* Fixes to scaling factor for calltrees so that precision is not lost
+  due to the conversion to doubles (Sylvain Joyeux) 
+* Changed constant ALLOCATED_OBJECTS to ALLOCATIONS in the C code to
+  match the Ruby code (Sylvain Joyeux)
+* Added support for calltree printer to ruby-prof binary script (Sylvain Joyeux)
+* Fix support for the allocator measure mode to extconf.rb (Sylvain Joyeux)
+* Honor measure mode when specified on the command line (Sylvain Joyeux)
+* Sorting of methods by total time was incorrect (Dan Fitch, Charlie Savage)
+* Fix ruby-prof to work with the latest version of GEMS (Alexander Dymo)
+* Always define MEASURE_CPU_TIME and MEASURE_ALLOCATIONS in Ruby code, but
+  set their values to nil if the functionality is not available.
+   
+
+0.5.2 (2007-07-19)
+========================
+
+ruby-prof 0.5.2 is a bug fix release.
+
+Fixes
+-------
+* Include missing rails plugin
+
+
 0.5.1 (2007-07-18)
 ========================
 

data/README

@@ -5,13 +5,14 @@
 ruby-prof is a fast code profiler for Ruby.  Its features include:
 
 * Speed - it is a C extension and therefore many times faster than the standard Ruby profiler.
-* Flat Profiles - similar to the reports generated by the standard Ruby profiler
-* Graph profiles - similar to GProf, these show how long a method runs, which methods call it and which methods it calls.
-* Call tree profiles - outputs results in the calltree format suitable for the KCacheGrind profiling tool.
+* Modes - Ruby prof can measure a number of different parameters, including
+          call times, memory usage and object allocations. 
+* Reports - can generate text and cross-referenced html reports
+  - Flat Profiles - similar to the reports generated by the standard Ruby profiler
+  - Graph profiles - similar to GProf, these show how long a method runs, which methods call it and which methods it calls.
+  - Call tree profiles - outputs results in the calltree format suitable for the KCacheGrind profiling tool.
 * Threads - supports profiling multiple threads simultaneously
 * Recursive calls - supports profiling recursive method calls
-* Reports - can generate both text and cross-referenced html reports
-* Output - can output to standard out or to a file
 
 
 == Requirements
@@ -27,13 +28,15 @@ includes an already built extension.
 
 == Install
 
-ruby-prof is provided as a RubyGem.  To install:
+The easiest way to install ruby-prof is by using Ruby Gems.  To install:
 
 <tt>gem install ruby-prof</tt>
 
 If you are running Windows, make sure to install the Win32 RubyGem which 
 includes a pre-built binary.
 
+ruby-prof is also available as a tarred gzip archive and zip archive. 
+
 == Usage
 
 There are three ways of running ruby-prof.
@@ -59,7 +62,7 @@ particular segments of code.
   result = RubyProf.stop
   
   # Print a flat profile to text
-  printer = RubyProf::TextPrinter.new(result)
+  printer = RubyProf::FlatPrinter.new(result)
   printer.print(STDOUT, 0)
   
 Alternatively, you can use a block to tell ruby-prof what
@@ -161,6 +164,7 @@ aspects of a Ruby program.  Supported measurements include:
 * wall time
 * cpu time
 * object allocations
+* memory usage
 
 Process time measures the time used by a process between any two moments.
 It is unaffected by other processes concurrently running 
@@ -176,18 +180,24 @@ CPU time uses the CPU clock counter to measure time.  The returned
 values are dependent on the correctly setting the CPU's frequency.
 This mode is only supported on Pentium or PowerPC platforms.
 
-Object allocations report which methods allocate objects in a running
-program.  This support was generously donated by Sylvain Joyeux. 
-This mode requires a patched Ruby interpreter.  For more
-information, see:
+Object allocation reports show how many objects each method in
+a program allocates.  This support was added by Sylvain Joyeux
+and requires a patched Ruby interpreter.  For more information, see:
 http://rubyforge.org/tracker/index.php?func=detail&aid=11497&group_id=426&atid=1700
 
+Memory usage reports show how much memory each method in a program
+uses.  This support was added by Alexander Dymo and requires a
+patched Ruby interpreter.  For more information, see:
+http://rubyforge.org/tracker/index.php?func=detail&aid=17676&group_id=1814&atid=7062.
+
+
 To set the measurement:
 
 * RubyProf.measure_mode = RubyProf::PROCESS_TIME
 * RubyProf.measure_mode = RubyProf::WALL_TIME
 * RubyProf.measure_mode = RubyProf::CPU_TIME
 * RubyProf.measure_mode = RubyProf::ALLOCATIONS
+* RubyProf.measure_mode = RubyProf::MEMORY
 
 The default value is RubyProf::PROCESS_TIME.
 

data/Rakefile

@@ -1,11 +1,13 @@
 require 'rubygems'
+require 'date'
 require 'rake/gempackagetask'
 require 'rake/rdoctask'
+require 'date'
 
 SO_NAME = "ruby_prof.so"
 
 # ------- Default Package ----------
-RUBY_PROF_VERSION = "0.5.2"
+RUBY_PROF_VERSION = "0.6.0"
 
 FILES = FileList[
   'Rakefile',
@@ -45,7 +47,6 @@ EOF
   spec.bindir = "bin"
   spec.executables = ["ruby-prof"]
   spec.extensions = ["ext/extconf.rb"]
-  spec.autorequire = "ruby-prof"
   spec.files = FILES.to_a
   spec.test_files = Dir["test/test_*.rb"]
   
@@ -71,7 +72,6 @@ EOF
 
 end
 
-
 # Rake task to build the default package
 Rake::GemPackageTask.new(default_spec) do |pkg|
   pkg.need_tar = true
@@ -80,14 +80,12 @@ end
 
 
 # ------- Windows Package ----------
-
 # Windows specification
 win_spec = default_spec.clone
 win_spec.extensions = []
-win_spec.platform = Gem::Platform::WIN32
+win_spec.platform = Gem::Platform::CURRENT
 win_spec.files += ["lib/#{SO_NAME}"]
 
-
 desc "Create Windows Gem"
 task :create_win32_gem do
   # Copy the win32 extension built by MingW - easier to install

data/bin/ruby-prof

@@ -26,6 +26,7 @@
 #                                        allocations - Tracks object allocations
 #                                              (requires a patched Ruby interpreter).
 #         --replace-progname           Replace $0 when loading the .rb files.
+#         --specialized-instruction    Turn on specialized instruction.
 #     -h, --help                       Show help message
 #         --version                    Show version
 # 
@@ -43,6 +44,7 @@ options.printer = RubyProf::FlatPrinter
 options.min_percent = 0
 options.file = nil
 options.replace_prog_name = false
+options.specialized_instruction = false
 
 opts = OptionParser.new do |opts|
   opts.banner = "ruby_prof #{RubyProf::VERSION}\n" +
@@ -67,6 +69,8 @@ opts = OptionParser.new do |opts|
         options.printer = RubyProf::GraphPrinter
       when :graph_html
         options.printer = RubyProf::GraphHtmlPrinter
+      when :call_tree
+        options.printer = RubyProf::CallTreePrinter
     end
   end
     
@@ -90,7 +94,7 @@ opts = OptionParser.new do |opts|
       '  cpu - CPU time (Pentium and PowerPCs only).',
       '  allocations - Object allocations (requires patched Ruby interpreter).') do |measure_mode|
       
-      case mode
+      case measure_mode
       when :process
         options.measure_mode = RubyProf::PROCESS_TIME     
       when :wall
@@ -105,6 +109,12 @@ opts = OptionParser.new do |opts|
   opts.on("--replace-progname", "Replace $0 when loading the .rb files.") do
           options.replace_prog_name = true
   end
+
+  if defined?(VM)
+    opts.on("--specialized-instruction", "Turn on specified instruction.") do
+            options.specialized_instruction = true
+    end
+  end
     
   opts.on_tail("-h", "--help", "Show help message") do
       puts opts
@@ -161,6 +171,14 @@ at_exit {
 # Now set measure mode
 RubyProf.measure_mode = options.measure_mode
 
+# Set VM compile option
+if defined?(VM)
+  VM::InstructionSequence.compile_option = {
+    :trace_instruction => true,
+    :specialized_instruction => options.specialized_instruction
+  }
+end
+
 # Get the script we will execute
 script = ARGV.shift
 if options.replace_prog_name

data/ext/extconf.rb

@@ -16,4 +16,6 @@ else
 end
 
 have_header("sys/times.h")
+have_func("rb_os_allocated_objects")
+have_func("rb_gc_allocated_size")
 create_makefile("ruby_prof")

data/ext/extconf.rb.rej

@@ -0,0 +1,13 @@
+***************
+*** 16,20 ****
+  end
+  
+  have_header("sys/times.h")
+- create_makefile("ruby_prof")
+- have_func("rb_os_allocated_objects")--- 16,21 ----
+  end
+  
+  have_header("sys/times.h")
++ have_func("rb_os_allocated_objects")
++ have_func("rb_gc_allocated_size")
++ create_makefile("ruby_prof")

data/ext/measure_memory.h

@@ -0,0 +1,42 @@
+/* :nodoc: 
+ * Copyright (C) 2008  Alexander Dymo <adymo@pluron.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. */
+
+
+#if defined(HAVE_RB_GC_ALLOCATED_SIZE)
+#define MEASURE_MEMORY 4
+ 
+static prof_measure_t
+measure_memory()
+{
+    return rb_gc_allocated_size();
+}
+
+static double
+convert_memory(prof_measure_t c)
+{ 
+    return  c / 1024; 
+}
+
+#endif

data/ext/ruby_prof.c

@@ -51,13 +51,18 @@
 #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
 
 
 /* ================  Constants  =================*/
 #define INITIAL_STACK_SIZE 8
-#define PROF_VERSION "0.5.2"
+#define PROF_VERSION "0.6.0"
 
 
 /* ================  Measurement  =================*/
@@ -71,6 +76,7 @@ typedef unsigned long prof_measure_t;
 #include "measure_wall_time.h"
 #include "measure_cpu_time.h"
 #include "measure_allocations.h"
+#include "measure_memory.h"
 
 static prof_measure_t (*get_measurement)() = measure_process_time;
 static double (*convert_measurement)(prof_measure_t) = convert_process_time;
@@ -195,7 +201,11 @@ figure_singleton_name(VALUE klass)
         /* Make sure to get the super class so that we don't
            mistakenly grab a T_ICLASS which would lead to
            unknown method errors. */
+#ifdef RCLASS_SUPER
+        VALUE super = rb_class_real(RCLASS_SUPER(klass));
+#else
         VALUE super = rb_class_real(RCLASS(klass)->super);
+#endif
         result = rb_str_new2("<Object::");
         rb_str_append(result, rb_inspect(super));
         rb_str_cat2(result, ">");
@@ -856,16 +866,14 @@ prof_method_cmp(VALUE self, VALUE other)
     prof_method_t *x = get_prof_method(self);
     prof_method_t *y = get_prof_method(other);
 
-    if (x->called == 0)
+    if (x->called == 0 && y->called == 0)
+      return INT2FIX(0);
+    else if (x->called == 0)
       return INT2FIX(1);
     else if (y->called == 0)
       return INT2FIX(-1);
-    else if (x->total_time < y->total_time)
-      return INT2FIX(-1);
-    else if (x->total_time == y->total_time)
-      return INT2FIX(0);
     else
-      return INT2FIX(1);
+      return rb_dbl_cmp(x->total_time, y->total_time);
 }
 
 static int
@@ -982,27 +990,27 @@ collect_threads(st_data_t key, st_data_t value, st_data_t result)
 /* ================  Profiling    =================*/
 /* Copied from eval.c */
 static char *
-get_event_name(rb_event_t event)
+get_event_name(rb_event_flag_t event)
 {
   switch (event) {
     case RUBY_EVENT_LINE:
-	return "line";
+  return "line";
     case RUBY_EVENT_CLASS:
-	return "class";
+  return "class";
     case RUBY_EVENT_END:
-	return "end";
+  return "end";
     case RUBY_EVENT_CALL:
-	return "call";
+  return "call";
     case RUBY_EVENT_RETURN:
-	return "return";
+  return "return";
     case RUBY_EVENT_C_CALL:
-	return "c-call";
+  return "c-call";
     case RUBY_EVENT_C_RETURN:
-	return "c-return";
+  return "c-return";
     case RUBY_EVENT_RAISE:
-	return "raise";
+  return "raise";
     default:
-	return "unknown";
+  return "unknown";
     }
 }
 
@@ -1070,8 +1078,13 @@ update_result(thread_data_t* thread_data,
 }
 
 
+#ifdef RUBY_VM
 static void
-prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
+prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
+#else
+static void
+prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass)
+#endif
 {
     
     VALUE thread;
@@ -1079,8 +1092,17 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     thread_data_t* thread_data = NULL;
     long thread_id = 0;
     prof_frame_t *frame = NULL;
-    
-    /*
+#ifdef RUBY_VM
+
+    if (event != RUBY_EVENT_C_CALL &&
+  event != RUBY_EVENT_C_RETURN) {
+  VALUE thread = rb_thread_current();
+  rb_frame_method_id_and_class(&mid, &klass);
+    }
+#endif
+    /*  This code is here for debug purposes - uncomment it out
+        when debugging to see a print out of exactly what the
+        profiler is tracing. 
     {
         st_data_t key = 0;
         static unsigned long last_thread_id = 0;
@@ -1157,8 +1179,12 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
          called from. */
       if (frame)
       {
+#ifdef RUBY_VM
+    frame->line = rb_sourceline();
+#else
         if (node)
           frame->line = nd_line(node);
+#endif
         break;
       }
       /* If we get here there was no frame, which means this is 
@@ -1185,8 +1211,8 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         
         if (!method)
         {
-          const char* source_file = (node ? node->nd_file : 0);
-          int line = (node ? nd_line(node) : 0);
+          const char* source_file = rb_sourcefile();
+          int line = rb_sourceline();
           
           /* Line numbers are not accurate for c method calls */
             if (event == RUBY_EVENT_C_CALL)
@@ -1210,8 +1236,8 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
           
           if (!method)
           {
-            const char* source_file = (node ? node->nd_file : 0);
-            int line = (node ? nd_line(node) : 0);
+            const char* source_file = rb_sourcefile();
+            int line = rb_sourceline();
             
             /* Line numbers are not accurate for c method calls */
             if (event == RUBY_EVENT_C_CALL)
@@ -1232,7 +1258,7 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         frame->start_time = now;
         frame->wait_time = 0;
         frame->child_time = 0;
-        frame->line = node ? nd_line(node) : 0;
+        frame->line = rb_sourceline();
 
         break;
     }
@@ -1347,7 +1373,8 @@ prof_result_threads(VALUE self)
    *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::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
+   *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.*/
 static VALUE
 prof_get_measure_mode(VALUE self)
 {
@@ -1362,7 +1389,8 @@ prof_get_measure_mode(VALUE self)
    *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::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
+   *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.*/
 static VALUE
 prof_set_measure_mode(VALUE self, VALUE val)
 {
@@ -1400,6 +1428,13 @@ prof_set_measure_mode(VALUE self, VALUE val)
         break;
       #endif
         
+      #if defined(MEASURE_MEMORY)
+      case MEASURE_MEMORY:
+        get_measurement = measure_memory;
+        convert_measurement = convert_memory;
+        break;
+      #endif
+        
       default:
         rb_raise(rb_eArgError, "invalid mode: %d", mode);
         break;
@@ -1441,10 +1476,21 @@ prof_start(VALUE self)
     last_thread_data = NULL;
     threads_tbl = threads_table_create();
     
+#ifdef RUBY_VM
+    rb_add_event_hook(prof_event_hook,
+          RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
+          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN 
+          | RUBY_EVENT_LINE, Qnil);
+#else
     rb_add_event_hook(prof_event_hook,
           RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
           RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN 
           | RUBY_EVENT_LINE);
+#endif
+
+#if defined(MEASURE_MEMORY)
+    rb_gc_enable_stats();
+#endif
 
     return Qnil;
 }
@@ -1457,6 +1503,10 @@ prof_start(VALUE self)
 static VALUE
 prof_stop(VALUE self)
 {
+#if defined(MEASURE_MEMORY)
+    rb_gc_disable_stats();
+#endif
+
     VALUE result = Qnil;
 
     if (threads_tbl == NULL)
@@ -1515,17 +1565,28 @@ Init_ruby_prof()
     rb_define_singleton_method(mProf, "measure_mode", prof_get_measure_mode, 0);
     rb_define_singleton_method(mProf, "measure_mode=", prof_set_measure_mode, 1);
 
+    rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
     rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
     rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
 
-    #if defined(MEASURE_CPU_TIME)
+    #ifndef MEASURE_CPU_TIME
+    rb_define_const(mProf, "CPU_TIME", Qnil);
+    #else
     rb_define_const(mProf, "CPU_TIME", INT2NUM(MEASURE_CPU_TIME));
     rb_define_singleton_method(mProf, "cpu_frequency", prof_get_cpu_frequency, 0); /* in measure_cpu_time.h */
     rb_define_singleton_method(mProf, "cpu_frequency=", prof_set_cpu_frequency, 1); /* in measure_cpu_time.h */
     #endif
         
-    #if defined(MEASURE_ALLOCATIONS)
-    rb_define_const(mProf, "ALLOCATED_OBJECTS", INT2NUM(MEASURE_ALLOCATIONS));
+    #ifndef MEASURE_ALLOCATIONS
+    rb_define_const(mProf, "ALLOCATIONS", Qnil);
+    #else
+    rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
+    #endif
+    
+    #ifndef MEASURE_MEMORY
+    rb_define_const(mProf, "MEMORY", Qnil);
+    #else
+    rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
     #endif
     
     cResult = rb_define_class_under(mProf, "Result", rb_cObject);