ruby-prof 0.16.2 → 0.17.0

data/ext/ruby_prof/rp_method.h

@@ -16,18 +16,39 @@ typedef struct
     st_index_t key;                         /* Cache calculated key */
 } prof_method_key_t;
 
+/* Source relation bit offsets. */
+enum {
+    kModuleIncludee = 0,                    /* Included module */
+    kModuleSingleton,                       /* Singleton class of a module */
+    kObjectSingleton                        /* Singleton class of an object */
+};
 
 /* Forward declaration, see rp_call_info.h */
 struct prof_call_infos_t;
 
 /* Profiling information for each method. */
-typedef struct 
+/* Excluded methods have no call_infos, source_klass, or source_file. */
+typedef struct
 {
-    prof_method_key_t *key;                 /* Method key */
-    const char *source_file;                /* The method's source file */
-    int line;                               /* The method's line number. */
-    struct prof_call_infos_t *call_infos;   /* Call info objects for this method */
+    /* Hot */
+
+    prof_method_key_t *key;                 /* Table key */
+
+    struct prof_call_infos_t *call_infos;   /* Call infos */
+    int visits;                             /* Current visits on the stack */
+
+    unsigned int excluded : 1;              /* Exclude from profile? */
+    unsigned int recursive : 1;             /* Recursive (direct or mutual)? */
+
+    /* Cold */
+
     VALUE object;                           /* Cached ruby object */
+    VALUE source_klass;                     /* Source class */
+    const char *source_file;                /* Source file */
+    int line;                               /* Line number */
+
+    unsigned int resolved : 1;              /* Source resolved? */
+    unsigned int relation : 3;              /* Source relation bits */
 } prof_method_t;
 
 void rp_init_method_info(void);
@@ -40,6 +61,8 @@ size_t method_table_insert(st_table *table, const prof_method_key_t *key, prof_m
 void method_table_free(st_table *table);
 
 prof_method_t* prof_method_create(VALUE klass, ID mid, const char* source_file, int line);
+prof_method_t* prof_method_create_excluded(VALUE klass, ID mid);
+
 VALUE prof_method_wrap(prof_method_t *result);
 void prof_method_mark(prof_method_t *method);
 

data/ext/ruby_prof/rp_stack.c

@@ -43,13 +43,15 @@ prof_stack_free(prof_stack_t *stack)
 }
 
 prof_frame_t *
