ruby-prof 0.11.0.rc3 → 0.11.2

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);
 }

data/ext/ruby_prof/ruby_prof.h

@@ -42,11 +42,13 @@ void method_key(prof_method_key_t* key, VALUE klass, ID mid);
 typedef struct
 {
     VALUE running;
+    VALUE paused;
     prof_measurer_t* measurer;
     VALUE threads;
     st_table* threads_tbl;
     st_table* exclude_threads_tbl;
     thread_data_t* last_thread_data;
+    double measurement_at_pause_resume;
 } prof_profile_t;
 
 

data/ext/ruby_prof/vc/ruby_prof_18.vcxproj

@@ -64,6 +64,8 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <LinkIncremental>true</LinkIncremental>
     <OutDir>C:\MinGW\local\src\ruby-prof\lib\1.8</OutDir>
+    <TargetExt>.so</TargetExt>
+    <TargetName>ruby_prof</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
@@ -81,6 +83,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>C:\MinGW\local\ruby187vc\lib</AdditionalLibraryDirectories>
       <AdditionalDependencies>msvcr100-ruby18.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

data/ext/ruby_prof/version.h

@@ -1,7 +1,7 @@
 /* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
    Please see the LICENSE file for copyright and distribution information */
 
-#define RUBY_PROF_VERSION  "0.11.0" // for easy parsing from rake files
+#define RUBY_PROF_VERSION  "0.11.2" // for easy parsing from rake files
 #define RUBY_PROF_VERSION_MAJ   0
 #define RUBY_PROF_VERSION_MIN   11
-#define RUBY_PROF_VERSION_MIC   0
+#define RUBY_PROF_VERSION_MIC   2

data/lib/ruby-prof/compatibility.rb

@@ -18,7 +18,7 @@ module RubyProf
   def self.measure_cpu_time
     Measure::CpuTime.measure
   end
-  
+
   def self.measure_gc_runs
     Measure::GcRuns.measure
   end
@@ -38,7 +38,7 @@ module RubyProf
   def self.measure_wall_time
     Measure::WallTime.measure
   end
-  
+
   # call-seq:
   # measure_mode -> measure_mode
   #
@@ -51,11 +51,11 @@ module RubyProf
   # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
   # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
   # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
-  
+
   def self.measure_mode
     @measure_mode ||= RubyProf::WALL_TIME
   end
-  
+
   # call-seq:
   # measure_mode=value -> void
   #
@@ -71,33 +71,31 @@ module RubyProf
   def self.measure_mode=(value)
     @measure_mode = value
   end
-  
+
   # call-seq:
   # exclude_threads= -> void
   #
   # Specifies what threads ruby-prof should exclude from profiling
-  
+
   def self.exclude_threads
     @exclude_threads ||= Array.new
   end
-  
+
   def self.exclude_threads=(value)
     @exclude_threads = value
   end
-  
+
   # Profiling
   def self.start
-    if running?
-      raise(RuntimeError, "RubyProf is already running");
-    end
+    ensure_not_running!
     @profile = Profile.new(self.measure_mode, self.exclude_threads)
+    enable_gc_stats_if_needed
     @profile.start
   end
 
   def self.pause
-    unless running?
-      raise(RuntimeError, "RubyProf.start was not yet called");
-    end
+    ensure_running!
+    disable_gc_stats_if_needed
     @profile.pause
   end
 
@@ -110,25 +108,47 @@ module RubyProf
   end
 
   def self.resume
-    unless running?
-      raise(RuntimeError, "RubyProf.start was not yet called");
-    end
+    ensure_running!
+    enable_gc_stats_if_needed
     @profile.resume
   end
 
   def self.stop
-    unless running?
-      raise(RuntimeError, "RubyProf.start was not yet called");
-    end
+    ensure_running!
+    disable_gc_stats_if_needed
     result = @profile.stop
     @profile = nil
     result
   end
 
+  # Profile a block
   def self.profile(&block)
-    if running?
-      raise(RuntimeError, "RubyProf is already running");
+    ensure_not_running!
+    gc_stat_was_enabled = enable_gc_stats_if_needed
+    res = Profile.profile(self.measure_mode, self.exclude_threads, &block)
+    disable_gc_stats_if_needed(gc_stat_was_enabled)
+    res
+  end
+
+
+private
+  def self.ensure_running!
+    raise(RuntimeError, "RubyProf.start was not yet called") unless running?
+  end
+
+  def self.ensure_not_running!
+    raise(RuntimeError, "RubyProf is already running") if running?
+  end
+
+  # for GC.allocated_size to work GC statistics should be enabled
+  def self.enable_gc_stats_if_needed
+    if self.measure_mode == RubyProf::MEMORY && GC.respond_to?(:enable_stats)
+      @gc_stat_was_enabled = GC.enable_stats
     end
