ruby-prof 0.11.0.rc3-x86-mingw32 → 0.11.2-x86-mingw32

data/CHANGES

@@ -1,3 +1,31 @@
+0.11.2 (2012-05-06)
+======================
+* Fix compile issue with BOOL.  Should be _Bool for C99.
+
+
+0.11.1 (2012-05-06)
+======================
+* Added option --exclude-common-callbacks, plus exclude #map and #inject in common cycles (Vasily Fedoseyev)
+* Add option --exclude-common-cycles to exclude common iterators (Vasily Fedoseyev)
+* Allow method elimination from command line via '-x' and '-X' keys (Vasily Fedoseyev)
+
+
+0.11.0 (2012-05-05)
+======================
+* Fix pause/resume so it actually works and add tests (David Barri)
+* Resume now returns the result of the block when given (David Barri)
+* Make recursive method explanation more clear (Charlie Savage)
+* Fix ruby warnings (Charlie Savage)
+* Toggle GC.enable_stats when profiling for memory to get the data (Vasily Fedoseyev)
+* Fix patched ruby support and remove some warnings (Vasily Fedoseyev)
+* Fix tests on 1.8.7 (rogerdpack)
+
+
+0.11.0.rc3 (2012-03-26)
+======================
+* Include missing files in gemspec (Charlie Savage).
+
+
 0.11.0.rc2 (2012-03-25)
 ======================
 * Lots of improvements to Rack handler - this can be used to profile requests

data/Rakefile

@@ -22,6 +22,7 @@ SO_NAME = 'ruby_prof'
 
 default_spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
 
+# specify which versions/builds to cross compile
 Rake::ExtensionTask.new do |ext|
   ext.gem_spec = default_spec
   ext.name = SO_NAME

data/bin/ruby-prof

@@ -172,6 +172,59 @@ opts = OptionParser.new do |opts|
       options.exec ||= []
       options.exec << code
   end
+
+  opts.on('-x regexp', '--exclude regexp', 'exclude methods by regexp (see method elimination)') do|meth|
+    options.eliminate_methods ||= []
+    options.eliminate_methods << Regexp.new(meth)
+  end
+
+  opts.on('-X file', '--exclude-file file', 'exclude methods by regexp listed in file (see method elimination)') do|file|
+    options.eliminate_methods_files ||= []
+    options.eliminate_methods_files << file
+  end
+
+  opts.on('--exclude-common-cycles', 'make common iterators like Integer#times appear inlined') do|meth|
+    options.eliminate_methods ||= []
+    options.eliminate_methods += %w{
+      Integer#times
+      Integer#upto
+      Integer#downto
+      Enumerator#each
+      Enumerator#each_with_index
+      Enumerator#each_with_object
+
+      Array#each
+      Array#each_index
+      Array#reverse_each
+      Array#map
+
+      Hash#each
+      Hash#each_pair
+      Hash#each_key
+      Hash#each_value
+
+      Range#each
+      Enumerable#each_cons
+      Enumerable#each_entry
+      Enumerable#each_slice
+      Enumerable#each_with_index
+      Enumerable#each_with_object
+      Enumerable#reverse_each
+      Enumerable#inject
+      Enumerable#collect
+      Enumerable#reduce
+    }
+    #TODO: may be the whole Enumerable module should be excluded via 'Enumerable#.*', we need feedback on use cases.
+  end
+
+  opts.on('--exclude-common-callbacks', 'make common callbacks invocations like Integer#times appear inlined so you can see call origins in graph') do|meth|
+    options.eliminate_methods ||= []
+    options.eliminate_methods += %w{
+      Method#call
+      Proc#call
+      ActiveSupport::Callbacks::ClassMethods#__run_callback
+    }
+  end
 end
 
 begin
