ruby-prof 0.13.1 → 0.14.0

data/ext/ruby_prof/extconf.rb

@@ -1,33 +1,32 @@
 require "mkmf"
 
-if RUBY_VERSION == "1.8.6"
-  STDERR.print("Ruby #{RUBY_VERSION} is no longer supported.  Please upgrade to 1.8.7 or 1.9.2 or higher\n")
-  exit(1)
-end
-
-if RUBY_VERSION == "1.9.0" or RUBY_VERSION == "1.9.1"
-  STDERR.print("Ruby #{RUBY_VERSION} is no longer supported.  Please upgrade to 1.9.2 or higher\n")
+if RUBY_VERSION < "1.9.3"
+  STDERR.puts("Ruby version #{RUBY_VERSION} is no longer supported. Please upgrade to 1.9.3 or higher")
   exit(1)
 end
 
 have_header("sys/times.h")
 
-# Stefan Kaes / Alexander Dymo GC patch
+# standard ruby methods
+have_func("rb_gc_stat")
+have_func("rb_gc_count")
+
+# Alexander Dymo GC patch
 have_func("rb_os_allocated_objects")
 have_func("rb_gc_allocated_size")
+
+# Stefan Kaes GC patches
 have_func("rb_gc_collections")
 have_func("rb_gc_time")
-
-# 1.9.3 superclass
-have_func("rb_class_superclass")
+# for ruby 2.1
+have_func("rb_gc_total_time")
+have_func("rb_gc_total_mallocs")
+have_func("rb_gc_total_malloced_bytes")
 
 # Lloyd Hilaiel's heap info patch
 have_func("rb_heap_total_mem")
 have_func("rb_gc_heap_info")
 
-# whether our ruby has fibers
-have_func("rb_fiber_current")
-
 def add_define(name, value = nil)
   if value
     $defs.push("-D#{name}=#{value}")
@@ -36,24 +35,23 @@ def add_define(name, value = nil)
   end
 end
 
-# if have_func("rb_gc_enable_stats")
-#   add_define("TOGGLE_GC_STATS", 1)
-# end
-
-require 'rubygems'
-unless Gem.win_platform? || RUBY_PLATFORM =~ /(darwin|openbsd)/
+if !Gem.win_platform? && RUBY_PLATFORM !~ /(darwin|openbsd)/
   $LDFLAGS += " -lrt" # for clock_gettime
 end
 add_define("RUBY_VERSION", RUBY_VERSION.gsub('.', ''))
 
-# for ruby 1.9, determine whether threads inherit trace flags (latest 1.9.2 works correctly)
+# for ruby 1.9, determine whether threads inherit trace flags (latest 1.9.2 and later should work correctly)
 if RUBY_VERSION > "1.9"
   require 'set'
   threads = Set.new
   set_trace_func lambda { |*args| threads << Thread.current.object_id }
   Thread.new{1}.join
   set_trace_func nil
-  add_define("THREADS_INHERIT_EVENT_FLAGS", (threads.size == 2) ? "1" : "0")
+  if threads.size < 2
+    # if we end up here, ruby does not automatically active tracing in spawned threads
+    STDERR.puts("Ruby #{RUBY_VERSION} does not activate tracing in spawned threads. Consider upgrading.")
+    exit(1)
+  end
 end
 
 create_makefile("ruby_prof")

data/ext/ruby_prof/rp_measure_allocations.c

@@ -11,8 +11,8 @@ static VALUE cMeasureAllocations;
   unsigned LONG_LONG rb_os_allocated_objects();
 #endif
 
-#if defined(HAVE_RB_GC_MALLOC_ALLOCATIONS)
-  unsigned LONG_LONG rb_gc_malloc_allocations();
+#if defined(HAVE_RB_GC_STAT)
+size_t rb_gc_stat(VALUE key);
 #endif
 
 static double
@@ -22,9 +22,13 @@ measure_allocations()
 #define MEASURE_ALLOCATIONS_ENABLED Qtrue
     return rb_os_allocated_objects();
 
