ruby-prof 0.7.4 → 0.7.5

data/ext/ruby_prof.c

@@ -48,7 +48,7 @@
 */
 
 #include "ruby_prof.h"
-
+#include <stdio.h>
 
 /* ================  Helper Functions  =================*/
 static VALUE
@@ -378,7 +378,7 @@ prof_call_info_target(VALUE self)
 /* call-seq:
    called -> int
 
-Returns the total amount of time this method was called. */
+Returns the total amount of times this method was called. */
 static VALUE
 prof_call_info_called(VALUE self)
 {
@@ -872,6 +872,12 @@ 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";
   }
@@ -918,7 +924,7 @@ update_result(prof_measure_t total_time,
               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 */
@@ -926,7 +932,7 @@ update_result(prof_measure_t total_time,
     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,12 +943,12 @@ switch_thread(VALUE thread_id, prof_measure_t now)
 {
     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 = 0;
 
     /* Get the frame at the top of the stack.  This may represent
@@ -950,13 +956,17 @@ switch_thread(VALUE thread_id, prof_measure_t now)
        previous method (EVENT_CALL).*/
     frame = stack_peek(thread_data->stack);
   
-    if (frame)
+    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;
+    if (last_thread_data) {
+      last_thread_data->last_switch = now;   
+    }
       
     last_thread_data = thread_data;
     return thread_data;
@@ -969,11 +979,10 @@ pop_frame(thread_data_t *thread_data, prof_measure_t now)
   prof_frame_t* parent_frame = NULL;
   prof_measure_t total_time;
 
-  frame = stack_pop(thread_data->stack);
-    
+  frame = stack_pop(thread_data->stack); // only time it's called
   /* Frame can be null.  This can happen if RubProf.start is called from
      a method that exits.  And it can happen if an exception is raised
-     in code that is being profiled and the stack unwinds (RubProf is
+     in code that is being profiled and the stack unwinds (RubyProf is
      not notified of that by the ruby runtime. */
   if (frame == NULL) return NULL;
 
@@ -989,7 +998,7 @@ pop_frame(thread_data_t *thread_data, prof_measure_t now)
     parent_frame->child_time += total_time;
   }
     
-  update_result(total_time, parent_frame, frame);
+  update_result(total_time, parent_frame, frame); // only time it's called
   return frame;
 }
 
@@ -1029,7 +1038,6 @@ static void
 prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 #endif
 {
-    
     VALUE thread = Qnil;
     VALUE thread_id = Qnil;
     prof_measure_t now = 0;
@@ -1066,8 +1074,9 @@ 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)
+        if (last_thread_id != thread_id) {
           printf("\n");
+        }
 
         printf("%2u: %-8s :%2d  %s#%s\n",
                thread_id, event_name, source_line, class_name, method_name);
@@ -1182,6 +1191,7 @@ 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:
     {
+        // this assumes that all C calls take 100% user cpu, I guess.
         pop_frame(thread_data, now);
         break;
       }
@@ -1238,7 +1248,7 @@ get_prof_result(VALUE obj)
       RDATA(obj)->dfree != (RUBY_DATA_FUNC) prof_result_free)
     {
         /* Should never happen */
-      rb_raise(rb_eTypeError, "wrong result object");
+      rb_raise(rb_eTypeError, "wrong result object (%d %d) ", BUILTIN_TYPE(obj) != T_DATA, RDATA(obj)->dfree != (RUBY_DATA_FUNC) prof_result_free);
     }
     return (prof_result_t *) DATA_PTR(obj);
 }
@@ -1402,7 +1412,7 @@ prof_install_hook()
     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);