-prof_stack_push(prof_stack_t *stack, double measurement)
+prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measurement, int paused)
 {
-  prof_frame_t* result = NULL;
+  prof_frame_t *result;
+  prof_frame_t* parent_frame;
+  prof_method_t *method;
 
   /* Is there space on the stack?  If not, double
      its size. */
-  if (stack->ptr == stack->end  )   
+  if (stack->ptr == stack->end)
   {
     size_t len = stack->ptr - stack->start;
     size_t new_capacity = (stack->end - stack->start) * 2;
@@ -59,17 +61,42 @@ prof_stack_push(prof_stack_t *stack, double measurement)
     stack->end = stack->start + new_capacity;
   }
 
-  // Setup returned stack pointer to be valid
-  result = stack->ptr;
-  result->child_time = 0;
+  parent_frame = prof_stack_peek(stack);
+
+  // Reserve the next available frame pointer.
+  result = stack->ptr++;
+
+  result->call_info = call_info;
+  result->call_info->depth = (int)(stack->ptr - stack->start); // shortening of 64 bit into 32;
+  result->passes = 0;
+
+  result->start_time = measurement;
+  result->pause_time = -1; // init as not paused.
   result->switch_time = 0;
   result->wait_time = 0;
+  result->child_time = 0;
   result->dead_time = 0;
-  result->depth = (int)(stack->ptr - stack->start); // shortening of 64 bit into 32
-  result->start_time = measurement;
 
-  // Increment the stack ptr for next time
-  stack->ptr++;
+  method = call_info->target;
+
+  /* If the method was visited previously, it's recursive. */
+  if (method->visits > 0)
+  {
+    method->recursive = 1;
+    call_info->recursive = 1;
+  }
+  /* Enter the method. */
+  method->visits++;
+
+  // Unpause the parent frame, if it exists.
+  // If currently paused then:
+  //   1) The child frame will begin paused.
+  //   2) The parent will inherit the child's dead time.
+  prof_frame_unpause(parent_frame, measurement);
+
+  if (paused) {
+    prof_frame_pause(result, measurement);
+  }
 
   // Return the result
   return result;
@@ -78,21 +105,33 @@ prof_stack_push(prof_stack_t *stack, double measurement)
 prof_frame_t *
 prof_stack_pop(prof_stack_t *stack, double measurement)
 {
-  prof_frame_t *frame = NULL;
-  prof_frame_t* parent_frame = NULL;
+  prof_frame_t *frame;
+  prof_frame_t *parent_frame;
   prof_call_info_t *call_info;
+  prof_method_t *method;
 
   double total_time;
   double self_time;
 
-  /* 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 (RubyProf is
-     not notified of that by the ruby runtime. */
-  if (stack->ptr == stack->start)
+  frame = prof_stack_peek(stack);
+
+  /* Frame can be null, which means the stack is empty.  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
+     (RubyProf is not notified of that by the ruby runtime. */
+  if (!frame) {
     return NULL;
-  
-  frame = --stack->ptr;
+  }
+
+  /* Match passes until we reach the frame itself. */
+  if (prof_frame_is_pass(frame)) {
+    frame->passes--;
+    /* Additional frames can be consumed. See pop_frames(). */
+    return frame;
+  }
+
+  /* Consume this frame. */
+  stack->ptr--;
 
   /* Calculate the total time this method took */
   prof_frame_unpause(frame, measurement);
@@ -101,11 +140,16 @@ prof_stack_pop(prof_stack_t *stack, double measurement)
 
   /* Update information about the current method */
   call_info = frame->call_info;
+  method = call_info->target;
+
   call_info->called++;
   call_info->total_time += total_time;
   call_info->self_time += self_time;
   call_info->wait_time += frame->wait_time;
 
+  /* Leave the method. */
+  method->visits--;
+
   parent_frame = prof_stack_peek(stack);
   if (parent_frame)
   {
@@ -119,10 +163,11 @@ prof_stack_pop(prof_stack_t *stack, double measurement)
 }
 
 prof_frame_t *
-prof_stack_peek(prof_stack_t *stack)
+prof_stack_pass(prof_stack_t *stack)
 {
-    if (stack->ptr == stack->start)
-      return NULL;
-    else
-      return stack->ptr - 1;
+  prof_frame_t *frame = prof_stack_peek(stack);
+  if (frame) {
+    frame->passes++;
+  }
+  return frame;
 }

data/ext/ruby_prof/rp_stack.h

@@ -13,39 +13,51 @@
 /* Temporary object that maintains profiling information
    for active methods.  They are created and destroyed
    as the program moves up and down its stack. */
-typedef struct 
+typedef struct
 {
     /* Caching prof_method_t values significantly
        increases performance. */
     prof_call_info_t *call_info;
+
+    unsigned int line;
+    unsigned int passes; /* Count of "pass" frames, _after_ this one. */
+
     double start_time;
     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 prof_frame_is_real(f) ((f)->passes == 0)
+#define prof_frame_is_pass(f) ((f)->passes > 0)
+
 #define prof_frame_is_paused(f) (f->pause_time >= 0)
 #define prof_frame_is_unpaused(f) (f->pause_time < 0)
+
 void prof_frame_pause(prof_frame_t*, double current_measurement);
 void prof_frame_unpause(prof_frame_t*, double current_measurement);
 
-
 /* Current stack of active methods.*/
-typedef struct 
+typedef struct
 {
     prof_frame_t *start;
     prof_frame_t *end;
     prof_frame_t *ptr;
 } prof_stack_t;
 
-prof_stack_t * prof_stack_create();
+prof_stack_t *prof_stack_create();
 void prof_stack_free(prof_stack_t *stack);
-prof_frame_t * prof_stack_push(prof_stack_t *stack, double measurement);
-prof_frame_t * prof_stack_pop(prof_stack_t *stack, double measurement);
-prof_frame_t * prof_stack_peek(prof_stack_t *stack);
+
+prof_frame_t *prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measurement, int paused);
+prof_frame_t *prof_stack_pop(prof_stack_t *stack, double measurement);
+prof_frame_t *prof_stack_pass(prof_stack_t *stack);
+
+static inline prof_frame_t *
+prof_stack_peek(prof_stack_t *stack) {
+    return stack->ptr != stack->start ? stack->ptr - 1 : NULL;
+}
+
 
 #endif //__RP_STACK__

data/ext/ruby_prof/rp_thread.c

@@ -217,7 +217,10 @@ collect_methods(st_data_t key, st_data_t value, st_data_t result)
        We want to store the method info information into an array.*/
     VALUE methods = (VALUE) result;
     prof_method_t *method = (prof_method_t *) value;
-    rb_ary_push(methods, prof_method_wrap(method));
+
+    if (!method->excluded) {
+      rb_ary_push(methods, prof_method_wrap(method));
+    }
 
     return ST_CONTINUE;
 }

data/ext/ruby_prof/ruby_prof.c

@@ -28,6 +28,7 @@
 
 VALUE mProf;
 VALUE cProfile;
+VALUE cExcludeCommonMethods;
 
 static prof_profile_t*
 prof_get_profile(VALUE self)
@@ -70,6 +71,19 @@ get_event_name(rb_event_flag_t event)
   }
 }
 