-#elif defined(HAVE_RB_GC_MALLOC_ALLOCATIONS)
+#elif defined(HAVE_RB_GC_STAT) && RUBY_VERSION == 210
 #define MEASURE_ALLOCATIONS_ENABLED Qtrue
-    return rb_gc_malloc_allocations();
+    static VALUE total_alloc_symbol = 0;
+    if (!total_alloc_symbol) {
+      total_alloc_symbol = ID2SYM(rb_intern_const("total_allocated_object"));
+    }
+    return rb_gc_stat(total_alloc_symbol);
 
 #else
 #define MEASURE_ALLOCATIONS_ENABLED Qfalse
@@ -61,5 +65,5 @@ void rp_init_measure_allocations()
     rb_define_const(mProf, "ALLOCATIONS_ENABLED", MEASURE_ALLOCATIONS_ENABLED);
 
     cMeasureAllocations = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
-    rb_define_singleton_method(cMeasureAllocations, "measure", prof_measure_allocations, 0);    
+    rb_define_singleton_method(cMeasureAllocations, "measure", prof_measure_allocations, 0);
 }

data/ext/ruby_prof/rp_measure_gc_runs.c

@@ -11,6 +11,10 @@ static VALUE cMeasureGcRuns;
   VALUE rb_gc_collections(void);
 #endif
 
+#if defined(HAVE_RB_GC_COUNT)
+  size_t rb_gc_count(void);
+#endif
+
 #if defined(HAVE_RB_GC_HEAP_INFO)
   VALUE rb_gc_heap_info(void);
 #endif
@@ -23,6 +27,10 @@ measure_gc_runs()
 #define MEASURE_GC_RUNS_ENABLED Qtrue
   return NUM2INT(rb_gc_collections());
 
+#elif defined(HAVE_RB_GC_COUNT)
+#define MEASURE_GC_RUNS_ENABLED Qtrue
+  return rb_gc_count();
+
 #elif defined(HAVE_RB_GC_HEAP_INFO)
 #define MEASURE_GC_RUNS_ENABLED Qtrue
   VALUE h = rb_gc_heap_info();

data/ext/ruby_prof/rp_measure_gc_time.c

@@ -11,11 +11,14 @@ static VALUE cMeasureGcTimes;
   VALUE rb_gc_time();
 #endif
 
