ruby-prof 0.11.0.rc1-x86-mingw32 → 0.11.0.rc2-x86-mingw32

data/CHANGES

@@ -1,13 +1,28 @@
+0.11.0.rc2 (2012-03-25)
+======================
+* Lots of improvements to Rack handler - this can be used to profile requests
+  in Rails and other rack-based ruby web frameworks (Charlie Savage).
+* Reimplemented handling of recursive calls using CallInfoVisitor (Charlie Savage).
+* Fix bug where child times were not correctly reported in complicated
+  call graphs with recursion like in frameworks like Rails (Charlie Savage).
+* Add in recursive call information to Flat, Graph and Graph HTML reports (Charlie Savage).
+* Add in new thread class add added RubyProf::Thread#top_method to
+  make report generation easier (Charlie Savage).
+* Add in CallInfoVisitor class to make it easy to iterate over a call graph (Charlie Savage).
+* Add in CallInfoPrinter to make it visualize RubyProf's internal call graphs (Charlie Savage).
+* Significant updates to documentation (Charlie Savage).
+* More c code cleanup (Charlie Savage).
+
 0.11.0.rc1 (2012-03-24)
 ======================
+* Big internal refactoring of C code to make RubyProf easier to understand and extend (Charlie Savage).
+* Profile results are now returned as instances of a new class RubyProf::Profile.  The old api
+  is supported via a compatability layer that at some point will be deprecated.  (Charlie Savage).
 * On Windows, use QueryPerformanceCounter and QueryPerformanceFrequency to measure CPU time instead
   of rdtsc.  This change is based on Microsoft's recommendation (Charlie Savage).
 * On Windows use GetProcessTimes to return real PROCESS_TIME times instead of wall times (Charlie Savage).
-* Big internal refactoring of C code to make RubyProf easier to understand and extend (Charlie Savage).
-* Profile results are now returned as instances of a new class RubyProf::Profile.  The old api 
-  is supported via a compatability layer that at some point will be deprecated.  (Charlie Savage).
-* Split out tests for cpu_time, process_time and wall_time into separate files (Charlie Savage).
-* Dropped support for Ruby 1.8.4 and 1.8.6 - does anybody still use these? (Charlie Savage).
+* Split out tests for each time of measurement (cpu_time, process_time, etc.) (Charlie Savage).
+* Dropped support for Ruby 1.8.4 and 1.8.6 and 1.9.0 (Charlie Savage).
 * Added support for sorting results by total, self, wait and child times (Jan Suchal)
 * Added tests for sorting behaviour & removed options from constructor to print method (Jan Suchal)
 * Fix line number tests due to changes at top of file (Charlie Savage).

data/README.rdoc

@@ -187,9 +187,16 @@ So to profile Rails:
 
 1.  Create a new profile.rb environment.  Make sure to turn on cache_classes
 and cache_template_loading.  Otherwise your profiling results will be
-overwhelemed by the time Rails spends loading required files.
+overwhelemed by the time Rails spends loading required files.  You should
+likely turn off caching.
 
-2.  Add the ruby prof rack adapter to your middleware stack.  One way to
+2.  Add the ruby-prof to your gemfile:
+
+  group :profile do
+    gem 'ruby-prof'
+  end
+
+3.  Add the ruby prof rack adapter to your middleware stack.  One way to
 do this is by adding the following code to config.ru:
 
   if Rails.env.profile?
@@ -199,7 +206,7 @@ do this is by adding the following code to config.ru:
 The path is where you want profiling results to be stored.  By default the
 rack adapter will generate a html call graph report and flat text report.
 
-3.  Now make a request to your running server.  New profiling information will
+4.  Now make a request to your running server.  New profiling information will
 be generated for each request.  Note that each request will overwrite
 the profiling reports created by the previous request!
 

data/ext/ruby_prof/rp_call_info.c

@@ -7,45 +7,13 @@
 
 VALUE cCallInfo;
 