+          | RUBY_EVENT_LINE | RUBY_EVENT_SWITCH, Qnil);
 #else
     rb_add_event_hook(prof_event_hook,
           RUBY_EVENT_CALL | RUBY_EVENT_RETURN |

data/ext/version.h

@@ -1,4 +1,4 @@
-#define RUBY_PROF_VERSION  "0.7.4"
+#define RUBY_PROF_VERSION  "0.7.5"
 #define RUBY_PROF_VERSION_MAJ   0
 #define RUBY_PROF_VERSION_MIN   7
-#define RUBY_PROF_VERSION_MIC   4
+#define RUBY_PROF_VERSION_MIC   5

data/lib/ruby-prof.rb

@@ -7,6 +7,7 @@ require "ruby-prof/flat_printer"
 require "ruby-prof/graph_printer"
 require "ruby-prof/graph_html_printer"
 require "ruby-prof/call_tree_printer"
+require "ruby-prof/symbol_to_proc"
 
 require "ruby-prof/test"
 

data/lib/ruby-prof/symbol_to_proc.rb

@@ -0,0 +1,9 @@
+unless (:a.respond_to?(:to_proc))
+
+ class Symbol
+   def to_proc
+      proc {|stuff| stuff.send(self)}
+   end
+ end
+end
+ 

data/lib/test.rb

@@ -0,0 +1,6 @@
+require 'ruby-prof'
+
+RubyProf.start
+loop {
+ Thread.new { sleep 1 }
+}

data/lib/test2.rb

@@ -0,0 +1,4 @@
+def go
+ 3
+end
+go

data/test/aggregate_test.rb

@@ -86,10 +86,10 @@ class AggregateTest < Test::Unit::TestCase
 
     call_info = call_infos.first
     assert_equal('AggClass#a', call_info.parent.target.full_name)
-    assert_in_delta(3, call_info.total_time, 0.01)
+    assert_in_delta(3, call_info.total_time, 0.05)
     assert_in_delta(0, call_info.wait_time, 0.01)
     assert_in_delta(0, call_info.self_time, 0.01)
-    assert_in_delta(3, call_info.children_time, 0.01)
+    assert_in_delta(3, call_info.children_time, 0.05)
     assert_equal(3, call_info.called)
   end
 
@@ -112,9 +112,9 @@ class AggregateTest < Test::Unit::TestCase
 
     call_info = call_infos.first
     assert_equal('AggClass#z', call_info.target.full_name)
-    assert_in_delta(3, call_info.total_time, 0.01)
+    assert_in_delta(3, call_info.total_time, 0.05)
     assert_in_delta(0, call_info.wait_time, 0.01)
-    assert_in_delta(0, call_info.self_time, 0.01)
+    assert_in_delta(0, call_info.self_time, 0.05)
     assert_in_delta(3, call_info.children_time, 0.01)
     assert_equal(3, call_info.called)
   end

data/test/basic_test.rb

@@ -115,6 +115,12 @@ class BasicTest < Test::Unit::TestCase
     assert_in_delta(0, methods[2].wait_time, 0.01)
     assert_in_delta(0.1, methods[2].self_time, 0.01)
   end
+  
+  if RUBY_VERSION < '1.9'
+    PARENT = Object
+  else
+    PARENT = BasicObject
+  end
 
   def test_instance_methods
     result = RubyProf.profile do
@@ -136,21 +142,22 @@ class BasicTest < Test::Unit::TestCase
     assert_equal('C1#hello', methods[1].full_name)
     assert_equal('Kernel#sleep', methods[2].full_name)
     assert_equal('Class#new', methods[3].full_name)
-    assert_equal('<Class::Object>#allocate', methods[4].full_name)
-    assert_equal('Object#initialize', methods[5].full_name)
+    
+    assert_equal("<Class::#{PARENT}>#allocate", methods[4].full_name)
+    assert_equal("#{PARENT}#initialize", methods[5].full_name)
 
     # Check times
-    assert_in_delta(0.2, methods[0].total_time, 0.01)
+    assert_in_delta(0.2, methods[0].total_time, 0.02)
     assert_in_delta(0, methods[0].wait_time, 0.01)
     assert_in_delta(0, methods[0].self_time, 0.01)
 
-    assert_in_delta(0.2, methods[1].total_time, 0.01)
+    assert_in_delta(0.2, methods[1].total_time, 0.02)
     assert_in_delta(0, methods[1].wait_time, 0.01)
     assert_in_delta(0, methods[1].self_time, 0.01)
 
-    assert_in_delta(0.2, methods[2].total_time, 0.01)
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
     assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.2, methods[2].self_time, 0.01)
+    assert_in_delta(0.2, methods[2].self_time, 0.02)
 
     assert_in_delta(0, methods[3].total_time, 0.01)
     assert_in_delta(0, methods[3].wait_time, 0.01)
@@ -183,17 +190,17 @@ class BasicTest < Test::Unit::TestCase
     assert_equal('Kernel#sleep', methods[2].full_name)
 
     # Check times
-    assert_in_delta(0.3, methods[0].total_time, 0.01)
+    assert_in_delta(0.3, methods[0].total_time, 0.02)
     assert_in_delta(0, methods[0].wait_time, 0.01)
     assert_in_delta(0, methods[0].self_time, 0.01)
 