-
 static double
 measure_gc_time()
 {
-#if defined(HAVE_RB_GC_TIME)
+#if defined(HAVE_RB_GC_TOTAL_TIME)
+#define MEASURE_GC_TIME_ENABLED Qtrue
+    return rb_gc_total_time();
+
+#elif defined(HAVE_RB_GC_TIME)
 #define MEASURE_GC_TIME_ENABLED Qtrue
     const double conversion = 1000000.0;
 #if HAVE_LONG_LONG

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -3,6 +3,7 @@
 
 /* :nodoc: */
 #include "ruby_prof.h"
+#include <sys/time.h>
 
 static VALUE cMeasureWallTime;
 

data/ext/ruby_prof/rp_method.c

@@ -37,16 +37,7 @@ figure_singleton_name(VALUE klass)
         /* Make sure to get the super class so that we don't
            mistakenly grab a T_ICLASS which would lead to
            unknown method errors. */
-#ifdef HAVE_RB_CLASS_SUPERCLASS
-        // 1.9.3
         VALUE super = rb_class_superclass(klass);
-#else
-# ifdef RCLASS_SUPER
-        VALUE super = rb_class_real(RCLASS_SUPER(klass));
-# else
-        VALUE super = rb_class_real(RCLASS(klass)->super);
-# endif
-#endif
         result = rb_str_new2("<Object::");
         rb_str_append(result, rb_inspect(super));
         rb_str_cat2(result, ">");

data/ext/ruby_prof/rp_method.h

@@ -6,15 +6,10 @@
 
 #include <ruby.h>
 
-#ifndef RUBY_VM
-#include <st.h>
-typedef st_data_t st_index_t;
-#endif
-
 extern VALUE cMethodInfo;
 
 /* A key used to identify each method */
-typedef struct 
+typedef struct
 {
     VALUE klass;                            /* The method's class. */
     ID mid;                                 /* The method id. */

data/ext/ruby_prof/ruby_prof.c

@@ -29,12 +29,6 @@
 VALUE mProf;
 VALUE cProfile;
 
-#ifndef RUBY_VM
-/* Global variable to hold current profile - needed 
-   prior to Ruby 1.9 */
-static prof_profile_t* pCurrentProfile;
-#endif
-
 static prof_profile_t*
 prof_get_profile(VALUE self)
 {
@@ -50,35 +44,29 @@ prof_get_profile(VALUE self)
  */
 static FILE* trace_file = NULL;
 
-/* Copied from eval.c (1.8.x) / thread.c (1.9.2) */
+/* Copied from thread.c (1.9.3) */
 static const char *
 get_event_name(rb_event_flag_t event)
 {
   switch (event) {
-    case RUBY_EVENT_LINE:
-  return "line";
-    case RUBY_EVENT_CLASS:
-  return "class";
-    case RUBY_EVENT_END:
-  return "end";
-    case RUBY_EVENT_CALL:
-  return "call";
-    case RUBY_EVENT_RETURN:
-  return "return";
-    case RUBY_EVENT_C_CALL:
-  return "c-call";
-    case RUBY_EVENT_C_RETURN:
-  return "c-return";
-    case RUBY_EVENT_RAISE:
-  return "raise";
-
-#ifdef RUBY_VM
-    case RUBY_EVENT_SWITCH:
-  return "thread-interrupt";
-#endif
-
-    default:
-  return "unknown";
+  case RUBY_EVENT_LINE:
+    return "line";
+  case RUBY_EVENT_CLASS:
+    return "class";
+  case RUBY_EVENT_END:
+    return "end";
+  case RUBY_EVENT_CALL:
+    return "call";
+  case RUBY_EVENT_RETURN:
+    return "return";
+  case RUBY_EVENT_C_CALL:
+    return "c-call";
+  case RUBY_EVENT_C_RETURN:
+    return "c-return";
+  case RUBY_EVENT_RAISE:
+    return "raise";
+  default:
+    return "unknown";
   }
 }
 
@@ -97,11 +85,7 @@ create_method(rb_event_flag_t event, VALUE klass, ID mid, const char* source_fil
 
 
 static prof_method_t*
-#ifdef RUBY_VM
- get_method(rb_event_flag_t event, VALUE klass, ID mid, thread_data_t* thread_data)
-# else
- get_method(rb_event_flag_t event, NODE *node, VALUE klass, ID mid, thread_data_t* thread_data)
-#endif
+get_method(rb_event_flag_t event, VALUE klass, ID mid, thread_data_t* thread_data)
 {
     prof_method_key_t key;
     prof_method_t *method = NULL;
@@ -147,24 +131,15 @@ prof_pop_threads(prof_profile_t* profile)
 }
 
 /* ===========  Profiling ================= */
-#ifdef RUBY_VM
 static void
 prof_trace(prof_profile_t* profile, rb_event_flag_t event, ID mid, VALUE klass, double measurement)
-#else
-static void
-prof_trace(prof_profile_t* profile, rb_event_flag_t event, NODE *node, ID mid, VALUE klass, double measurement)
-#endif
 {
     static VALUE last_fiber_id = Qnil;
 
     VALUE thread = rb_thread_current();
     VALUE thread_id = rb_obj_id(thread);
-#if defined(HAVE_RB_FIBER_CURRENT)
     VALUE fiber = rb_fiber_current();
     VALUE fiber_id = rb_obj_id(fiber);
-#else
-    VALUE fiber_id = thread_id;
-#endif
     const char* class_name = NULL;
     const char* method_name = rb_id2name(mid);
     const char* source_file = rb_sourcefile();
@@ -189,20 +164,10 @@ prof_trace(prof_profile_t* profile, rb_event_flag_t event, NODE *node, ID mid, V
     last_fiber_id = fiber_id;
 }
 
-#ifdef RUBY_VM
 static void
 prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
-#else
-static void
-prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass)
-#endif
 {
-#ifndef RUBY_VM
-    prof_profile_t* profile = pCurrentProfile;
-#else
     prof_profile_t* profile = prof_get_profile(data);
-#endif	
-    
     VALUE thread = Qnil;
     VALUE thread_id = Qnil;
     VALUE fiber = Qnil;
@@ -211,41 +176,30 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     prof_frame_t *frame = NULL;
     double measurement;
 
-    #ifdef RUBY_VM
-      if (event != RUBY_EVENT_C_CALL && event != RUBY_EVENT_C_RETURN) {
+    if (event != RUBY_EVENT_C_CALL && event != RUBY_EVENT_C_RETURN) {
         // guess these are already set for C calls in 1.9, then?
         rb_frame_method_id_and_class(&mid, &klass);
-      }
-    #endif
+    }
 
     /* Get current measurement */
     measurement = profile->measurer->measure();
 
-    if (trace_file != NULL)
-    {
-#ifdef RUBY_VM
-        prof_trace(profile, event, mid, klass, measurement);
-#else
-        prof_trace(profile, event, node, mid, klass, measurement);
-#endif
-    }
-
     /* Special case - skip any methods from the mProf
        module or cProfile class since they clutter
        the results but aren't important to them results. */
     if (self == mProf || klass == cProfile)
 		return;
 
-    /* Get the current thread information. */
+    if (trace_file != NULL)
+    {
+        prof_trace(profile, event, mid, klass, measurement);
+    }
+
+    /* Get the current thread and fiber information. */
     thread = rb_thread_current();
     thread_id = rb_obj_id(thread);
-#if defined(HAVE_RB_FIBER_CURRENT)
     fiber = rb_fiber_current();
     fiber_id = rb_obj_id(fiber);
-#else
-    fiber = thread;
-    fiber_id = thread_id;
-#endif
 
     if (st_lookup(profile->exclude_threads_tbl, (st_data_t) thread_id, 0))
     {
@@ -284,11 +238,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         prof_call_info_t *call_info = NULL;
         prof_method_t *method = NULL;
 
-        #ifdef RUBY_VM
         method = get_method(event, klass, mid, thread_data);
-        #else
-        method = get_method(event, node, klass, mid, thread_data);
-        #endif
 
         if (!frame)
         {
@@ -334,37 +284,15 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
 void
 prof_install_hook(VALUE self)
 {
-#ifdef RUBY_VM
     rb_add_event_hook(prof_event_hook,
           RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
-          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN
-            | RUBY_EVENT_LINE, self); // RUBY_EVENT_SWITCH
-#else
-    rb_add_event_hook(prof_event_hook,
-          RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
-          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN
-          | RUBY_EVENT_LINE);
-
-    pCurrentProfile = prof_get_profile(self);
-#endif	
-
-#if defined(TOGGLE_GC_STATS)
-    rb_gc_enable_stats();
-#endif
+          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN |
+          RUBY_EVENT_LINE, self);
 }
 
 void
 prof_remove_hook()
 {
-#if defined(TOGGLE_GC_STATS)
-    rb_gc_disable_stats();
-#endif
-
-#ifndef RUBY_VM
-    pCurrentProfile = NULL;
-#endif
-
-    /* Now unregister from event   */
     rb_remove_event_hook(prof_event_hook);
 }
 
@@ -508,19 +436,12 @@ prof_start(VALUE self)
     char* trace_file_name;
 
     prof_profile_t* profile = prof_get_profile(self);
-        
+
     if (profile->running == Qtrue)
     {
         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;
@@ -674,8 +595,7 @@ prof_threads(VALUE self)
 void Init_ruby_prof()
 {
     mProf = rb_define_module("RubyProf");
-    rb_define_const(mProf, "VERSION", rb_str_new2(RUBY_PROF_VERSION));
-    
+
     rp_init_measure();
     rp_init_method_info();
     rp_init_call_info();