@@ -201,6 +254,10 @@ at_exit {
   # Stop profiling
   result = RubyProf.stop
 
+  # Eliminate unwanted methods from call graph
+  result.eliminate_methods! options.eliminate_methods if options.eliminate_methods
+  options.eliminate_methods_files.each{|f| result.eliminate_methods!(f)} if options.eliminate_methods_files
+
   # Create a printer
   printer = options.printer.new(result)
   printer_options = {:min_percent => options.min_percent, :sort_method => options.sort_method}

data/ext/ruby_prof/rp_measure_allocations.c

@@ -8,50 +8,29 @@
 static VALUE cMeasureAllocations;
 
 #if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
-#define MEASURE_ALLOCATIONS_ENABLED Qtrue
+  unsigned LONG_LONG rb_os_allocated_objects();
+#endif
+
+#if defined(HAVE_RB_GC_MALLOC_ALLOCATIONS)
+  unsigned LONG_LONG rb_gc_malloc_allocations();
+#endif
 
 static double
 measure_allocations()
 {
+#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
+#define MEASURE_ALLOCATIONS_ENABLED Qtrue
     return rb_os_allocated_objects();
-}
-
-/* Document-method: prof_measure_allocations
-   call-seq:
-     measure_allocations -> int
-
-Returns the total number of object allocations since Ruby started.*/
-static VALUE
-prof_measure_allocations(VALUE self)
-{
-#if defined(HAVE_LONG_LONG)
-    return ULL2NUM(rb_os_allocated_objects());
-#else
-    return ULONG2NUM(rb_os_allocated_objects());
-#endif
-}
 
 #elif defined(HAVE_RB_GC_MALLOC_ALLOCATIONS)
-
 #define MEASURE_ALLOCATIONS_ENABLED Qtrue
-
-static double
-measure_allocations()
-{
     return rb_gc_malloc_allocations();
-}
 
 #else
-
 #define MEASURE_ALLOCATIONS_ENABLED Qfalse
-
-static double
-measure_allocations()
-{
     return 0;
-}
-
 #endif
+}
 
 
 prof_measurer_t* prof_measurer_allocations()

data/ext/ruby_prof/rp_measure_gc_runs.c

@@ -8,53 +8,31 @@
 static VALUE cMeasureGcRuns;
 
 #if defined(HAVE_RB_GC_COLLECTIONS)
+  VALUE rb_gc_collections(void);
+#endif
+
+#if defined(HAVE_RB_GC_HEAP_INFO)
+  VALUE rb_gc_heap_info(void);
+#endif
 
-#define MEASURE_GC_RUNS_ENABLED Qtrue
 
 static double
 measure_gc_runs()
 {
-    return NUM2INT(rb_gc_collections());
-}
-
-/* call-seq:
-   gc_runs -> Integer
-
-Returns the total number of garbage collections.*/
-static VALUE
-prof_measure_gc_runs(VALUE self)
-{
-    return rb_gc_collections();
-}
+#if defined(HAVE_RB_GC_COLLECTIONS)
+#define MEASURE_GC_RUNS_ENABLED Qtrue
+  return NUM2INT(rb_gc_collections());
 
 #elif defined(HAVE_RB_GC_HEAP_INFO)
-
 #define MEASURE_GC_RUNS_ENABLED Qtrue
-
-static double
-measure_gc_runs()
-{
   VALUE h = rb_gc_heap_info();
   return NUM2UINT(rb_hash_aref(h, rb_str_new2("num_gc_passes")));
-}
-
-static VALUE
-prof_measure_gc_runs(VALUE self)
-{
-  VALUE h = rb_gc_heap_info();
-  return rb_hash_aref(h, rb_str_new2("num_gc_passes"));
-}
-
-#else 
 
+#else
 #define MEASURE_GC_RUNS_ENABLED Qfalse
-
-static double
-measure_gc_runs()
-{
   return 0;
-}
 #endif