-    Profile.profile(self.measure_mode, self.exclude_threads, &block)
+  end
+
+  def self.disable_gc_stats_if_needed(was_enabled=nil)
+    was_enabled ||= defined?(@gc_stat_was_enabled) && @gc_stat_was_enabled
+    GC.disable_stats if self.measure_mode == RubyProf::MEMORY && GC.respond_to?(:disable_stats) && !was_enabled
   end
 end

data/lib/ruby-prof/printers/flat_printer.rb

@@ -62,7 +62,7 @@ module RubyProf
 
     def print_footer(thread)
       @output << "\n"
-      @output << "* in front of method name means it is recursively called\n"
+      @output << "* indicates recursively called methods\n"
     end
   end
 end

data/lib/ruby-prof/printers/graph_html_printer.rb

@@ -235,7 +235,7 @@ module RubyProf
         </tbody>
         <tfoot>
           <tr>
-            <td colspan="9">* in front of method name means it is recursively called</td>
+            <td colspan="9">* indicates recursively called methods</td>
           </tr>
         </tfoot>
       </table>

data/lib/ruby-prof/printers/graph_printer.rb

@@ -109,7 +109,7 @@ module RubyProf
 
     def print_footer(thread)
       @output << "\n"
-      @output << "* in front of method name means it is recursively called\n"
+      @output << "* indicates recursively called methods\n"
     end
   end
 end

data/ruby-prof.gemspec

@@ -6,8 +6,7 @@ version_header = File.read(File.expand_path('../ext/ruby_prof/version.h', __FILE
 match = version_header.match(/RUBY_PROF_VERSION\s*"([^"]+)"/)
 raise(RuntimeError, "Could not determine RUBY_PROF_VERSION") if not match
 
-# For now make this an rc1
-RUBY_PROF_VERSION = "#{match[1]}.rc3"
+RUBY_PROF_VERSION = "#{match[1]}"
 
 Gem::Specification.new do |spec|
   spec.name = "ruby-prof"

data/test/basic_test.rb

@@ -39,4 +39,58 @@ class BasicTest < Test::Unit::TestCase
 
     RubyProf.stop
   end
-end
+
+  def test_pause_seq
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    p.start ; assert !p.paused?
+    p.pause ; assert p.paused?
+    p.resume; assert !p.paused?
+    p.pause ; assert p.paused?
+    p.pause ; assert p.paused?
+    p.resume; assert !p.paused?
+    p.resume; assert !p.paused?
+    p.stop  ; assert !p.paused?
+  end
+
+  def test_pause_block
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    p.start
+    p.pause
+    assert p.paused?
+
+    times_block_invoked = 0
+    retval= p.resume{
+      times_block_invoked += 1
+      120 + times_block_invoked
+    }
+    assert_equal 1, times_block_invoked
+    assert p.paused?
+
+    assert_equal 121, retval, "resume() should return the result of the given block."
+
+    p.stop
+  end
+
+  def test_pause_block_with_error
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    p.start
+    p.pause
+    assert p.paused?
+
+    begin
+      p.resume{ raise }
+      flunk 'Exception expected.'
+    rescue
+      assert p.paused?
+    end
+
+    p.stop
+  end
+
+  def test_resume_when_not_paused
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    p.start ; assert !p.paused?
+    p.resume; assert !p.paused?
+    p.stop  ; assert !p.paused?
+  end
+end

data/test/line_number_test.rb

@@ -5,11 +5,9 @@ require File.expand_path('../test_helper', __FILE__)
 
 class LineNumbers
   def method1
-    3
   end
 
   def method2
-    3
     method1
   end
 
@@ -32,11 +30,11 @@ class LineNumbersTest < Test::Unit::TestCase
 
     method = methods[0]
     assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
-    assert_equal(27, method.line)
+    assert_equal(25, method.line)
 
     method = methods[1]
     assert_equal('LineNumbers#method2', method.full_name)
-    assert_equal(11, method.line)
+    assert_equal(10, method.line)
 
     method = methods[2]
     assert_equal('LineNumbers#method1', method.full_name)
@@ -64,10 +62,10 @@ class LineNumbersTest < Test::Unit::TestCase
 
     method = methods[1]
     assert_equal('LineNumbers#method3', method.full_name)
-    assert_equal(16, method.line)
+    assert_equal(14, method.line)
 
     method = methods[2]
     assert_equal('LineNumbersTest#test_c_function', method.full_name)
-    assert_equal(50, method.line)
+    assert_equal(48, method.line)
   end
 end

data/test/measure_cpu_time_test.rb

@@ -23,9 +23,6 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
       RubyProf::C1.hello
     end
 
-    printer = RubyProf::FlatPrinter.new(result)
-    printer.print
-
     # Length should be 3:
     #   MeasureCpuTimeTest#test_class_methods
     #   <Class::RubyProf::C1>#hello

data/test/multi_printer_test.rb

@@ -57,7 +57,6 @@ class MultiPrinterTest < Test::Unit::TestCase
 \s*</table>')
     assert graph =~ re
     display_time = $1.to_f
-    difference = (expected_time-display_time).abs
     assert_in_delta expected_time, display_time, 0.005
   end
 

data/test/pause_resume_test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class PauseResumeTest < Test::Unit::TestCase
+
+  # pause/resume in the same frame
+  def test_pause_resume_1
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+
+    p.start
+    method_1a
+
+    p.pause
+    method_1b
+
+    p.resume
+    method_1c
+
+    r= p.stop
+    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05)
+  end
+  def method_1a; sleep 0.2 end
+  def method_1b; sleep 1   end
+  def method_1c; sleep 0.4 end
+
+  # pause in parent frame, resume in child
+  def test_pause_resume_2
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+
+    p.start
+    method_2a
+
+    p.pause
+    sleep 0.5
+    method_2b(p)
+
+    r= p.stop
+    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_2$/}[0].total_time, 0.05)
+  end
+  def method_2a; sleep 0.2 end
+  def method_2b(p); sleep 0.5; p.resume; sleep 0.4 end
+
+  # pause in child frame, resume in parent
+  def test_pause_resume_3
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+
+    p.start
+    method_3a(p)
+
+    sleep 0.5
+    p.resume
+    method_3b
+
+    r= p.stop
+    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_3$/}[0].total_time, 0.05)
+  end
+  def method_3a(p); sleep 0.2; p.pause; sleep 0.5 end
+  def method_3b; sleep 0.4 end
+end