-/* =======  Call Info   ========*/
-st_table *
-call_info_table_create()
-{
-  return st_init_table(&type_method_hash);
-}
-
-size_t
-call_info_table_insert(st_table *table, const prof_method_key_t *key, prof_call_info_t *val)
-{
-  return st_insert(table, (st_data_t) key, (st_data_t) val);
-}
-
-prof_call_info_t *
-call_info_table_lookup(st_table *table, const prof_method_key_t *key)
-{
-    st_data_t val;
-    if (st_lookup(table, (st_data_t) key, &val))
-    {
-      return (prof_call_info_t *) val;
-    }
-    else
-    {
-      return NULL;
-    }
-}
 
-static void
-call_info_table_free(st_table *table)
-{
-    st_free_table(table);
-}
+// Forward declarations
+st_table * call_info_table_create();
+void call_info_table_free(st_table *table);
 
-/* Document-class: RubyProf::CallInfo
-RubyProf::CallInfo is a helper class used by RubyProf::MethodInfo
-to keep track of which child methods were called and how long
-they took to execute. */
 
-/* :nodoc: */
+/* =======  prof_call_info_t   ========*/
 prof_call_info_t *
 prof_call_info_create(prof_method_t* method, prof_call_info_t* parent)
 {
@@ -65,35 +33,33 @@ prof_call_info_create(prof_method_t* method, prof_call_info_t* parent)
 }
 
 static void
-prof_call_info_mark(prof_call_info_t *call_info)
+prof_call_info_free(prof_call_info_t *call_info)
 {
-  {
-    VALUE target = call_info->target->object;
-    if (NIL_P(target))
-      prof_method_mark(call_info->target);
-    else
-      rb_gc_mark(target);
-  }
-  rb_gc_mark(call_info->children);
-  if (call_info->parent) {
-    VALUE parent = call_info->parent->object;
-    if (NIL_P(parent)) {
-      prof_call_info_mark(call_info->parent);
+	/* Has this thread object been accessed by Ruby?  If
+	   yes clean it up so to avoid a segmentation fault. */
+	if (call_info->object != Qnil)
+	{
+		RDATA(call_info->object)->data = NULL;
+		RDATA(call_info->object)->dfree = NULL;
+		RDATA(call_info->object)->dmark = NULL;
     }
-    else {
-      rb_gc_mark(parent);
-    }
-  }
+	call_info->object = Qnil;
+
+	call_info_table_free(call_info->call_infos);
+	xfree(call_info);
 }
 
 static void
-prof_call_info_free(prof_call_info_t *call_info)
+prof_call_info_mark(prof_call_info_t *call_info)
 {
-  call_info_table_free(call_info->call_infos);
-  xfree(call_info);
+	if (call_info->object)
+		rb_gc_mark(call_info->children);
+
+	if (call_info->children)
+		rb_gc_mark(call_info->children);
 }
 
-static VALUE
+VALUE
 prof_call_info_wrap(prof_call_info_t *call_info)
 {
   if (call_info->object == Qnil)
@@ -104,17 +70,68 @@ prof_call_info_wrap(prof_call_info_t *call_info)
 }
 
 static prof_call_info_t *
-prof_get_call_info_result(VALUE obj)
+prof_get_call_info(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+	prof_call_info_t* result = DATA_PTR(self);
+
+	if (!result)
+	    rb_raise(rb_eRuntimeError, "This RubyProf::CallInfo instance has already been freed, likely because its profile has been freed.");
+
+   return result;
+}
+
+/* =======  Call Info Table   ========*/
+st_table *
+call_info_table_create()
+{
+  return st_init_table(&type_method_hash);
+}
+
+/*static int
+call_info_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
+{
+    prof_call_info_free((prof_call_info_t*)value);
+    return ST_CONTINUE;
+}*/
+
+void
+call_info_table_free(st_table *table)
+{
+  //st_foreach(table, call_info_table_free_iterator, 0);
+    st_free_table(table);
+}
+
+size_t
+call_info_table_insert(st_table *table, const prof_method_key_t *key, prof_call_info_t *val)
+{
+  return st_insert(table, (st_data_t) key, (st_data_t) val);
+}
+
+prof_call_info_t *
+call_info_table_lookup(st_table *table, const prof_method_key_t *key)
 {
-    if (BUILTIN_TYPE(obj) != T_DATA)
+    st_data_t val;
+    if (st_lookup(table, (st_data_t) key, &val))
     {
-        /* Should never happen */
-      rb_raise(rb_eTypeError, "Not a call info object");
+      return (prof_call_info_t *) val;
+    }
+    else
+    {
+      return NULL;
     }
-    return (prof_call_info_t *) DATA_PTR(obj);
 }
 
 
+/* =======  RubyProf::CallInfo   ========*/
+
+/* Document-class: RubyProf::CallInfo
+RubyProf::CallInfo is a helper class used by RubyProf::MethodInfo
+to keep track of which child methods were called and how long
+they took to execute. */
+
+
 /* call-seq:
    called -> MethodInfo
 
@@ -126,7 +143,7 @@ prof_call_info_target(VALUE self)
        about the GC.  We will wrap the method_info but provide no
        free method so the underlying object is not freed twice! */
 
-    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info(self);
     return prof_method_wrap(result->target);
 }
 