+}
 
 prof_measurer_t* prof_measurer_gc_runs()
 {

data/ext/ruby_prof/rp_measure_gc_time.c

@@ -8,40 +8,27 @@
 static VALUE cMeasureGcTimes;
 
 #if defined(HAVE_RB_GC_TIME)
+  VALUE rb_gc_time();
+#endif
 
-#define MEASURE_GC_TIME_ENABLED Qtrue
 
 static double
 measure_gc_time()
 {
-    int conversion = 1000000
+#if defined(HAVE_RB_GC_TIME)
+#define MEASURE_GC_TIME_ENABLED Qtrue
+    const int conversion = 1000000;
 #if HAVE_LONG_LONG
     return NUM2LL(rb_gc_time() / conversion);
 #else
     return NUM2LONG(rb_gc_time() / conversion));
 #endif
-}
-
-/* call-seq:
-   gc_time -> Integer
-
-Returns the time spent doing garbage collections in microseconds.*/
-static VALUE
-prof_measure_gc_time(VALUE self)
-{
-    return rb_gc_time();
-}
 
 #else
-
 #define MEASURE_GC_TIME_ENABLED Qfalse
-
-static double
-measure_gc_time()
-{
     return 0;
-}
 #endif
+}
 
 prof_measurer_t* prof_measurer_gc_time()
 {
@@ -63,6 +50,7 @@ prof_measure_gc_time(VALUE self)
     return ULONG2NUM(measure_gc_time());
 #endif
 }
+
 void rp_init_measure_gc_time()
 {
     rb_define_const(mProf, "GC_TIME", INT2NUM(MEASURE_GC_TIME));

data/ext/ruby_prof/rp_measure_memory.c

@@ -7,52 +7,45 @@
 
 static VALUE cMeasureMemory;
 
+
 #if defined(HAVE_RB_GC_ALLOCATED_SIZE)
-#define TOGGLE_GC_STATS 1
-#define MEASURE_GC_TIME_ENABLED Qtrue
+  VALUE rb_gc_allocated_size();
+#endif
+
+#if defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
+  size_t rb_gc_malloc_allocated_size();
+#endif
+
+#if defined(HAVE_RB_HEAP_TOTAL_MEM)
+  //FIXME: did not find the patch to check prototype, assuming it to return size_t
+  size_t rb_heap_total_mem();
+#endif
 
 static double
 measure_memory()
 {
+#if defined(HAVE_RB_GC_ALLOCATED_SIZE)
+#define TOGGLE_GC_STATS 1
+#define MEASURE_MEMORY_ENABLED Qtrue
 #if defined(HAVE_LONG_LONG)
-    return NUM2LL(rb_gc_allocated_size() / 1024);
+    return NUM2LL(rb_gc_allocated_size()) / 1024.0;
 #else
-    return NUM2ULONG(rb_gc_allocated_size() / 1024);
+    return NUM2ULONG(rb_gc_allocated_size()) / 1024.0;
 #endif
-}
 
 #elif defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
-
 #define MEASURE_MEMORY_ENABLED Qtrue
-
-static double
-measure_memory()
-{
-    return rb_gc_malloc_allocated_size() / 1024;
-}
-
+    return rb_gc_malloc_allocated_size() / 1024.0;
 
 #elif defined(HAVE_RB_HEAP_TOTAL_MEM)
-
 #define MEASURE_MEMORY_ENABLED Qtrue
-
-static double
-measure_memory()
-{
-    return rb_heap_total_mem() / 1024;
-}
+    return rb_heap_total_mem() / 1024.0;
 
 #else
-
 #define MEASURE_MEMORY_ENABLED Qfalse
-
-static double
-measure_memory()
-{
     return 0;
-}
-
 #endif
+}
 
 prof_measurer_t* prof_measurer_memory()
 {

data/ext/ruby_prof/rp_stack.c

@@ -5,6 +5,22 @@
 
 #define INITIAL_STACK_SIZE 8
 
+void
+frame_pause(prof_frame_t *frame, double current_measurement)
+{
+    if (frame && frame_is_unpaused(frame))
+        frame->pause_time = current_measurement;
+}
+
+void
+frame_unpause(prof_frame_t *frame, double current_measurement)
+{
+    if (frame && frame_is_paused(frame)) {
+        frame->dead_time += (current_measurement - frame->pause_time);
+        frame->pause_time = -1;
+    }
+}
+
 
 /* Creates a stack of prof_frame_t to keep track
    of timings for active methods. */
@@ -48,7 +64,7 @@ stack_push(prof_stack_t *stack)
   result->child_time = 0;
   result->switch_time = 0;
   result->wait_time = 0;
-  result->depth = (stack->ptr - stack->start);
+  result->depth = (int)(stack->ptr - stack->start); // shortening of 64 bit into 32
 
   // Increment the stack ptr for next time
   stack->ptr++;

data/ext/ruby_prof/rp_stack.h

@@ -22,10 +22,18 @@ typedef struct
     double switch_time;  /* Time at switch to different thread */
     double wait_time;
     double child_time;
+    double pause_time; // Time pause() was initiated
+    double dead_time; // Time to ignore (i.e. total amount of time between pause/resume blocks)
     int depth;
     unsigned int line;
 } prof_frame_t;
 