data/test/pause_test.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class PauseTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_pause_resume
+    RubyProf.start
+    # Measured
+    RubyProf::C1.hello
+    RubyProf.pause
+
+    # Not measured
+    RubyProf::C1.hello
+
+    RubyProf.resume
+    # Measured
+    RubyProf::C1.hello
+    result = RubyProf.stop
+
+    printer = RubyProf::FlatPrinter.new(result)
+    printer.print
+
+    # Length should be 3:
+    #   PauseTest#test_pause_resume
+    #   <Class::RubyProf::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('PauseTest#test_pause_resume', methods[0].full_name)
+    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+
+  end
+
+end

data/test/prime.rb

@@ -51,5 +51,5 @@ def run_primes(length=10, maxnum=1000)
   primes = find_primes(random_array)
 
   # Find the largest primes
-  # largest = find_largest(primes)
+  largest = find_largest(primes)
 end

data/test/prime_test.rb

@@ -6,7 +6,7 @@ require File.expand_path('../test_helper', __FILE__)
 # --  Tests ----
 class PrimeTest< Test::Unit::TestCase
   def test_consistency
-    result = RubyProf.profile do
+    RubyProf.profile do
       run_primes
     end
   end

data/test/recursive_test.rb

@@ -50,9 +50,10 @@ class RecursiveTest < Test::Unit::TestCase
       method.full_name.match(/Fixnum/)
     end
 
-    assert_equal(3, methods.length) # which don't show up in 1.9
+    assert_equal(3, methods.length)
 
     # Method 0: RecursiveTest#test_simple
+    methods.sort!.reverse!
     method = methods[0]
     assert_equal('RecursiveTest#test_simple', method.full_name)
     assert_equal(1, method.called)
@@ -79,16 +80,12 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(2, method.call_infos.length)
 
     call_info = method.call_infos.first
-    if RUBY_VERSION < '1.9'
-      assert_equal(4, call_info.children.length)
-    else
-      assert_equal(2, call_info.children.length)
-    end
+    assert_equal(2 + (RUBY_VERSION < '1.9.0' ? 2 : 0), call_info.children.length)
     assert_equal('RecursiveTest#test_simple->Object#simple', call_info.call_sequence)
     assert(!call_info.recursive)
 
     call_info = method.call_infos.last
-    assert_equal(1, call_info.children.length)
+    assert_equal(1 + (RUBY_VERSION < '1.9.0' ? 2 : 0), call_info.children.length)
     assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple', call_info.call_sequence)
     assert(call_info.recursive)
 
