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

data/ext/ruby_prof/rp_measure_gc_runs.c

@@ -81,7 +81,7 @@ void rp_init_measure_gc_runs()
 {
     rb_define_const(mProf, "GC_RUNS", INT2NUM(MEASURE_GC_RUNS));
     rb_define_const(mProf, "GC_RUNS_ENABLED", MEASURE_GC_RUNS_ENABLED);
-	
+    
     cMeasureGcRuns = rb_define_class_under(mMeasure, "GcRuns", rb_cObject);
     rb_define_singleton_method(cMeasureGcRuns, "measure", prof_measure_gc_runs, 0);
 }

data/ext/ruby_prof/rp_measure_memory.c

@@ -74,7 +74,7 @@ prof_measure_memory(VALUE self)
 void rp_init_measure_memory()
 {
     rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
-	rb_define_const(mProf, "MEMORY_ENABLED", MEASURE_MEMORY_ENABLED);
+    rb_define_const(mProf, "MEMORY_ENABLED", MEASURE_MEMORY_ENABLED);
 
     cMeasureMemory = rb_define_class_under(mMeasure, "Memory", rb_cObject);
     rb_define_singleton_method(cMeasureMemory, "measure", prof_measure_memory, 0);

data/ext/ruby_prof/rp_measure_process_time.c

@@ -1,71 +1,71 @@
-/* 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"
-#include <time.h>
-
-static VALUE cMeasureProcessTime;
-
-static double
-measure_process_time()
-{
-#if defined(__linux__)
-    struct timespec clock;
-    clock_gettime(CLOCK_PROCESS_CPUTIME_ID , &clock);
-    return (clock.tv_sec * 1000000000 + clock.tv_nsec) / 1000000000.0;
-#elif defined(_win32)
-	FILETIME createTime;
-	FILETIME exitTime;
-	FILETIME sysTime;
-	FILETIME cpuTime;
-
-	ULARGE_INTEGER sysTimeInt;
-	ULARGE_INTEGER cpuTimeInt;
-	ULONGLONG totalTime;
-
-	GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &cpuTime); 
-
-	/* Doing this based on MSFT's recommendation in the FILETIME structure documentation at
-	  http://msdn.microsoft.com/en-us/library/ms724284%28VS.85%29.aspx*/
-
-	sysTimeInt.LowPart = sysTime.dwLowDateTime;
-	sysTimeInt.HighPart = sysTime.dwHighDateTime;
-	cpuTimeInt.LowPart = cpuTime.dwLowDateTime;
-	cpuTimeInt.HighPart = cpuTime.dwHighDateTime;
-
-	totalTime = sysTimeInt.QuadPart + cpuTimeInt.QuadPart;
-
-	// Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
-	return totalTime / 10000000.0;
-#else
-    return ((double)clock()) / CLOCKS_PER_SEC;
-#endif
-}
-
-/* call-seq:
-   measure_process_time -> float
-
-Returns the process time.*/
-static VALUE
-prof_measure_process_time(VALUE self)
-{
-    return rb_float_new(measure_process_time());
-}
-
-prof_measurer_t* prof_measurer_process_time()
-{
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_process_time;
-  return measure;
-}
-
-
-void rp_init_measure_process_time()
-{
-    rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
-    rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
-	rb_define_const(mProf, "PROCESS_TIME_ENABLED", Qtrue);
-
-    cMeasureProcessTime = rb_define_class_under(mMeasure, "ProcessTime", rb_cObject);
-    rb_define_singleton_method(cMeasureProcessTime, "measure", prof_measure_process_time, 0);
-}
+/* 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"
+#include <time.h>
+
+static VALUE cMeasureProcessTime;
+
+static double
+measure_process_time()
+{
+#if defined(__linux__)
+    struct timespec clock;
+    clock_gettime(CLOCK_PROCESS_CPUTIME_ID , &clock);
+    return (clock.tv_sec * 1000000000 + clock.tv_nsec) / 1000000000.0;
+#elif defined(_win32)
+	FILETIME createTime;
+	FILETIME exitTime;
+	FILETIME sysTime;
+	FILETIME cpuTime;
+
+	ULARGE_INTEGER sysTimeInt;
+	ULARGE_INTEGER cpuTimeInt;
+	ULONGLONG totalTime;
+
+	GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &cpuTime); 
+
+	/* Doing this based on MSFT's recommendation in the FILETIME structure documentation at
+	  http://msdn.microsoft.com/en-us/library/ms724284%28VS.85%29.aspx*/
+
+	sysTimeInt.LowPart = sysTime.dwLowDateTime;
+	sysTimeInt.HighPart = sysTime.dwHighDateTime;
+	cpuTimeInt.LowPart = cpuTime.dwLowDateTime;
+	cpuTimeInt.HighPart = cpuTime.dwHighDateTime;
+
+	totalTime = sysTimeInt.QuadPart + cpuTimeInt.QuadPart;
+
+	// Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
+	return totalTime / 10000000.0;
+#else
+    return ((double)clock()) / CLOCKS_PER_SEC;
+#endif
+}
+
+/* call-seq:
+   measure_process_time -> float
+
+Returns the process time.*/
+static VALUE
+prof_measure_process_time(VALUE self)
+{
+    return rb_float_new(measure_process_time());
+}
+
+prof_measurer_t* prof_measurer_process_time()
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->measure = measure_process_time;
+  return measure;
+}
+
+
+void rp_init_measure_process_time()
+{
+    rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
+    rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
+	rb_define_const(mProf, "PROCESS_TIME_ENABLED", Qtrue);
+
+    cMeasureProcessTime = rb_define_class_under(mMeasure, "ProcessTime", rb_cObject);
+    rb_define_singleton_method(cMeasureProcessTime, "measure", prof_measure_process_time, 0);
+}

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -37,6 +37,6 @@ void rp_init_measure_wall_time()
     rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
     rb_define_const(mProf, "WALL_TIME_ENABLED", Qtrue);
 