+static int
+excludes_method(prof_method_key_t *key, prof_profile_t *profile)
+{
+  return (profile->exclude_methods_tbl &&
+    method_table_lookup(profile->exclude_methods_tbl, key) != NULL);
+}
+
+static void
+prof_exclude_common_methods(VALUE profile)
+{
+  rb_funcall(cExcludeCommonMethods, rb_intern("apply!"), 1, profile);
+}
+
 static prof_method_t*
 create_method(rb_event_flag_t event, VALUE klass, ID mid, const char* source_file, int line)
 {
@@ -83,24 +97,36 @@ create_method(rb_event_flag_t event, VALUE klass, ID mid, const char* source_fil
     return prof_method_create(klass, mid, source_file, line);
 }
 
-
 static prof_method_t*
-get_method(rb_event_flag_t event, VALUE klass, ID mid, thread_data_t* thread_data)
+get_method(rb_event_flag_t event, VALUE klass, ID mid, thread_data_t *thread_data, prof_profile_t *profile)
 {
     prof_method_key_t key;
     prof_method_t *method = NULL;
 
+    /* Probe the local table. */
     method_key(&key, klass, mid);
     method = method_table_lookup(thread_data->method_table, &key);
 
     if (!method)
     {
- 	  const char* source_file = rb_sourcefile();
-      int line = rb_sourceline();
+      /* Didn't find it; are we excluding it specifically? */
+      if (excludes_method(&key, profile)) {
+        /* We found a exclusion sentinel so propagate it into the thread's local hash table. */
+        /* TODO(nelgau): Is there a way to avoid this allocation completely so that all these
+           tables share the same exclusion method struct? The first attempt failed due to my
+           ignorance of the whims of the GC. */
+        method = prof_method_create_excluded(klass, mid);
+      } else {
+        /* This method has no entry for this thread/fiber and isn't specifically excluded. */
+        const char* source_file = rb_sourcefile();
+        int line = rb_sourceline();
+  	    method = create_method(event, klass, mid, source_file, line);
+      }
 
-	  method = create_method(event, klass, mid, source_file, line);
+      /* Insert the newly created method, or the exlcusion sentinel. */
       method_table_insert(thread_data->method_table, method->key, method);
     }
+
     return method;
 }
 
@@ -238,10 +264,11 @@ prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE kla
       /* Keep track of the current line number in this method.  When
          a new method is called, we know what line number it was
          called from. */
-
       if (frame)
       {
-        frame->line = rb_sourceline();
+        if (prof_frame_is_real(frame)) {
+          frame->line = rb_sourceline();
+        }
         break;
       }
 
@@ -252,10 +279,16 @@ prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE kla
     case RUBY_EVENT_CALL:
     case RUBY_EVENT_C_CALL:
     {
-        prof_call_info_t *call_info = NULL;
-        prof_method_t *method = NULL;
+        prof_frame_t *next_frame;
+        prof_call_info_t *call_info;
+        prof_method_t *method;
 
-        method = get_method(event, klass, mid, thread_data);
+        method = get_method(event, klass, mid, thread_data, profile);
+
+        if (method->excluded) {
+          prof_stack_pass(thread_data->stack);
+          break;
+        }
 
         if (!frame)
         {
@@ -274,26 +307,18 @@ prof_event_hook(rb_event_flag_t event, VALUE data, 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.
-          prof_frame_unpause(frame, measurement);
         }
 
         /* Push a new frame onto the stack for a new c-call or ruby call (into a method) */
-        frame = prof_stack_push(thread_data->stack, measurement);
-        frame->call_info = call_info;
-		frame->call_info->depth = frame->depth;
-        frame->pause_time = profile->paused == Qtrue ? measurement : -1;
-        frame->line = rb_sourceline();
+        next_frame = prof_stack_push(thread_data->stack, call_info, measurement, RTEST(profile->paused));
+        next_frame->line = rb_sourceline();
         break;
     }
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_C_RETURN:
     {
-	  prof_stack_pop(thread_data->stack, measurement);
-      break;
+        prof_stack_pop(thread_data->stack, measurement);
+        break;
     }
   }
 }