+#define frame_is_paused(f) (f->pause_time >= 0)
+#define frame_is_unpaused(f) (f->pause_time < 0)
+void frame_pause(prof_frame_t*, double current_measurement);
+void frame_unpause(prof_frame_t*, double current_measurement);
+
+
 /* Current stack of active methods.*/
 typedef struct 
 {

data/ext/ruby_prof/ruby_prof.c

@@ -133,6 +133,11 @@ pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
   double measurement = profile->measurer->measure();
   double total_time;
   double self_time;
+#ifdef _MSC_VER
+  BOOL frame_paused;
+#else
+  _Bool frame_paused;
+#endif
 
   frame = stack_pop(thread_data->stack); // only time it's called
 
@@ -140,11 +145,13 @@ pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
      a method that exits.  And it can happen if an exception is raised
      in code that is being profiled and the stack unwinds (RubyProf is
      not notified of that by the ruby runtime. */
-  if (frame == NULL) 
+  if (frame == NULL)
       return NULL;
 
   /* Calculate the total time this method took */
-  total_time = measurement - frame->start_time;
+  frame_paused = frame_is_paused(frame);
+  frame_unpause(frame, measurement);
+  total_time = measurement - frame->start_time - frame->dead_time;
   self_time = total_time - frame->child_time - frame->wait_time;
 
   /* Update information about the current method */
@@ -158,6 +165,12 @@ pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
   if (parent_frame)
   {
       parent_frame->child_time += total_time;
+      parent_frame->dead_time += frame->dead_time;
+
+      // Repause parent if currently paused
+      if (frame_paused)
+          frame_pause(parent_frame, measurement);
+
       call_info->line = parent_frame->line;
   }
 
@@ -333,6 +346,11 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
             call_info_table_insert(frame->call_info->call_infos, method->key, call_info);
             prof_add_call_info(method->call_infos, call_info);
           }
+
+          // Unpause the parent frame. If currently paused then:
+          // 1) The child frame will begin paused.
+          // 2) The parent will inherit the child's dead time.
+          frame_unpause(frame, measurement);
         }
 
         /* Push a new frame onto the stack for a new c-call or ruby call (into a method) */
@@ -340,6 +358,8 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         frame->call_info = call_info;
 		frame->call_info->depth = frame->depth;
         frame->start_time = measurement;
+        frame->pause_time = profile->paused == Qtrue ? measurement : -1;
+        frame->dead_time = 0;
         frame->line = rb_sourceline();
         break;
     }
@@ -459,7 +479,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
     VALUE mode;
-    prof_measure_mode_t measurer;
+    prof_measure_mode_t measurer = MEASURE_WALL_TIME;
     VALUE exclude_threads;
     int i;
     
@@ -497,6 +517,39 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
     return self;
 }
 