-	cMeasureWallTime = rb_define_class_under(mMeasure, "WallTime", rb_cObject);
+    cMeasureWallTime = rb_define_class_under(mMeasure, "WallTime", rb_cObject);
     rb_define_singleton_method(cMeasureWallTime, "measure", prof_measure_wall_time, 0);
 }

data/ext/ruby_prof/rp_method.c

@@ -118,6 +118,129 @@ full_name(VALUE klass, ID mid)
   return result;
 }
 
+void
+method_key(prof_method_key_t* key, VALUE klass, ID mid)
+{
+    /* Is this an include for a module?  If so get the actual
+        module class since we want to combine all profiling
+        results for that module. */
+    if (klass != 0)
+        klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
+
+    key->klass = klass;
+    key->mid = mid;
+    key->key = (klass << 4) + (mid << 2);
+}
+
+/* ================  prof_method_t   =================*/
+prof_method_t*
+prof_method_create(VALUE klass, ID mid, const char* source_file, int line)
+{
+    prof_method_t *result = ALLOC(prof_method_t);
+    result->object = Qnil;
+    result->call_infos = prof_call_infos_create();
+	result->call_infos2 = Qnil;
+
+    result->key = ALLOC(prof_method_key_t);
+    method_key(result->key, klass, mid);
+
+    //result->call_info_table = call_info_table_create();
+
+    if (source_file != NULL)
+    {
+      size_t len = strlen(source_file) + 1;
+      char *buffer = ALLOC_N(char, len);
+
+      MEMCPY(buffer, source_file, char, len);
+      result->source_file = buffer;
+    }
+    else
+    {
+      result->source_file = source_file;
+    }
+    result->line = line;
+
+    return result;
+}
+
+/* The underlying c structures are freed when the parent profile is freed.  
+   However, on shutdown the Ruby GC frees objects in any will-nilly order.
+   That means the ruby thread object wrapping the c thread struct may
+   be freed before the parent profile.  Thus we add in a free function
+   for the garbage collector so that if it does get called will nil 
+   out our Ruby object reference.*/
+static void
+prof_method_ruby_gc_free(prof_method_t* method)
+{
+	/* Has this thread object been accessed by Ruby?  If
+	   yes clean it up so to avoid a segmentation fault. */
+	if (method->object != Qnil)
+	{
+		RDATA(method->object)->data = NULL;
+		RDATA(method->object)->dfree = NULL;
+		RDATA(method->object)->dmark = NULL;
+    }
+	method->object = Qnil;
+}
+
+static void
+prof_method_free(prof_method_t* method)
+{
+	prof_method_ruby_gc_free(method);
+	prof_call_infos_free(method->call_infos);
+
+	xfree(method->key);
+	method->key = NULL;
+
+	xfree(method);
+}
+
+/*static int
+mark_call_infos(st_data_t key, st_data_t value, st_data_t result)
+{
+    prof_call_info_t *call_info = (prof_call_info_t *) value;
+    prof_call_info_mark(call_info);
+    return ST_CONTINUE;
+}
+*/
+
+void
+prof_method_mark(prof_method_t *method)
+{
+	if (method->object)
+		rb_gc_mark(method->object);
+
+	if (method->call_infos2)
+		rb_gc_mark(method->call_infos2);
+
+	if (method->call_infos->object)
+		rb_gc_mark(method->call_infos->object);
+
+	//st_foreach(method->call_info_table, mark_call_infos, NULL);
+}
+
+VALUE
+prof_method_wrap(prof_method_t *result)
+{
+  if (result->object == Qnil)
+  {
+    result->object = Data_Wrap_Struct(cMethodInfo, prof_method_mark, prof_method_ruby_gc_free, result);
+  }
+  return result->object;
+}
+
+static prof_method_t *
+get_prof_method(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+	prof_method_t* result = DATA_PTR(self);
+
+	if (!result)
+	    rb_raise(rb_eRuntimeError, "This RubyProf::MethodInfo instance has already been freed, likely because its profile has been freed.");
+
+   return result;
+}
 
 /* ================  Method Table   =================*/
 int