@@ -137,7 +154,7 @@ Returns the total amount of times this method was called. */
 static VALUE
 prof_call_info_called(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info(self);
     return INT2NUM(result->called);
 }
 
@@ -148,11 +165,22 @@ Sets the call count to n. */
 static VALUE
 prof_call_info_set_called(VALUE self, VALUE called)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info(self);
     result->called = NUM2INT(called);
     return called;
 }
 
+/* call-seq:
+   depth -> int
+
+   returns the depth of this call info in the call graph */
+static VALUE
+prof_call_info_depth(VALUE self)
+{
+  prof_call_info_t *result = prof_get_call_info(self);
+  return rb_int_new(result->depth);
+}
+
 /* call-seq:
    line_no -> int
 
@@ -160,7 +188,7 @@ prof_call_info_set_called(VALUE self, VALUE called)
 static VALUE
 prof_call_info_line(VALUE self)
 {
-  prof_call_info_t *result = prof_get_call_info_result(self);
+  prof_call_info_t *result = prof_get_call_info(self);
   return rb_int_new(result->line);
 }
 
@@ -171,7 +199,7 @@ Returns the total amount of time spent in this method and its children. */
 static VALUE
 prof_call_info_total_time(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info(self);
     return rb_float_new(result->total_time);
 }
 
@@ -182,8 +210,8 @@ adds total time time from call_info to self. */
 static VALUE
 prof_call_info_add_total_time(VALUE self, VALUE other)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
-    prof_call_info_t *other_info = prof_get_call_info_result(other);
+    prof_call_info_t *result = prof_get_call_info(self);
+    prof_call_info_t *other_info = prof_get_call_info(other);
 
     result->total_time += other_info->total_time;
     return Qnil;
@@ -196,7 +224,7 @@ Returns the total amount of time spent in this method. */
 static VALUE
 prof_call_info_self_time(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info(self);
 
     return rb_float_new(result->self_time);
 }
@@ -208,8 +236,8 @@ adds self time from call_info to self. */
 static VALUE
 prof_call_info_add_self_time(VALUE self, VALUE other)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
-    prof_call_info_t *other_info = prof_get_call_info_result(other);
+    prof_call_info_t *result = prof_get_call_info(self);
+    prof_call_info_t *other_info = prof_get_call_info(other);
 
     result->self_time += other_info->self_time;
     return Qnil;
@@ -222,7 +250,7 @@ Returns the total amount of time this method waited for other threads. */
 static VALUE
 prof_call_info_wait_time(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info(self);
 
     return rb_float_new(result->wait_time);
 }
@@ -235,8 +263,8 @@ adds wait time from call_info to self. */
 static VALUE
 prof_call_info_add_wait_time(VALUE self, VALUE other)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
-    prof_call_info_t *other_info = prof_get_call_info_result(other);
+    prof_call_info_t *result = prof_get_call_info(self);
+    prof_call_info_t *other_info = prof_get_call_info(other);
 
     result->wait_time += other_info->wait_time;
     return Qnil;