-    assert_in_delta(0.3, methods[1].total_time, 0.01)
+    assert_in_delta(0.3, methods[1].total_time, 0.02)
     assert_in_delta(0, methods[1].wait_time, 0.01)
     assert_in_delta(0, methods[1].self_time, 0.01)
 
-    assert_in_delta(0.3, methods[2].total_time, 0.01)
+    assert_in_delta(0.3, methods[2].total_time, 0.02)
     assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.3, methods[2].self_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.02)
   end
 
   def test_module_instance_methods
@@ -216,21 +223,21 @@ class BasicTest < Test::Unit::TestCase
     assert_equal('M1#hello', methods[1].full_name)
     assert_equal('Kernel#sleep', methods[2].full_name)
     assert_equal('Class#new', methods[3].full_name)
-    assert_equal('<Class::Object>#allocate', methods[4].full_name)
-    assert_equal('Object#initialize', methods[5].full_name)
-
+    assert_equal("<Class::#{PARENT}>#allocate", methods[4].full_name)
+    assert_equal("#{PARENT}#initialize", methods[5].full_name)
+    
     # Check times
-    assert_in_delta(0.3, methods[0].total_time, 0.01)
-    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0.3, methods[0].total_time, 0.02)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
     assert_in_delta(0, methods[0].self_time, 0.01)
 
-    assert_in_delta(0.3, methods[1].total_time, 0.01)
+    assert_in_delta(0.3, methods[1].total_time, 0.02)
     assert_in_delta(0, methods[1].wait_time, 0.01)
     assert_in_delta(0, methods[1].self_time, 0.01)
 
-    assert_in_delta(0.3, methods[2].total_time, 0.01)
+    assert_in_delta(0.3, methods[2].total_time, 0.02)
     assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.3, methods[2].self_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.02)
 
     assert_in_delta(0, methods[3].total_time, 0.01)
     assert_in_delta(0, methods[3].wait_time, 0.01)

data/test/current_failures_windows

@@ -0,0 +1,20 @@
+1.8 passes, 1.9 however...
+
+
+  1) Failure:
+test_thread_count(ThreadTest) [E:/dev/ruby/ruby-prof/test/thread_test.rb:22]:
+<2> expected but was
+<1>.
+
+  2) Failure:
+test_thread_identity(ThreadTest) [E:/dev/ruby/ruby-prof/test/thread_test.rb:37]:
+<2> expected but was
+<1>.
+
+  3) Failure:
+test_thread_timings(ThreadTest) [E:/dev/ruby/ruby-prof/test/thread_test.rb:58]:
+<2> expected but was
+<1>.
+
+43 tests, 390 assertions, 3 failures, 0 errors, 0 skips
+rake aborted!

data/test/recursive_test.rb

@@ -34,15 +34,20 @@ class RecursiveTest < Test::Unit::TestCase
     end
 
     methods = result.threads.values.first.sort.reverse
-    assert_equal(6, methods.length)
-
+    
+    if RUBY_VERSION < '1.9'
+      assert_equal(6, methods.length) # includes Fixnum+, Fixnum==...
+    else
+      assert_equal(4, methods.length)
+    end
+    
     method = methods[0]
     assert_equal('RecursiveTest#test_simple', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.01)
+    assert_in_delta(2, method.total_time, 0.05)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(2, method.children_time, 0.01)
+    assert_in_delta(2, method.children_time, 0.05)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
@@ -60,8 +65,11 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_simple->Object#simple', call_info.call_sequence)
-    assert_equal(4, call_info.children.length)
-
+    if RUBY_VERSION < '1.9'
+      assert_equal(4, call_info.children.length)
+    else
+      assert_equal(2, call_info.children.length)
+    end
     method = methods[2]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(2, method.called)