+static int pause_thread(st_data_t key, st_data_t value, st_data_t data) 
+{
+    thread_data_t* thread_data = (thread_data_t *) value;
+    prof_profile_t* profile = (prof_profile_t*) data;
+
+    prof_frame_t* frame = stack_peek(thread_data->stack);
+    frame_pause(frame, profile->measurement_at_pause_resume);
+
+    return ST_CONTINUE;
+}
+
+static int unpause_thread(st_data_t key, st_data_t value, st_data_t data) 
+{
+    thread_data_t* thread_data = (thread_data_t *) value;
+    prof_profile_t* profile = (prof_profile_t*) data;
+
+    prof_frame_t* frame = stack_peek(thread_data->stack);
+    frame_unpause(frame, profile->measurement_at_pause_resume);
+
+    return ST_CONTINUE;
+}
+
+/* call-seq:
+   paused? -> boolean
+
+   Returns whether a profile is currently paused.*/
+static VALUE
+prof_paused(VALUE self)
+{
+    prof_profile_t* profile = prof_get_profile(self);
+    return profile->paused;
+}
+
 /* call-seq:
    running? -> boolean
 
@@ -516,6 +569,7 @@ static VALUE
 prof_start(VALUE self)
 {
     char* trace_file_name;
+
     prof_profile_t* profile = prof_get_profile(self);
         
     if (profile->running == Qtrue)
@@ -523,7 +577,15 @@ prof_start(VALUE self)
         rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
     }
 
+#ifndef RUBY_VM
+	if (pCurrentProfile != NULL)
+    {
+        rb_raise(rb_eRuntimeError, "Only one profile can run at a time on Ruby 1.8.*");
+    }
+#endif
+
     profile->running = Qtrue;
+    profile->paused = Qfalse;
     profile->last_thread_data = NULL;
 
 
@@ -562,9 +624,13 @@ prof_pause(VALUE self)
         rb_raise(rb_eRuntimeError, "RubyProf is not running.");
     }
 
-    profile->running = Qfalse;
+    if (profile->paused == Qfalse)
+    {
+        profile->paused = Qtrue;
+        profile->measurement_at_pause_resume = profile->measurer->measure();
+        st_foreach(profile->threads_tbl, pause_thread, (st_data_t) profile);
+    }
 
-    prof_remove_hook();
     return self;
 }
 
@@ -578,20 +644,17 @@ prof_resume(VALUE self)
     prof_profile_t* profile = prof_get_profile(self);
     if (profile->running == Qfalse)
     {
-        prof_start(self);
-    }
-    else
-    {
-        profile->running = Qtrue;
-        prof_install_hook(self);
+        rb_raise(rb_eRuntimeError, "RubyProf is not running.");
     }
 
-    if (rb_block_given_p())
+    if (profile->paused == Qtrue)
     {
-      rb_ensure(rb_yield, self, prof_pause, self);
+        profile->paused = Qfalse;
+        profile->measurement_at_pause_resume = profile->measurer->measure();
+        st_foreach(profile->threads_tbl, unpause_thread, (st_data_t) profile);
     }
 
-    return self;
+    return rb_block_given_p() ? rb_ensure(rb_yield, self, prof_pause, self) : self;
 }
 
 /* call-seq:
@@ -628,7 +691,7 @@ prof_stop(VALUE self)
 
     /* Unset the last_thread_data (very important!)
        and the threads table */
-    profile->running = Qfalse;
+    profile->running = profile->paused = Qfalse;
     profile->last_thread_data = NULL;
 
     /* Post process result */
@@ -686,10 +749,10 @@ void Init_ruby_prof()
     rb_define_alloc_func (cProfile, prof_allocate);
     rb_define_method(cProfile, "initialize", prof_initialize, -1);
     rb_define_method(cProfile, "start", prof_start, 0);
-    rb_define_method(cProfile, "start", prof_start, 0);
     rb_define_method(cProfile, "stop", prof_stop, 0);
     rb_define_method(cProfile, "resume", prof_resume, 0);
     rb_define_method(cProfile, "pause", prof_pause, 0);
     rb_define_method(cProfile, "running?", prof_running, 0);
+    rb_define_method(cProfile, "paused?", prof_paused, 0);
     rb_define_method(cProfile, "threads", prof_threads, 0);
 }