@@ -307,10 +332,19 @@ prof_install_hook(VALUE self)
           RUBY_EVENT_LINE, self);
 }
 
+#ifdef HAVE_RB_REMOVE_EVENT_HOOK_WITH_DATA
+extern int
+rb_remove_event_hook_with_data(rb_event_hook_func_t func, VALUE data);
+#endif
+
 void
-prof_remove_hook()
+prof_remove_hook(VALUE self)
 {
+#ifdef HAVE_RB_REMOVE_EVENT_HOOK_WITH_DATA
+    rb_remove_event_hook_with_data(prof_event_hook, self);
+#else
     rb_remove_event_hook(prof_event_hook);
+#endif
 }
 
 static int
@@ -331,10 +365,19 @@ mark_threads(st_data_t key, st_data_t value, st_data_t result)
     return ST_CONTINUE;
 }
 
+static int
+mark_methods(st_data_t key, st_data_t value, st_data_t result)
+{
+    prof_method_t *method = (prof_method_t *) value;
+    prof_method_mark(method);
+    return ST_CONTINUE;
+}
+
 static void
 prof_mark(prof_profile_t *profile)
 {
     st_foreach(profile->threads_tbl, mark_threads, 0);
+    st_foreach(profile->exclude_methods_tbl, mark_methods, 0);
 }
 
 /* Freeing the profile creates a cascade of freeing.
@@ -358,6 +401,10 @@ prof_free(prof_profile_t *profile)
         profile->include_threads_tbl = NULL;
     }
 
+    /* This table owns the excluded sentinels for now. */
+    method_table_free(profile->exclude_methods_tbl);
+    profile->exclude_methods_tbl = NULL;
+
     xfree(profile->measurer);
     profile->measurer = NULL;
 
@@ -375,6 +422,8 @@ prof_allocate(VALUE klass)
     profile->include_threads_tbl = NULL;
     profile->running = Qfalse;
     profile->merge_fibers = 0;
+    profile->exclude_methods_tbl = method_table_create();
+    profile->running = Qfalse;
     return result;
 }
 
@@ -401,6 +450,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
     VALUE exclude_threads = Qnil;
     VALUE include_threads = Qnil;
     VALUE merge_fibers = Qnil;
+    VALUE exclude_common = Qnil;
     int i;
 
     switch (rb_scan_args(argc, argv, "02", &mode_or_options, &exclude_threads)) {
@@ -414,6 +464,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
             Check_Type(mode_or_options, T_HASH);
             mode = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("measure_mode")));
             merge_fibers = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("merge_fibers")));
+            exclude_common = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_common")));
             exclude_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_threads")));
             include_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("include_threads")));
         }
@@ -453,6 +504,10 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
         }
     }
 
+    if (RTEST(exclude_common)) {
+        prof_exclude_common_methods(self);
+    }
+
     return self;
 }
 
@@ -581,11 +636,11 @@ prof_stop(VALUE self)
     {
         rb_raise(rb_eRuntimeError, "RubyProf.start was not yet called");
     }