@@ -249,7 +277,7 @@ Returns the call_infos parent call_info object (the method that called this meth
 static VALUE
 prof_call_info_parent(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info(self);
     if (result->parent)
       return prof_call_info_wrap(result->parent);
     else
@@ -263,11 +291,11 @@ Changes the parent of self to new_parent and returns it.*/
 static VALUE
 prof_call_info_set_parent(VALUE self, VALUE new_parent)
 {
-    prof_call_info_t *result = prof_get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info(self);
     if (new_parent == Qnil)
       result->parent = NULL;
     else
-      result->parent = prof_get_call_info_result(new_parent);
+      result->parent = prof_get_call_info(new_parent);
     return prof_call_info_parent(self);
 }
 
@@ -288,7 +316,7 @@ called (ie, children).*/
 static VALUE
 prof_call_info_children(VALUE self)
 {
-    prof_call_info_t *call_info = prof_get_call_info_result(self);
+    prof_call_info_t *call_info = prof_get_call_info(self);
     if (call_info->children == Qnil)
     {
       call_info->children = rb_ary_new();
@@ -365,5 +393,6 @@ void rp_init_call_info()
     rb_define_method(cCallInfo, "add_self_time", prof_call_info_add_self_time, 1);
     rb_define_method(cCallInfo, "wait_time", prof_call_info_wait_time, 0);
     rb_define_method(cCallInfo, "add_wait_time", prof_call_info_add_wait_time, 1);
+    rb_define_method(cCallInfo, "depth", prof_call_info_depth, 0);
     rb_define_method(cCallInfo, "line", prof_call_info_line, 0);
 }

data/ext/ruby_prof/rp_call_info.h

@@ -16,6 +16,7 @@ typedef struct prof_call_info_t
     struct prof_call_info_t *parent;
     st_table *call_infos;
     int called;
+	int depth;
     double total_time;
     double self_time;
     double wait_time;

data/ext/ruby_prof/rp_measure_cpu_time.c

@@ -1,112 +1,112 @@
-/* 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 */
-
-#include "ruby_prof.h"
-
-static VALUE cMeasureCpuTime;
-
-static unsigned long long cpu_frequency = 0;
-
-/* The _WIN32 check is needed for msys (and maybe cygwin?) */
-#if defined(__GNUC__) && !defined(_WIN32)
-
-#include <stdint.h>
-#include <time.h>
-
-static unsigned long long get_cpu_time()
-{
-#if defined(__i386__) || defined(__x86_64__)
-    uint32_t a, d;
-    __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));
-   return ((uint64_t)d << 32) + a;
-#elif defined(__powerpc__) || defined(__ppc__)
-    unsigned long long x, y;
-
-    __asm__ __volatile__ ("\n\
-1:      mftbu   %1\n\
-  mftb    %L0\n\
-  mftbu   %0\n\
-  cmpw    %0,%1\n\
-  bne-    1b"
-  : "=r" (x), "=r" (y));
-   return x;
-#endif
-}
-
-static unsigned long long get_cpu_frequency()
-{
-    unsigned long long x, y;
-
-    struct timespec ts;
-    ts.tv_sec = 0;
-    ts.tv_nsec = 500000000;
-    x = get_cpu_time();
-    nanosleep(&ts, NULL);
-    y = get_cpu_time();
-    return (y - x) * 2;
-}
-
-#elif defined(_WIN32)
-
-static unsigned long long get_cpu_time()
-{
-	LARGE_INTEGER time;
-	QueryPerformanceCounter(&time);
-	return time.QuadPart;
-};
-
-static unsigned long long get_cpu_frequency()
-{
-	LARGE_INTEGER cpu_frequency;
-	QueryPerformanceFrequency(&cpu_frequency);
-	return cpu_frequency.QuadPart;
-};
-#endif
-
-static double
-measure_cpu_time()
-{
-    return ((double)get_cpu_time()) / cpu_frequency;
-}
-
-
-prof_measurer_t* prof_measurer_cpu_time()
-{
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_cpu_time;
-  return measure;
-}
-
-/* call-seq:
-   measure -> float
-
-Returns the cpu time.*/
-static VALUE
-prof_measure_cpu_time(VALUE self)
-{
-    return rb_float_new(measure_cpu_time());
-}
-
-/* call-seq:
-   cpu_frequency -> int
-
-Returns the cpu's frequency.  This value is needed when
-RubyProf::measure_mode is set to CPU_TIME. */
-static VALUE
-prof_get_cpu_frequency(VALUE self)
-{
-	return ULL2NUM(cpu_frequency);
-}
-
-void rp_init_measure_cpu_time()
-{
-    rb_define_const(mProf, "CPU_TIME", INT2NUM(MEASURE_CPU_TIME));
+/* 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 */
+
+#include "ruby_prof.h"
+
+static VALUE cMeasureCpuTime;
+
+static unsigned long long cpu_frequency = 0;
+
+/* The _WIN32 check is needed for msys (and maybe cygwin?) */
+#if defined(__GNUC__) && !defined(_WIN32)
+
+#include <stdint.h>
+#include <time.h>
+
+static unsigned long long get_cpu_time()
+{
+#if defined(__i386__) || defined(__x86_64__)
+    uint32_t a, d;
+    __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));
+   return ((uint64_t)d << 32) + a;
+#elif defined(__powerpc__) || defined(__ppc__)
+    unsigned long long x, y;
+
+    __asm__ __volatile__ ("\n\
+1:      mftbu   %1\n\
+  mftb    %L0\n\
+  mftbu   %0\n\
+  cmpw    %0,%1\n\
+  bne-    1b"
+  : "=r" (x), "=r" (y));
+   return x;
+#endif
+}
+
+static unsigned long long get_cpu_frequency()
+{
+    unsigned long long x, y;
+
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = 500000000;
+    x = get_cpu_time();
+    nanosleep(&ts, NULL);
+    y = get_cpu_time();
+    return (y - x) * 2;
+}
+
+#elif defined(_WIN32)
+
+static unsigned long long get_cpu_time()
+{
+	LARGE_INTEGER time;
+	QueryPerformanceCounter(&time);
+	return time.QuadPart;
+};
+
+static unsigned long long get_cpu_frequency()
+{
+	LARGE_INTEGER cpu_frequency;
+	QueryPerformanceFrequency(&cpu_frequency);
+	return cpu_frequency.QuadPart;
+};
+#endif
+
+static double
+measure_cpu_time()
+{
+    return ((double)get_cpu_time()) / cpu_frequency;
+}
+
+
+prof_measurer_t* prof_measurer_cpu_time()
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->measure = measure_cpu_time;
+  return measure;
+}
+
+/* call-seq:
+   measure -> float
+
+Returns the cpu time.*/
+static VALUE
+prof_measure_cpu_time(VALUE self)
+{
+    return rb_float_new(measure_cpu_time());
+}
+
+/* call-seq:
+   cpu_frequency -> int
+
+Returns the cpu's frequency.  This value is needed when
+RubyProf::measure_mode is set to CPU_TIME. */
+static VALUE
+prof_get_cpu_frequency(VALUE self)
+{
+	return ULL2NUM(cpu_frequency);
+}
+
+void rp_init_measure_cpu_time()
+{
+    rb_define_const(mProf, "CPU_TIME", INT2NUM(MEASURE_CPU_TIME));
 	rb_define_const(mProf, "CPU_TIME_ENABLED", Qtrue);
-
-    cMeasureCpuTime = rb_define_class_under(mMeasure, "CpuTime", rb_cObject);
-    rb_define_singleton_method(cMeasureCpuTime, "measure", prof_measure_cpu_time, 0);
-    rb_define_singleton_method(cMeasureCpuTime, "frequency", prof_get_cpu_frequency, 0);
-
-    /* Get cpu_frequency */
-    cpu_frequency = get_cpu_frequency();
-}
+
+    cMeasureCpuTime = rb_define_class_under(mMeasure, "CpuTime", rb_cObject);
+    rb_define_singleton_method(cMeasureCpuTime, "measure", prof_measure_cpu_time, 0);
+    rb_define_singleton_method(cMeasureCpuTime, "frequency", prof_get_cpu_frequency, 0);
+
+    /* Get cpu_frequency */
+    cpu_frequency = get_cpu_frequency();
+}