ruby-prof 0.8.2 → 0.9.0

data/ext/ruby_prof/extconf.rb

@@ -39,6 +39,5 @@ def add_define(name, value = nil)
   end
 end
 
-add_define 'DEBUG' if $DEBUG
 add_define("RUBY_VERSION", RUBY_VERSION.gsub('.', ''))
 create_makefile("ruby_prof")

data/ext/ruby_prof/measure_allocations.h

@@ -1,4 +1,4 @@
-/* :nodoc: 
+/* :nodoc:
  * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.
@@ -28,17 +28,17 @@
 
 #if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
 #define MEASURE_ALLOCATIONS 3
- 
+
 static prof_measure_t
 measure_allocations()
-{ 
-    return rb_os_allocated_objects(); 
+{
+    return rb_os_allocated_objects();
 }
 
 static double
 convert_allocations(prof_measure_t c)
-{ 
-    return  c; 
+{
+    return  c;
 }
 
 /* Document-method: prof_measure_allocations

data/ext/ruby_prof/measure_cpu_time.h

@@ -1,4 +1,4 @@
-/* :nodoc: 
+/* :nodoc:
  * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.
@@ -38,7 +38,7 @@ static unsigned LONG_LONG cpu_frequency;
 static prof_measure_t
 measure_cpu_time()
 {
-#if defined(__i386__) || defined(__x86_64__) 
+#if defined(__i386__) || defined(__x86_64__)
     uint32_t a, d;
     __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));
     return ((uint64_t)d << 32) + a;
@@ -46,7 +46,7 @@ measure_cpu_time()
     unsigned long long x, y;
 
     __asm__ __volatile__ ("\n\
-1:	mftbu   %1\n\
+1:      mftbu   %1\n\
   mftb    %L0\n\
   mftbu   %0\n\
   cmpw    %0,%1\n\
@@ -128,7 +128,7 @@ prof_measure_cpu_time(VALUE self)
    call-seq:
      cpu_frequency -> int
 
-Returns the cpu's frequency.  This value is needed when 
+Returns the cpu's frequency.  This value is needed when
 RubyProf::measure_mode is set to CPU_TIME. */
 static VALUE
 prof_get_cpu_frequency(VALUE self)
@@ -140,7 +140,7 @@ prof_get_cpu_frequency(VALUE self)
    call-seq:
      cpu_frequency=value -> void
 
-Sets the cpu's frequency.   This value is needed when 
+Sets the cpu's frequency.   This value is needed when
 RubyProf::measure_mode is set to CPU_TIME. */
 static VALUE
 prof_set_cpu_frequency(VALUE self, VALUE val)

data/ext/ruby_prof/measure_gc_runs.h

@@ -1,4 +1,4 @@
-/* :nodoc: 
+/* :nodoc:
  * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.

data/ext/ruby_prof/measure_gc_time.h

@@ -1,4 +1,4 @@
-/* :nodoc: 
+/* :nodoc:
  * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.

data/ext/ruby_prof/measure_memory.h

@@ -1,4 +1,4 @@
-/* :nodoc: 
+/* :nodoc:
  * Copyright (C) 2008  Alexander Dymo <adymo@pluron.com>
  *
  * All rights reserved.
@@ -28,7 +28,7 @@
 #if defined(HAVE_RB_GC_ALLOCATED_SIZE)
 #define MEASURE_MEMORY 4
 #define TOGGLE_GC_STATS 1
- 
+
 static prof_measure_t
 measure_memory()
 {
@@ -41,8 +41,8 @@ measure_memory()
 
 static double
 convert_memory(prof_measure_t c)
-{ 
-    return (double) c / 1024; 
+{
+    return (double) c / 1024;
 }
 
 /* Document-method: prof_measure_memory

data/ext/ruby_prof/measure_process_time.h

@@ -31,7 +31,7 @@
 static prof_measure_t
 measure_process_time()
 {
-    return clock();
+    return clock(); // cpu usage (with poor precision) in linux (TODO), wall time in doze (TODO)
 }
 
 static double

data/ext/ruby_prof/measure_wall_time.h

@@ -1,4 +1,4 @@
-/* :nodoc: 
+/* :nodoc:
  * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.

data/ext/ruby_prof/ruby_prof.c

@@ -29,22 +29,22 @@
    The main players are:
 
      prof_result_t     - Its one field, values,  contains the overall results
-     thread_data_t     - Stores data about a single thread.  
+     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. 
+     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.      
+  caller or callee method, thereby making it easy to navigate through the call
+  hierarchy in ruby - which is very helpful for creating call graphs.
 */
 
 #include "ruby_prof.h"