-  
-    prof_remove_hook();
+
+    prof_remove_hook(self);
 
     /* close trace file if open */
-    if (trace_file != NULL) 
+    if (trace_file != NULL)
     {
       if (trace_file !=stderr && trace_file != stdout)
       {
@@ -597,7 +652,7 @@ prof_stop(VALUE self)
       }
       trace_file = NULL;
     }
-    
+
     prof_pop_threads(profile);
 
     /* Unset the last_thread_data (very important!)
@@ -605,12 +660,23 @@ prof_stop(VALUE self)
     profile->running = profile->paused = Qfalse;
     profile->last_thread_data = NULL;
 
-    /* Post process result */
-    rb_funcall(self, rb_intern("post_process") , 0);
-
     return self;
 }
 
+/* call-seq:
+   threads -> Array of RubyProf::Thread
+
+Returns an array of RubyProf::Thread instances that were executed
+while the the program was being run. */
+static VALUE
+prof_threads(VALUE self)
+{
+    VALUE result = rb_ary_new();
+    prof_profile_t* profile = prof_get_profile(self);
+    st_foreach(profile->threads_tbl, collect_threads, result);
+    return result;
+}
+
 /* call-seq:
    profile(&block) -> self
    profile(options, &block) -> self
@@ -619,7 +685,7 @@ Profiles the specified block and returns a RubyProf::Profile
 object. Arguments are passed to Profile initialize method.
 */
 static VALUE
-prof_profile(int argc,  VALUE *argv, VALUE klass)
+prof_profile_class(int argc,  VALUE *argv, VALUE klass)
 {
     int result;
     VALUE profile = rb_class_new_instance(argc, argv, cProfile);
@@ -635,17 +701,47 @@ prof_profile(int argc,  VALUE *argv, VALUE klass)
 }
 
 /* call-seq:
-   threads -> array of RubyProf::Thread
+   profile {block} -> RubyProf::Result
 
-Returns an array of RubyProf::Thread instances that were executed
-while the the program was being run. */
+Profiles the specified block and returns a RubyProf::Result object. */
 static VALUE
-prof_threads(VALUE self)
+prof_profile_object(VALUE self)
+{
+    int result;
+    if (!rb_block_given_p())
+    {
+        rb_raise(rb_eArgError, "A block must be provided to the profile method.");
+    }
+
+    prof_start(self);
+    rb_protect(rb_yield, self, &result);
+    return prof_stop(self);
+
+}
+
+static VALUE
+prof_exclude_method(VALUE self, VALUE klass, VALUE sym)
 {
-    VALUE result = rb_ary_new();
     prof_profile_t* profile = prof_get_profile(self);
-    st_foreach(profile->threads_tbl, collect_threads, result);
-    return result;
+    ID mid = SYM2ID(sym);
+
+    prof_method_key_t key;
+    prof_method_t *method;
+
+    if (profile->running == Qtrue)
+    {
+        rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
+    }
+
+    method_key(&key, klass, mid);
+    method = method_table_lookup(profile->exclude_methods_tbl, &key);
+
+    if (!method) {
+      method = prof_method_create_excluded(klass, mid);
+      method_table_insert(profile->exclude_methods_tbl, method->key, method);
+    }
+
+    return self;
 }
 
 void Init_ruby_prof()
@@ -658,8 +754,8 @@ void Init_ruby_prof()
     rp_init_thread();
 
     cProfile = rb_define_class_under(mProf, "Profile", rb_cObject);
-    rb_define_singleton_method(cProfile, "profile", prof_profile, -1);
     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, "stop", prof_stop, 0);
@@ -668,4 +764,11 @@ void Init_ruby_prof()
     rb_define_method(cProfile, "running?", prof_running, 0);
     rb_define_method(cProfile, "paused?", prof_paused, 0);
     rb_define_method(cProfile, "threads", prof_threads, 0);
+
+    rb_define_singleton_method(cProfile, "profile", prof_profile_class, -1);
+    rb_define_method(cProfile, "profile", prof_profile_object, 0);
+
+    rb_define_method(cProfile, "exclude_method!", prof_exclude_method, 2);
+
+    cExcludeCommonMethods = rb_define_class_under(cProfile, "ExcludeCommonMethods", rb_cObject);
 }