@@ -112,6 +109,7 @@ class RecursiveTest < Test::Unit::TestCase
     assert(!call_info.recursive)
 
     if RUBY_VERSION < '1.9'
+      methods = result.threads.first.methods.dup.sort!.reverse!
       method = methods[3]
       assert_equal('Fixnum#-', method.full_name)
       assert_equal(2, method.called)
@@ -207,7 +205,7 @@ class RecursiveTest < Test::Unit::TestCase
 
     call_info = method.call_infos[1]
     assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Integer#times', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(1 + (RUBY_VERSION < '1.9.0' ? 1 : 0), call_info.children.length)
     assert(call_info.recursive)
 
     method = methods[3]
@@ -221,17 +219,17 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(3, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial', call_info.call_sequence)
-    assert_equal(3, call_info.children.length)
+    assert_equal(3 + (RUBY_VERSION < '1.9.0' ? 1 : 0), call_info.children.length)
     assert(!call_info.recursive)
 
     call_info = method.call_infos[1]
     assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Object#render_partial', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(1 + (RUBY_VERSION < '1.9.0' ? 1 : 0), call_info.children.length)
     assert(call_info.recursive)
 
     call_info = method.call_infos[2]
     assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Integer#times->Object#render_partial', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(1 + (RUBY_VERSION < '1.9.0' ? 1 : 0), call_info.children.length)
     assert(call_info.recursive)
 
     method = methods[4]

data/test/test_suite.rb

@@ -24,6 +24,7 @@ require File.expand_path("../test_helper", __FILE__)
    module_test
    multi_printer_test
    no_method_class_test
+   pause_test
    prime_test
    printers_test
    recursive_test
@@ -34,5 +35,4 @@ require File.expand_path("../test_helper", __FILE__)
    thread_test
    unique_call_path_test).each do |test|
   require File.expand_path("../#{test}", __FILE__)
-end
-
+end

data/test/thread_test.rb

@@ -25,14 +25,14 @@ class ThreadTest < Test::Unit::TestCase
 
   def test_thread_identity
     RubyProf.start
-    thread = Thread.new do
+    sleep_thread = Thread.new do
       sleep(1)
     end
-    thread.join
+    sleep_thread.join
     result = RubyProf.stop
 
     thread_ids = result.threads.map {|thread| thread.id}.sort
-    threads = [Thread.current, thread]
+    threads = [Thread.current, sleep_thread]
     assert_equal(2, result.threads.length)
 
     assert(thread_ids.include?(threads[0].object_id))
@@ -164,9 +164,9 @@ class ThreadTest < Test::Unit::TestCase
   end
 
   def test_thread
-    result = RubyProf.profile do
+    RubyProf.profile do
       begin
-        status = Timeout::timeout(2) do
+        Timeout::timeout(2) do
           while true
             next
           end

data/test/unique_call_path_test.rb

@@ -17,7 +17,6 @@ class UniqueCallPath
   end
 
   def method_c
-    c = 3
   end
 
   def method_k(i)

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ruby-prof
 version: !ruby/object:Gem::Version
-  version: 0.11.0.rc3
-  prerelease: 7
+  version: 0.11.2
+  prerelease: 
 platform: ruby
 authors:
 - Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-26 00:00:00.000000000 Z
+date: 2012-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -137,6 +137,8 @@ files:
 - test/module_test.rb
 - test/multi_printer_test.rb
 - test/no_method_class_test.rb
+- test/pause_resume_test.rb
+- test/pause_test.rb
 - test/prime.rb
 - test/prime_test.rb
 - test/printers_test.rb
@@ -145,7 +147,6 @@ files:
 - test/stack_printer_test.rb
 - test/stack_test.rb
 - test/start_stop_test.rb
-- test/summarize_test.rb
 - test/test_helper.rb
 - test/test_suite.rb
 - test/thread_test.rb
@@ -165,12 +166,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Fast Ruby profiler

data/test/summarize_test.rb

@@ -1,48 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-def slow
-  sleep(3)
-end
-
-def fast
-  sleep(3)
-end
-
-def slow_caller
-  1.times do
-    slow
-  end
-end
-
-def fast_caller
-  1.times do
-    fast
-  end
-end
-
-def parent
-  [1..10].each do
-  #slow_caller
-  fast_caller
-    end
-end
-
-class SummarizeTest < Test::Unit::TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def test
-    result = RubyProf::Profile.profile do
-      parent
-    end
-
-    printer = RubyProf::GraphPrinter.new(result)
-    printer.print(STDOUT)
-
-  end
-end