@@ -90,58 +98,66 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple-1', call_info.call_sequence)
-    assert_equal(3, call_info.children.length)
-
-    method = methods[4]
-    assert_equal('Fixnum#-', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
-
-    assert_equal(2, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_simple->Object#simple->Fixnum#-', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple-1->Fixnum#-', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    method = methods[5]
-    assert_equal('Fixnum#==', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
-
-    assert_equal(2, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_simple->Object#simple->Fixnum#==', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple-1->Fixnum#==', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
+    if RUBY_VERSION < '1.9'
+      assert_equal(3, call_info.children.length)
+
+      method = methods[4]
+      assert_equal('Fixnum#-', method.full_name)
+      assert_equal(2, method.called)
+      assert_in_delta(0, method.total_time, 0.01)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(2, method.call_infos.length)
+      call_info = method.call_infos[0]
+      assert_equal('RecursiveTest#test_simple->Object#simple->Fixnum#-', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+
+      call_info = method.call_infos[1]
+      assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple-1->Fixnum#-', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+
+      method = methods[5]
+      assert_equal('Fixnum#==', method.full_name)
+      assert_equal(2, method.called)
+      assert_in_delta(0, method.total_time, 0.01)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(2, method.call_infos.length)
+      call_info = method.call_infos[0]
+      assert_equal('RecursiveTest#test_simple->Object#simple->Fixnum#==', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+
+      call_info = method.call_infos[1]
+      assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple-1->Fixnum#==', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+
+    else
+      assert_equal(1, call_info.children.length)
+    end
   end
-  
+
   def test_cycle
     result = RubyProf.profile do
       cycle(2)
     end
 
     methods = result.threads.values.first.sort.reverse
-    assert_equal(8, methods.length)
-
+    if RUBY_VERSION < '1.9'
+      assert_equal(8, methods.length) # includes Fixnum+ and Fixnum==, which aren't included in 1.9
+    else
+      assert_equal(6, methods.length)
+    end
     method = methods[0]
     assert_equal('RecursiveTest#test_cycle', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.01)
+    assert_in_delta(2, method.total_time, 0.05)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(2, method.children_time, 0.01)
+    assert_in_delta(2, method.children_time, 0.05)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
@@ -151,10 +167,10 @@ class RecursiveTest < Test::Unit::TestCase
     method = methods[1]
     assert_equal('Object#cycle', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.01)
+    assert_in_delta(2, method.total_time, 0.05)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(2, method.children_time, 0.01)
+    assert_in_delta(2, method.children_time, 0.05)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
@@ -164,20 +180,24 @@ class RecursiveTest < Test::Unit::TestCase
     method = methods[2]
     assert_equal('Object#sub_cycle', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.01)
+    assert_in_delta(2, method.total_time, 0.05)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(2, method.children_time, 0.01)
+    assert_in_delta(2, method.children_time, 0.05)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle', call_info.call_sequence)
-    assert_equal(4, call_info.children.length)
+    if RUBY_VERSION < '1.9'
+      assert_equal(4, call_info.children.length)
+    else
+      assert_equal(2, call_info.children.length)
+    end
 
     method = methods[3]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.01)
+    assert_in_delta(2, method.total_time, 0.05)
     assert_in_delta(2, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(0, method.children_time, 0.01)
@@ -194,10 +214,10 @@ class RecursiveTest < Test::Unit::TestCase
     method = methods[4]
     assert_equal('Object#cycle-1', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.01)
+    assert_in_delta(1, method.total_time, 0.05)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(1, method.children_time, 0.01)
+    assert_in_delta(1, method.children_time, 0.05)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
@@ -215,40 +235,44 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1', call_info.call_sequence)
-    assert_equal(3, call_info.children.length)
-
-    method = methods[6]
-    assert_equal('Fixnum#-', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
-
-    assert_equal(2, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Fixnum#-', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1->Fixnum#-', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    method = methods[7]
-    assert_equal('Fixnum#==', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
-
-    assert_equal(2, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Fixnum#==', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
+    if RUBY_VERSION < '1.9'
+      assert_equal(3, call_info.children.length)
+      method = methods[6]
+      assert_equal('Fixnum#-', method.full_name)
+      assert_equal(2, method.called)
+      assert_in_delta(0, method.total_time, 0.01)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(2, method.call_infos.length)
+      call_info = method.call_infos[0]
+      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Fixnum#-', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+
+      call_info = method.call_infos[1]
+      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1->Fixnum#-', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+
+      method = methods[7]
+      assert_equal('Fixnum#==', method.full_name)
+      assert_equal(2, method.called)
+      assert_in_delta(0, method.total_time, 0.01)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(2, method.call_infos.length)
+      call_info = method.call_infos[0]
+      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Fixnum#==', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+
+      call_info = method.call_infos[1]
+      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1->Fixnum#==', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+    else
+      assert_equal(1, call_info.children.length)
+    end
 
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1->Fixnum#==', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
   end
-end
+end