@@ -92,7 +92,7 @@ figure_singleton_name(VALUE klass)
         rb_str_append(result, rb_inspect(super));
         rb_str_cat2(result, ">");
     }
-    
+
     /* Ok, this could be other things like an array made put onto
        a singleton object (yeah, it happens, see the singleton
        objects test case). */
@@ -108,7 +108,7 @@ static VALUE
 klass_name(VALUE klass)
 {
     VALUE result = Qnil;
-    
+
     if (klass == 0 || klass == Qnil)
     {
         result = rb_str_new2("Global");
@@ -135,34 +135,27 @@ klass_name(VALUE klass)
 }
 
 static VALUE
-method_name(ID mid, int depth)
+method_name(ID mid)
 {
     VALUE result;
 
-    if (mid == ID_ALLOCATOR) 
+    if (mid == ID_ALLOCATOR)
         result = rb_str_new2("allocate");
     else if (mid == 0)
         result = rb_str_new2("[No method]");
     else
         result = rb_String(ID2SYM(mid));
-    
-    if (depth > 0)
-    {
-      char buffer[65];
-      sprintf(buffer, "(d%i)", depth);
-      rb_str_cat2(result, buffer);
-    }
 
     return result;
 }
 
 static VALUE
-full_name(VALUE klass, ID mid, int depth)
+full_name(VALUE klass, ID mid)
 {
   VALUE result = klass_name(klass);
   rb_str_cat2(result, "#");
-  rb_str_append(result, method_name(mid, depth));
-  
+  rb_str_append(result, method_name(mid));
+
   return result;
 }
 
@@ -221,16 +214,14 @@ stack_peek(prof_stack_t *stack)
 }
 
 /* ================  Method Key   =================*/
-static int 
-method_table_cmp(prof_method_key_t *key1, prof_method_key_t *key2) 
+static int
+method_table_cmp(prof_method_key_t *key1, prof_method_key_t *key2)
 {
-    return (key1->klass != key2->klass) || 
-           (key1->mid != key2->mid) || 
-           (key1->depth != key2->depth);
+    return (key1->klass != key2->klass) || (key1->mid != key2->mid);
 }
 
-static int 
-method_table_hash(prof_method_key_t *key) 
+static st_index_t
+method_table_hash(prof_method_key_t *key)
 {
    return key->key;
 }
@@ -241,12 +232,11 @@ static struct st_hash_type type_method_hash = {
 };
 
 static void
-method_key(prof_method_key_t* key, VALUE klass, ID mid, int depth)
+method_key(prof_method_key_t* key, VALUE klass, ID mid)
 {
     key->klass = klass;
     key->mid = mid;
-    key->depth = depth;
-    key->key = (klass << 4) + (mid << 2) + depth;
+    key->key = (klass << 4) + (mid << 2);
 }
 
 
@@ -334,7 +324,7 @@ prof_call_info_mark(prof_call_info_t *call_info)
 static void
 prof_call_info_free(prof_call_info_t *call_info)
 {
-  call_info_table_free(call_info->call_infos); 
+  call_info_table_free(call_info->call_infos);
   xfree(call_info);
 }
 
@@ -370,7 +360,7 @@ prof_call_info_target(VALUE self)
     /* Target is a pointer to a method_info - so we have to be careful
        about the GC.  We will wrap the method_info but provide no
        free method so the underlying object is not freed twice! */
-    
+
     prof_call_info_t *result = prof_get_call_info_result(self);
     return prof_method_wrap(result->target);
 }
@@ -386,6 +376,18 @@ prof_call_info_called(VALUE self)
     return INT2NUM(result->called);
 }
 