@@ -143,6 +266,21 @@ method_table_create()
   return st_init_table(&type_method_hash);
 }
 
+static int
+method_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
+{
+    prof_method_free((prof_method_t*)value);
+    return ST_CONTINUE;
+}
+
+void
+method_table_free(st_table *table)
+{
+    st_foreach(table, method_table_free_iterator, 0);
+    st_free_table(table);
+}
+
+
 size_t
 method_table_insert(st_table *table, const prof_method_key_t *key, prof_method_t *val)
 {
@@ -163,15 +301,6 @@ method_table_lookup(st_table *table, const prof_method_key_t* key)
     }
 }
 
-void
-method_table_free(st_table *table)
-{
-    /* Don't free the contents since they are wrapped by
-       Ruby objects! */
-    st_free_table(table);
-}
-
-
 /* ================  Method Info   =================*/
 /* Document-class: RubyProf::MethodInfo
 The RubyProf::MethodInfo class stores profiling data for a method.
@@ -182,69 +311,6 @@ created.  RubyProf::MethodInfo objects can be accessed via
 the RubyProf::Result object.
 */
 
-prof_method_t*
-prof_method_create(prof_method_key_t *key, const char* source_file, int line)
-{
-    prof_method_t *result = ALLOC(prof_method_t);
-    result->object = Qnil;
-    result->key = ALLOC(prof_method_key_t);
-    method_key(result->key, key->klass, key->mid);
-
-    result->call_infos = prof_call_infos_create();
-
-    if (source_file != NULL)
-    {
-      size_t len = strlen(source_file) + 1;
-      char *buffer = ALLOC_N(char, len);
-
-      MEMCPY(buffer, source_file, char, len);
-      result->source_file = buffer;
-    }
-    else
-    {
-      result->source_file = source_file;
-    }
-    result->line = line;
-
-    return result;
-}
-
-void
-prof_method_mark(prof_method_t *method)
-{
-  rb_gc_mark(method->call_infos->object);
-  rb_gc_mark(method->key->klass);
-}
-
-static void
-prof_method_free(prof_method_t *method)
-{
-  if (method->source_file)
-  {
-    xfree((char*)method->source_file);
-  }
-
-  prof_call_infos_free(method->call_infos);
-  xfree(method->key);
-  xfree(method);
-}
-
-VALUE
-prof_method_wrap(prof_method_t *result)
-{
-  if (result->object == Qnil)
-  {
-    result->object = Data_Wrap_Struct(cMethodInfo, prof_method_mark, prof_method_free, result);
-  }
-  return result->object;
-}
-
-static prof_method_t *
-get_prof_method(VALUE obj)
-{
-    return (prof_method_t *) DATA_PTR(obj);
-}
-
 /* call-seq:
    line_no -> int
 
@@ -343,7 +409,11 @@ static VALUE
 prof_method_call_infos(VALUE self)
 {
     prof_method_t *method = get_prof_method(self);
-    return prof_call_infos_wrap(method->call_infos);
+	if (method->call_infos2 == Qnil)
+	{
+		method->call_infos2 = prof_call_infos_wrap(method->call_infos);
+	}
+	return method->call_infos2;
 }
 
 void rp_init_method_info()

data/ext/ruby_prof/rp_method.h

@@ -6,7 +6,7 @@
 
 #include <ruby.h>
 
-#ifndef RUBY_VM
+#ifndef RUBY_VM
 #include <st.h>
 typedef st_data_t st_index_t;
 #endif
@@ -18,10 +18,10 @@ typedef struct
 {
     VALUE klass;                            /* The method's class. */
     ID mid;                                 /* The method id. */
-    int depth;                              /* The recursion depth. */
     st_index_t key;                         /* Cache calculated key */
 } prof_method_key_t;
 
+
 /* Forward declaration, see rp_call_info.h */
 struct prof_call_infos_t;
 
@@ -31,18 +31,21 @@ 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 */
+    struct prof_call_infos_t *call_infos;          /* Call info objects for this method */
     VALUE object;                           /* Cached ruby object */
+	VALUE call_infos2;                      /* Cached array of RubyProf::CallInfo */
 } prof_method_t;
 
 void rp_init_method_info(void);
 
+void method_key(prof_method_key_t* key, VALUE klass, ID mid);
+
 st_table * method_table_create();
 prof_method_t * method_table_lookup(st_table *table, const prof_method_key_t* key);
 size_t method_table_insert(st_table *table, const prof_method_key_t *key, prof_method_t *val);
 void method_table_free(st_table *table);
 
-prof_method_t* prof_method_create(prof_method_key_t *key, const char* source_file, int line);
+prof_method_t* prof_method_create(VALUE klass, ID mid, const char* source_file, int line);
 VALUE prof_method_wrap(prof_method_t *result);
 void prof_method_mark(prof_method_t *method);