+/* call-seq:
+   called=n -> n
+
+Sets the call count to n. */
+static VALUE
+prof_call_info_set_called(VALUE self, VALUE called)
+{
+    prof_call_info_t *result = prof_get_call_info_result(self);
+    result->called = NUM2INT(called);
+    return called;
+}
+
 /* call-seq:
    line_no -> int
 
@@ -408,6 +410,20 @@ prof_call_info_total_time(VALUE self)
     return rb_float_new(convert_measurement(result->total_time));
 }
 
+/* call-seq:
+   add_total_time(call_info) -> nil
+
+adds total time time from call_info to self. */
+static VALUE
+prof_call_info_add_total_time(VALUE self, VALUE other)
+{
+    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *other_info = prof_get_call_info_result(other);
+
+    result->total_time += other_info->total_time;
+    return Qnil;
+}
+
 /* call-seq:
    self_time -> float
 
@@ -420,6 +436,20 @@ prof_call_info_self_time(VALUE self)
     return rb_float_new(convert_measurement(result->self_time));
 }
 
+/* call-seq:
+   add_self_time(call_info) -> nil
+
+adds self time from call_info to self. */
+static VALUE
+prof_call_info_add_self_time(VALUE self, VALUE other)
+{
+    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *other_info = prof_get_call_info_result(other);
+
+    result->self_time += other_info->self_time;
+    return Qnil;
+}
+
 /* call-seq:
    wait_time -> float
 
@@ -432,6 +462,21 @@ prof_call_info_wait_time(VALUE self)
     return rb_float_new(convert_measurement(result->wait_time));
 }
 
+/* call-seq:
+   add_wait_time(call_info) -> nil
+
+adds wait time from call_info to self. */
+
+static VALUE
+prof_call_info_add_wait_time(VALUE self, VALUE other)
+{
+    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *other_info = prof_get_call_info_result(other);
+
+    result->wait_time += other_info->wait_time;
+    return Qnil;
+}
+
 /* call-seq:
    parent -> call_info
 
@@ -446,6 +491,21 @@ prof_call_info_parent(VALUE self)
       return Qnil;
 }
 
+/* call-seq:
+   parent=new_parent -> new_parent
+
+Changes the parent of self to new_parent and returns it.*/
+static VALUE
+prof_call_info_set_parent(VALUE self, VALUE new_parent)
+{
+    prof_call_info_t *result = prof_get_call_info_result(self);
+    if (new_parent == Qnil)
+      result->parent = NULL;
+    else
+      result->parent = prof_get_call_info_result(new_parent);
+    return prof_call_info_parent(self);
+}
+
 static int
 prof_call_info_collect_children(st_data_t key, st_data_t value, st_data_t result)
 {
@@ -458,7 +518,7 @@ prof_call_info_collect_children(st_data_t key, st_data_t value, st_data_t result
 /* call-seq:
    children -> hash
 
-Returns an array of call info objects of methods that this method 
+Returns an array of call info objects of methods that this method
 called (ie, children).*/
 static VALUE
 prof_call_info_children(VALUE self)
@@ -539,24 +599,22 @@ prof_method_create(prof_method_key_t *key, const char* source_file, int line)
     prof_method_t *result = ALLOC(prof_method_t);
     result->object = Qnil;
     result->key = ALLOC(prof_method_key_t);
-    method_key(result->key, key->klass, key->mid, key->depth);   
+    method_key(result->key, key->klass, key->mid);
 
     result->call_infos = prof_call_infos_create();
 
-    result->active = 0;
-
-    if (source_file != NULL) 
+    if (source_file != NULL)
     {
-      int len = strlen(source_file) + 1;    
+      size_t len = strlen(source_file) + 1;
       char *buffer = ALLOC_N(char, len);
 
       MEMCPY(buffer, source_file, char, len);
       result->source_file = buffer;
     }
-    else 
-    {    
+    else
+    {
       result->source_file = source_file;
-    }      
+    }
     result->line = line;
 
     return result;
@@ -574,7 +632,7 @@ prof_method_free(prof_method_t *method)
 {
   if (method->source_file)
   {
-    xfree((char*)method->source_file);    
+    xfree((char*)method->source_file);
   }
 
   prof_call_infos_free(method->call_infos);
@@ -611,7 +669,7 @@ prof_method_line(VALUE self)
 /* call-seq:
    source_file => string
 
-return the source file of the method 
+return the source file of the method
 */
 static VALUE prof_method_source_file(VALUE self)
 {
@@ -669,10 +727,10 @@ Returns the name of this method in the format Object#method.  Singletons
 methods will be returned in the format <Object::Object>#method.*/
 
 static VALUE
-prof_method_name(VALUE self, int depth)
+prof_method_name(VALUE self)
 {
     prof_method_t *method = get_prof_method(self);
-    return method_name(method->key->mid, depth);
+    return method_name(method->key->mid);
 }
 
 /* call-seq:
@@ -684,13 +742,13 @@ static VALUE
 prof_full_name(VALUE self)
 {
     prof_method_t *method = get_prof_method(self);
-    return full_name(method->key->klass, method->key->mid, method->key->depth);
+    return full_name(method->key->klass, method->key->mid);
 }
 
 /* call-seq:
    call_infos -> Array of call_info
 
-Returns an array of call info objects that contain profiling information 
+Returns an array of call info objects that contain profiling information
 about the current method.*/
 static VALUE
 prof_method_call_infos(VALUE self)
@@ -702,7 +760,7 @@ prof_method_call_infos(VALUE self)
 static int
 collect_methods(st_data_t key, st_data_t value, st_data_t result)
 {
-    /* Called for each method stored in a thread's method table. 
+    /* Called for each method stored in a thread's method table.
        We want to store the method info information into an array.*/
     VALUE methods = (VALUE) result;
     prof_method_t *method = (prof_method_t *) value;
@@ -735,7 +793,7 @@ method_table_lookup(st_table *table, const prof_method_key_t* key)
     {
       return (prof_method_t *) val;
     }
-    else 
+    else
     {
       return NULL;
     }
@@ -829,7 +887,7 @@ threads_table_free(st_table *table)
 static int
 collect_threads(st_data_t key, st_data_t value, st_data_t result)
 {
-    /* Although threads are keyed on an id, that is actually a 
+    /* Although threads are keyed on an id, that is actually a
        pointer to the VALUE object of the thread.  So its bogus.
        However, in thread_data is the real thread id stored
        as an int. */
@@ -841,7 +899,7 @@ collect_threads(st_data_t key, st_data_t value, st_data_t result)
     /* Now collect an array of all the called methods */
     st_table* method_table = thread_data->method_table;
     st_foreach(method_table, collect_methods, methods);
- 
+
     /* Store the results in the threads hash keyed on the thread id. */
     rb_hash_aset(threads_hash, thread_data->thread_id, methods);
 
@@ -850,9 +908,16 @@ collect_threads(st_data_t key, st_data_t value, st_data_t result)
 
 
 /* ================  Profiling    =================*/
-/* Copied from eval.c */
-#ifdef DEBUG
-static char *
+
+/* support tracing ruby events from ruby-prof. useful for getting at
+   what actually happens inside the ruby interpreter (and ruby-prof).
+   set environment variable RUBY_PROF_TRACE to filename you want to
+   find the trace in.
+ */
+static FILE* trace_file = NULL;
+
+/* Copied from eval.c (1.8.x) / thread.c (1.9.2) */
+static const char *
 get_event_name(rb_event_flag_t event)
 {
   switch (event) {
@@ -872,43 +937,43 @@ get_event_name(rb_event_flag_t event)
   return "c-return";
     case RUBY_EVENT_RAISE:
   return "raise";
-  
+
 #ifdef RUBY_VM
     case RUBY_EVENT_SWITCH:
   return "thread-interrupt";
 #endif
-  
+
     default:
   return "unknown";
   }
 }
-#endif
 
-static prof_method_t* 
+
+static prof_method_t*
 #ifdef RUBY_VM
- get_method(rb_event_flag_t event, VALUE klass, ID mid, int depth, st_table* method_table)
+ get_method(rb_event_flag_t event, VALUE klass, ID mid, st_table* method_table)
 # else
- get_method(rb_event_flag_t event, NODE *node, VALUE klass, ID mid, int depth, st_table* method_table)
-#endif 
+ get_method(rb_event_flag_t event, NODE *node, VALUE klass, ID mid, st_table* method_table)
+#endif
 {
     prof_method_key_t key;
     prof_method_t *method = NULL;
-    
-    method_key(&key, klass, mid, depth);
+
+    method_key(&key, klass, mid);
     method = method_table_lookup(method_table, &key);
 
     if (!method)
     {
       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)
       {
         line = 0;
         source_file = NULL;
       }
-        
+
       method = prof_method_create(&key, source_file, line);
       method_table_insert(method_table, method->key, method);
     }
@@ -917,18 +982,18 @@ static prof_method_t*
 
 static void
 update_result(prof_measure_t total_time,
-              prof_frame_t *parent_frame, 
+              prof_frame_t *parent_frame,
               prof_frame_t *frame)
 {
     prof_measure_t self_time = total_time - frame->child_time - frame->wait_time;
     prof_call_info_t *call_info = frame->call_info;
-    
+
     /* Update information about the current method */
     call_info->called++;
     call_info->total_time += total_time;
     call_info->self_time += self_time;
     call_info->wait_time += frame->wait_time;
-    
+
     /* Note where the current method was called from */
     if (parent_frame)
       call_info->line = parent_frame->line;
@@ -937,31 +1002,31 @@ update_result(prof_measure_t total_time,
 static thread_data_t *
 switch_thread(VALUE thread_id, prof_measure_t now)
 {
-	prof_frame_t *frame = NULL;
-	prof_measure_t wait_time = 0;
+        prof_frame_t *frame = NULL;
+        prof_measure_t wait_time = 0;
     /* Get new thread information. */
     thread_data_t *thread_data = threads_table_lookup(threads_tbl, thread_id);
 
     /* How long has this thread been waiting? */
     wait_time = now - thread_data->last_switch;
-    
+
     thread_data->last_switch = now; // XXXX a test that fails if this is 0
 
     /* Get the frame at the top of the stack.  This may represent
        the current method (EVENT_LINE, EVENT_RETURN)  or the
        previous method (EVENT_CALL).*/
     frame = stack_peek(thread_data->stack);
-  
+
     if (frame) {
       frame->wait_time += wait_time;
     }
-      
+
     /* Save on the last thread the time of the context switch
        and reset this thread's last context switch to 0.*/
     if (last_thread_data) {
-      last_thread_data->last_switch = now;   
+      last_thread_data->last_switch = now;
     }
-      
+
     last_thread_data = thread_data;
     return thread_data;
 }
@@ -983,20 +1048,17 @@ pop_frame(thread_data_t *thread_data, prof_measure_t now)
   /* Calculate the total time this method took */
   total_time = now - frame->start_time;
 
-  /* Now deactivate the method */
-  frame->call_info->target->active = 0;
-
   parent_frame = stack_peek(thread_data->stack);
   if (parent_frame)
   {
-  	parent_frame->child_time += total_time;
+        parent_frame->child_time += total_time;
   }
-    
+
   update_result(total_time, parent_frame, frame); // only time it's called
   return frame;
 }
 
-static int 
+static int
 pop_frames(st_data_t key, st_data_t value, st_data_t now_arg)
 {
     VALUE thread_id = (VALUE)key;
@@ -1011,11 +1073,11 @@ pop_frames(st_data_t key, st_data_t value, st_data_t now_arg)
     while (pop_frame(thread_data, now))
     {
     }
-    
+
     return ST_CONTINUE;
 }
 
-static void 
+static void
 prof_pop_threads()
 {
     /* Get current measurement */
@@ -1061,10 +1123,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     /* Get current timestamp */
     now = get_measurement();
 
-#ifdef DEBUG
-    /*  This code is here for debug purposes - uncomment it out
-        when debugging to see a print out of exactly what the
-        profiler is tracing. */
+    if (trace_file != NULL)
     {
         static VALUE last_thread_id = Qnil;
 
@@ -1075,7 +1134,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         const char* source_file = rb_sourcefile();
         unsigned int source_line = rb_sourceline();
 
-        char* event_name = get_event_name(event);
+        const char* event_name = get_event_name(event);
 
         if (klass != 0)
           klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
@@ -1083,17 +1142,16 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         class_name = rb_class2name(klass);
 
         if (last_thread_id != thread_id) {
-          printf("\n");
+          fprintf(trace_file, "\n");
         }
-        
-        printf("%2u:%2ums %-8s %s:%2d  %s#%s\n",
+
+        fprintf(trace_file, "%2u:%2ums %-8s %s:%2d  %s#%s\n",
                (unsigned int) thread_id, (unsigned int) now, event_name, source_file, source_line, class_name, method_name);
-        fflush(stdout);
-        last_thread_id = thread_id;               
+        /* fflush(trace_file); */
+        last_thread_id = thread_id;
     }
-#endif
-    
-    /* Special case - skip any methods from the mProf 
+
+    /* Special case - skip any methods from the mProf
        module, such as Prof.stop, since they clutter
        the results but aren't important to them results. */
     if (self == mProf) return;
@@ -1101,7 +1159,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     /* Get the current thread information. */
     thread = rb_thread_current();
     thread_id = rb_obj_id(thread);
-    
+
    # if RUBY_VERSION == 191
      /* ensure that new threads are hooked [sigh] (bug in core) */
      prof_remove_hook();
@@ -1109,43 +1167,43 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
    # endif
 
     if (exclude_threads_tbl &&
-        st_lookup(exclude_threads_tbl, (st_data_t) thread_id, 0)) 
+        st_lookup(exclude_threads_tbl, (st_data_t) thread_id, 0))
     {
       return;
-    }    
-    
-    
+    }
+
+
     /* Was there a context switch? */
     if (!last_thread_data || last_thread_data->thread_id != thread_id)
       thread_data = switch_thread(thread_id, now);
     else
       thread_data = last_thread_data;
-    
-    
+
+
     switch (event) {
     case RUBY_EVENT_LINE:
     {
       /* Keep track of the current line number in this method.  When
-         a new method is called, we know what line number it was 
+         a new method is called, we know what line number it was
          called from. */
-         
+
        /* Get the current frame for the current thread. */
       frame = stack_peek(thread_data->stack);
 
       if (frame)
       {
-        frame->line = rb_sourceline();        
-        
+        frame->line = rb_sourceline();
+
         # if RUBY_VERSION == 191
           // disabled it causes
           // us to lose valuable frame information...maybe mid comes in wrong sometimes?
           // walk_up_until_right_frame(frame, thread_data, mid, klass, now);
         # endif
-        
+
         break;
       }
 
-      /* If we get here there was no frame, which means this is 
+      /* If we get here there was no frame, which means this is
          the first method seen for this thread, so fall through
          to below to create it. */
     }
@@ -1161,27 +1219,15 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         /* Is this an include for a module?  If so get the actual
            module class since we want to combine all profiling
            results for that module. */
-        
+
         if (klass != 0)
           klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
-          
-        /* Assume this is the first time we have called this method. */
+
         #ifdef RUBY_VM
-          method = get_method(event, klass, mid, 0, thread_data->method_table);
+        method = get_method(event, klass, mid, thread_data->method_table);
         #else
-          method = get_method(event, node, klass, mid, 0, thread_data->method_table);
+        method = get_method(event, node, klass, mid, thread_data->method_table);
         #endif
-        /* Check for a recursive call */
-        while (method->active) // it's while because we start at 0 and then inc. to the right recursive depth
-        {
-          /* Yes, this method is already active somewhere up the stack */
-          #ifdef RUBY_VM
-            method = get_method(event, klass, mid, method->key->depth + 1, thread_data->method_table);
-          #else
-            method = get_method(event, node, klass, mid, method->key->depth + 1, thread_data->method_table);
-          #endif
-        }          
-        method->active = 1;                
 
         if (!frame)
         {
@@ -1211,9 +1257,9 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     }
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_C_RETURN:
-    {      
-    	frame = pop_frame(thread_data, now);
-      
+    {
+        frame = pop_frame(thread_data, now);
+
       # if RUBY_VERSION == 191
         // we need to walk up the stack to find the right one [http://redmine.ruby-lang.org/issues/show/2610] (for now)
         // sometimes frames don't have line and source somehow [like blank]
@@ -1221,7 +1267,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         // or maybe we don't have one because we're at the top or something.
         walk_up_until_right_frame(frame, thread_data, mid, klass, now);
       # endif
-                
+
       break;
     }
     }
@@ -1240,7 +1286,7 @@ static inline void walk_up_until_right_frame(prof_frame_t *frame, thread_data_t*
 /* ========  ProfResult ============== */
 
 /* Document-class: RubyProf::Result
-The RubyProf::Result class is used to store the results of a 
+The RubyProf::Result class is used to store the results of a
 profiling run.  And instace of the class is returned from
 the methods RubyProf#stop and RubyProf#profile.
 
@@ -1296,7 +1342,7 @@ get_prof_result(VALUE obj)
 Returns a hash table keyed on thread ID.  For each thread id,
 the hash table stores another hash table that contains profiling
 information for each method called during the threads execution.
-That hash table is keyed on method name and contains 
+That hash table is keyed on method name and contains
 RubyProf::MethodInfo objects. */
 static VALUE
 prof_result_threads(VALUE self)
@@ -1309,12 +1355,12 @@ prof_result_threads(VALUE self)
 
 /* 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::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.
@@ -1327,12 +1373,12 @@ prof_get_measure_mode(VALUE self)
 
 /* 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::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.
@@ -1340,7 +1386,7 @@ prof_get_measure_mode(VALUE self)
 static VALUE
 prof_set_measure_mode(VALUE self, VALUE val)
 {
-    long mode = NUM2LONG(val);
+    int mode = NUM2INT(val);
 
     if (threads_tbl)
     {
@@ -1352,12 +1398,12 @@ prof_set_measure_mode(VALUE self, VALUE val)
         get_measurement = measure_process_time;
         convert_measurement = convert_process_time;
         break;
-        
+
       case MEASURE_WALL_TIME:
         get_measurement = measure_wall_time;
         convert_measurement = convert_wall_time;
         break;
-        
+
       #if defined(MEASURE_CPU_TIME)
       case MEASURE_CPU_TIME:
         if (cpu_frequency == 0)
@@ -1366,14 +1412,14 @@ prof_set_measure_mode(VALUE self, VALUE val)
         convert_measurement = convert_cpu_time;
         break;
       #endif
-              
+
       #if defined(MEASURE_ALLOCATIONS)
       case MEASURE_ALLOCATIONS:
         get_measurement = measure_allocations;
         convert_measurement = convert_allocations;
         break;
       #endif
-        
+
       #if defined(MEASURE_MEMORY)
       case MEASURE_MEMORY:
         get_measurement = measure_memory;
@@ -1396,10 +1442,10 @@ prof_set_measure_mode(VALUE self, VALUE val)
       #endif
 
       default:
-        rb_raise(rb_eArgError, "invalid mode: %ld", mode);
+        rb_raise(rb_eArgError, "invalid mode: %d", mode);
         break;
     }
-    
+
     measure_mode = mode;
     return val;
 }
@@ -1431,12 +1477,12 @@ prof_set_exclude_threads(VALUE self, VALUE threads)
       Check_Type(threads, T_ARRAY);
       exclude_threads_tbl = st_init_numtable();
 
-      for (i=0; i < RARRAY_LEN(threads); ++i) 
+      for (i=0; i < RARRAY_LEN(threads); ++i)
       {
         VALUE thread = rb_ary_entry(threads, i);
         st_insert(exclude_threads_tbl, (st_data_t) rb_obj_id(thread), 0);
       }
-    }    
+    }
     return threads;
 }
 
@@ -1448,12 +1494,12 @@ prof_install_hook()
 #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_C_CALL | RUBY_EVENT_C_RETURN
             | RUBY_EVENT_LINE, Qnil); // RUBY_EVENT_SWITCH
 #else
     rb_add_event_hook(prof_event_hook,
           RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
-          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN 
+          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN
           | RUBY_EVENT_LINE);
 #endif
 
@@ -1477,7 +1523,7 @@ prof_remove_hook()
 
 /* call-seq:
    running? -> boolean
-   
+
    Returns whether a profile is currently running.*/
 static VALUE
 prof_running(VALUE self)
@@ -1490,7 +1536,7 @@ prof_running(VALUE self)
 
 /* call-seq:
    start -> RubyProf
-   
+
    Starts recording profile data.*/
 static VALUE
 prof_start(VALUE self)
@@ -1504,9 +1550,21 @@ prof_start(VALUE self)
     last_thread_data = NULL;
     threads_tbl = threads_table_create();
 
-    prof_install_hook();              
+    /* open trace file if environment wants it */
+    char* trace_file_name = getenv("RUBY_PROF_TRACE");
+    if (trace_file_name != NULL) {
+      if (0==strcmp(trace_file_name, "stdout")) {
+        trace_file = stdout;
+      } else if (0==strcmp(trace_file_name, "stderr")) {
+        trace_file = stderr;
+      } else {
+        trace_file = fopen(trace_file_name, "a");
+      }
+    }
+
+    prof_install_hook();
     return self;
-}    
+}
 
 /* call-seq:
    pause -> RubyProf
@@ -1526,20 +1584,20 @@ prof_pause(VALUE self)
 
 /* call-seq:
    resume {block} -> RubyProf
-   
+
    Resumes recording profile data.*/
 static VALUE
 prof_resume(VALUE self)
 {
     if (threads_tbl == NULL)
-    { 
+    {
         prof_start(self);
     }
     else
-    { 
+    {
         prof_install_hook();
     }
-    
+
     if (rb_block_given_p())
     {
       rb_ensure(rb_yield, self, prof_pause, self);
@@ -1556,7 +1614,14 @@ static VALUE
 prof_stop(VALUE self)
 {
     VALUE result = Qnil;
-    
+
+    /* close trace file if open */
+    if (trace_file != NULL) {
+      if (trace_file!=stderr && trace_file!=stdout)
+        fclose(trace_file);
+      trace_file = NULL;
+    }
+
     prof_remove_hook();
 
     prof_pop_threads();
@@ -1564,12 +1629,15 @@ prof_stop(VALUE self)
     /* Create the result */
     result = prof_result_new();
 
-    /* Unset the last_thread_data (very important!) 
+    /* Unset the last_thread_data (very important!)
        and the threads table */
     last_thread_data = NULL;
     threads_table_free(threads_tbl);
     threads_tbl = NULL;
 
+    /* compute minimality of call_infos */
+    rb_funcall(result, rb_intern("compute_minimality") , 0);
+
     return result;
 }
 
@@ -1581,7 +1649,7 @@ static VALUE
 prof_profile(VALUE self)
 {
     int result;
-    
+
     if (!rb_block_given_p())
     {
         rb_raise(rb_eArgError, "A block must be provided to the profile method.");
@@ -1616,21 +1684,21 @@ Returns the cpu time.*/
    call-seq:
      cpu_frequency -> int
 
-Returns the cpu's frequency.  This value is needed when 
+Returns the cpu's frequency.  This value is needed when
 RubyProf::measure_mode is set to CPU_TIME. */
 
 /* Document-method: cpu_frequency
    call-seq:
      cpu_frequency -> int
 
-Returns the cpu's frequency.  This value is needed when 
+Returns the cpu's frequency.  This value is needed when
 RubyProf::measure_mode is set to CPU_TIME. */
 
 /* Document-method: cpu_frequency=
    call-seq:
      cpu_frequency = frequency
 
-Sets the cpu's frequency.  This value is needed when 
+Sets the cpu's frequency.  This value is needed when
 RubyProf::measure_mode is set to CPU_TIME. */
 
 /* Document-method: measure_allocations
@@ -1659,7 +1727,7 @@ Returns the time spent doing garbage collections in microseconds.*/
 
 
 #if defined(_WIN32)
-__declspec(dllexport) 
+__declspec(dllexport)
 #endif
 void
 
@@ -1673,7 +1741,7 @@ Init_ruby_prof()
     rb_define_module_function(mProf, "pause", prof_pause, 0);
     rb_define_module_function(mProf, "running?", prof_running, 0);
     rb_define_module_function(mProf, "profile", prof_profile, 0);
-    
+
     rb_define_singleton_method(mProf, "exclude_threads=", prof_set_exclude_threads, 1);
     rb_define_singleton_method(mProf, "measure_mode", prof_get_measure_mode, 0);
     rb_define_singleton_method(mProf, "measure_mode=", prof_set_measure_mode, 1);
@@ -1692,14 +1760,14 @@ Init_ruby_prof()
     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
-        
+
     #ifndef MEASURE_ALLOCATIONS
     rb_define_const(mProf, "ALLOCATIONS", Qnil);
     #else
     rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
     rb_define_singleton_method(mProf, "measure_allocations", prof_measure_allocations, 0); /* in measure_allocations.h */
     #endif
-    
+
     #ifndef MEASURE_MEMORY
     rb_define_const(mProf, "MEMORY", Qnil);
     #else
@@ -1728,13 +1796,13 @@ Init_ruby_prof()
     /* MethodInfo */
     cMethodInfo = rb_define_class_under(mProf, "MethodInfo", rb_cObject);
     rb_undef_method(CLASS_OF(cMethodInfo), "new");
-    
+
     rb_define_method(cMethodInfo, "klass", prof_method_klass, 0);
     rb_define_method(cMethodInfo, "klass_name", prof_klass_name, 0);
     rb_define_method(cMethodInfo, "method_name", prof_method_name, 0);
     rb_define_method(cMethodInfo, "full_name", prof_full_name, 0);
     rb_define_method(cMethodInfo, "method_id", prof_method_id, 0);
-    
+
     rb_define_method(cMethodInfo, "source_file", prof_method_source_file,0);
     rb_define_method(cMethodInfo, "line", prof_method_line, 0);
 
@@ -1744,11 +1812,16 @@ Init_ruby_prof()
     cCallInfo = rb_define_class_under(mProf, "CallInfo", rb_cObject);
     rb_undef_method(CLASS_OF(cCallInfo), "new");
     rb_define_method(cCallInfo, "parent", prof_call_info_parent, 0);
+    rb_define_method(cCallInfo, "parent=", prof_call_info_set_parent, 1);
     rb_define_method(cCallInfo, "children", prof_call_info_children, 0);
     rb_define_method(cCallInfo, "target", prof_call_info_target, 0);
     rb_define_method(cCallInfo, "called", prof_call_info_called, 0);
+    rb_define_method(cCallInfo, "called=", prof_call_info_set_called, 1);
     rb_define_method(cCallInfo, "total_time", prof_call_info_total_time, 0);
+    rb_define_method(cCallInfo, "add_total_time", prof_call_info_add_total_time, 1);
     rb_define_method(cCallInfo, "self_time", prof_call_info_self_time, 0);
+    rb_define_method(cCallInfo, "add_self_time", prof_call_info_add_self_time, 1);
     rb_define_method(cCallInfo, "wait_time", prof_call_info_wait_time, 0);
+    rb_define_method(cCallInfo, "add_wait_time", prof_call_info_add_wait_time, 1);
     rb_define_method(cCallInfo, "line", prof_call_info_line, 0);
 }