ruby-prof 1.4.3 → 1.6.3

data/ext/ruby_prof/rp_call_tree.h

@@ -1,43 +1,47 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RP_CALL_TREE_H__
-#define __RP_CALL_TREE_H__
-
-#include "ruby_prof.h"
-#include "rp_measurement.h"
-#include "rp_method.h"
-
-extern VALUE cRpCallTree;
-
-/* Callers and callee information for a method. */
-typedef struct prof_call_tree_t
-{
-    prof_method_t* method;
-    struct prof_call_tree_t* parent;
-    st_table* children;             /* Call infos that this call info calls */
-    prof_measurement_t* measurement;
-    VALUE object;
-
-    int visits;                             /* Current visits on the stack */
-
-    unsigned int source_line;
-    VALUE source_file;
-} prof_call_tree_t;
-
-prof_call_tree_t* prof_call_tree_create(prof_method_t* method, prof_call_tree_t* parent, VALUE source_file, int source_line);
-prof_call_tree_t* prof_call_tree_copy(prof_call_tree_t* other);
-void prof_call_tree_merge(prof_call_tree_t* result, prof_call_tree_t* other);
-void prof_call_tree_mark(void* data);
-prof_call_tree_t* call_tree_table_lookup(st_table* table, st_data_t key);
-
-void prof_call_tree_add_parent(prof_call_tree_t* self, prof_call_tree_t* parent);
-void prof_call_tree_add_child(prof_call_tree_t* self, prof_call_tree_t* child);
-
-uint32_t prof_call_figure_depth(prof_call_tree_t* call_tree_data);
-prof_call_tree_t* prof_get_call_tree(VALUE self);
-VALUE prof_call_tree_wrap(prof_call_tree_t* call_tree);
-void prof_call_tree_free(prof_call_tree_t* call_tree);
-void rp_init_call_tree(void);
-
-#endif //__RP_CALL_TREE_H__
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_CALL_TREE_H__
+#define __RP_CALL_TREE_H__
+
+#include "ruby_prof.h"
+#include "rp_measurement.h"
+#include "rp_method.h"
+
+extern VALUE cRpCallTree;
+
+/* Callers and callee information for a method. */
+typedef struct prof_call_tree_t
+{
+    prof_owner_t owner;
+    prof_method_t* method;
+    struct prof_call_tree_t* parent;
+    st_table* children;             /* Call infos that this call info calls */
+    prof_measurement_t* measurement;
+    VALUE object;
+
+    int visits;                             /* Current visits on the stack */
+
+    unsigned int source_line;
+    VALUE source_file;
+} prof_call_tree_t;
+
+prof_call_tree_t* prof_call_tree_create(prof_method_t* method, prof_call_tree_t* parent, VALUE source_file, int source_line);
+prof_call_tree_t* prof_call_tree_copy(prof_call_tree_t* other);
+void prof_call_tree_merge_internal(prof_call_tree_t* destination, prof_call_tree_t* other, st_table* method_table);
+void prof_call_tree_mark(void* data);
+prof_call_tree_t* call_tree_table_lookup(st_table* table, st_data_t key);
+
+void prof_call_tree_add_parent(prof_call_tree_t* self, prof_call_tree_t* parent);
+void prof_call_tree_add_child(prof_call_tree_t* self, prof_call_tree_t* child);
+
+uint32_t prof_call_tree_figure_depth(prof_call_tree_t* call_tree);
+VALUE prof_call_tree_methods(prof_call_tree_t* call_tree);
+
+prof_call_tree_t* prof_get_call_tree(VALUE self);
+VALUE prof_call_tree_wrap(prof_call_tree_t* call_tree);
+void prof_call_tree_free(prof_call_tree_t* call_tree);
+
+void rp_init_call_tree();
+
+#endif //__RP_CALL_TREE_H__

data/ext/ruby_prof/rp_call_trees.c

@@ -1,7 +1,6 @@
 /* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
    Please see the LICENSE file for copyright and distribution information */
 
-#include "rp_aggregate_call_tree.h"
 #include "rp_call_trees.h"
 #include "rp_measurement.h"
 
@@ -68,11 +67,11 @@ void prof_call_trees_ruby_gc_free(void* data)
     }
 }
 
-static int prof_call_trees_collect_aggregates(st_data_t key, st_data_t value, st_data_t data)
+static int prof_call_trees_collect(st_data_t key, st_data_t value, st_data_t data)
 {
     VALUE result = (VALUE)data;
     prof_call_tree_t* call_tree_data = (prof_call_tree_t*)value;
-    VALUE aggregate_call_tree = prof_aggregate_call_tree_wrap(call_tree_data);
+    VALUE aggregate_call_tree = prof_call_tree_wrap(call_tree_data);
     rb_ary_push(result, aggregate_call_tree);
 
     return ST_CONTINUE;
@@ -87,11 +86,16 @@ static int prof_call_trees_collect_callees(st_data_t key, st_data_t value, st_da
 
     if (rb_st_lookup(callers, call_tree_data->method->key, (st_data_t*)&aggregate_call_tree_data))
     {
-        prof_call_tree_merge(aggregate_call_tree_data, call_tree_data);
+      prof_measurement_merge_internal(aggregate_call_tree_data->measurement, call_tree_data->measurement);
     }
     else
     {
+        // Copy the call tree so we don't touch the original and give Ruby ownerhip 
+        // of it so that it is freed on GC
         aggregate_call_tree_data = prof_call_tree_copy(call_tree_data);
+        aggregate_call_tree_data->owner = OWNER_RUBY;
+
+
         rb_st_insert(callers, call_tree_data->method->key, (st_data_t)aggregate_call_tree_data);
     }
 
@@ -166,7 +170,7 @@ VALUE prof_call_trees_min_depth(VALUE self)
     prof_call_trees_t* call_trees = prof_get_call_trees(self);
     for (prof_call_tree_t** p_call_tree = call_trees->start; p_call_tree < call_trees->ptr; p_call_tree++)
     {
-        unsigned int call_tree_depth = prof_call_figure_depth(*p_call_tree);
+        unsigned int call_tree_depth = prof_call_tree_figure_depth(*p_call_tree);
         if (call_tree_depth < depth)
             depth = call_tree_depth;
     }
@@ -210,17 +214,21 @@ VALUE prof_call_trees_callers(VALUE self)
 
         if (rb_st_lookup(callers, parent->method->key, (st_data_t*)&aggregate_call_tree_data))
         {
-            prof_call_tree_merge(aggregate_call_tree_data, *p_call_tree);
+          prof_measurement_merge_internal(aggregate_call_tree_data->measurement, (*p_call_tree)->measurement);
         }
         else
         {
+            // Copy the call tree so we don't touch the original and give Ruby ownerhip 
+            // of it so that it is freed on GC
             aggregate_call_tree_data = prof_call_tree_copy(*p_call_tree);
+            aggregate_call_tree_data->owner = OWNER_RUBY;
+
             rb_st_insert(callers, parent->method->key, (st_data_t)aggregate_call_tree_data);
         }
     }
 
     VALUE result = rb_ary_new_capa((long)callers->num_entries);
-    rb_st_foreach(callers, prof_call_trees_collect_aggregates, result);
+    rb_st_foreach(callers, prof_call_trees_collect, result);
     rb_st_free_table(callers);
     return result;
 }
@@ -240,7 +248,7 @@ VALUE prof_call_trees_callees(VALUE self)
     }
 
     VALUE result = rb_ary_new_capa((long)callees->num_entries);
-    rb_st_foreach(callees, prof_call_trees_collect_aggregates, result);
+    rb_st_foreach(callees, prof_call_trees_collect, result);
     rb_st_free_table(callees);
     return result;
 }

data/ext/ruby_prof/rp_measure_allocations.c

@@ -8,20 +8,20 @@
 static VALUE cMeasureAllocations;
 VALUE total_allocated_objects_key;
 
-static double measure_allocations_via_gc_stats(rb_trace_arg_t* trace_arg)
-{
-    return (double)rb_gc_stat(total_allocated_objects_key);
-}
-
-static double measure_allocations_via_tracing(rb_trace_arg_t* trace_arg)
+static double measure_allocations(rb_trace_arg_t* trace_arg)
 {
     static double result = 0;
 
     if (trace_arg)
     {
+        // Only process creation of new objects
         rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
-        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
-            result++;
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ) {
+            // Don't count allocations of internal IMemo objects
+            VALUE object = rb_tracearg_object(trace_arg);
+            if (BUILTIN_TYPE(object) != T_IMEMO)
+                result++;
+        }
     }
     return result;
 }
@@ -30,14 +30,11 @@ prof_measurer_t* prof_measurer_allocations(bool track_allocations)
 {
     prof_measurer_t* measure = ALLOC(prof_measurer_t);
     measure->mode = MEASURE_ALLOCATIONS;
+    measure->measure = measure_allocations;
     measure->multiplier = 1;
+    // Need to track allocations to get RUBY_INTERNAL_EVENT_NEWOBJ event
     measure->track_allocations = track_allocations;
 
-    if (track_allocations)
-        measure->measure = measure_allocations_via_tracing;
-    else
-        measure->measure = measure_allocations_via_gc_stats;
-
     return measure;
 }
 

data/ext/ruby_prof/rp_measure_memory.c

@@ -7,20 +7,23 @@
 
 static VALUE cMeasureMemory;
 
-static double
-measure_memory_via_tracing(rb_trace_arg_t* trace_arg)
+static double measure_memory(rb_trace_arg_t* trace_arg)
 {
     static double result = 0;
 
     if (trace_arg)
     {
+        // Only process creation of new objects
         rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
         if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
         {
+            // Don't count allocations of internal IMemo objects
             VALUE object = rb_tracearg_object(trace_arg);
-            result += rb_obj_memsize_of(object);
+            if (BUILTIN_TYPE(object) != T_IMEMO)
+                result += rb_obj_memsize_of(object);
         }
     }
+
     return result;
 }
 
@@ -28,8 +31,9 @@ prof_measurer_t* prof_measurer_memory(bool track_allocations)
 {
   prof_measurer_t* measure = ALLOC(prof_measurer_t);
   measure->mode = MEASURE_MEMORY;
-  measure->measure = measure_memory_via_tracing;
+  measure->measure = measure_memory;
   measure->multiplier = 1;
+  // Need to track allocations to get RUBY_INTERNAL_EVENT_NEWOBJ event
   measure->track_allocations = true;
   return measure;
 }

data/ext/ruby_prof/rp_measure_process_time.c

@@ -11,21 +11,22 @@ static double measure_process_time(rb_trace_arg_t* trace_arg)
 #if defined(_WIN32)
     FILETIME  createTime;
     FILETIME  exitTime;
-    FILETIME  sysTime;
+    FILETIME  kernelTime;
     FILETIME  userTime;
 
-    ULARGE_INTEGER sysTimeInt;
+    ULARGE_INTEGER kernelTimeInt;
     ULARGE_INTEGER userTimeInt;
 
-    GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &userTime);
+    GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &kernelTime, &userTime);
 
-    sysTimeInt.LowPart = sysTime.dwLowDateTime;
-    sysTimeInt.HighPart = sysTime.dwHighDateTime;
+    kernelTimeInt.LowPart = kernelTime.dwLowDateTime;
+    kernelTimeInt.HighPart = kernelTime.dwHighDateTime;
     userTimeInt.LowPart = userTime.dwLowDateTime;
     userTimeInt.HighPart = userTime.dwHighDateTime;
 
-    return (double)(sysTimeInt.QuadPart + userTimeInt.QuadPart);
+    return (double)(kernelTimeInt.QuadPart + userTimeInt.QuadPart);
 #elif !defined(CLOCK_PROCESS_CPUTIME_ID)
+    #include <sys/resource.h>
     struct rusage usage;
     getrusage(RUSAGE_SELF, &usage);
     return usage.ru_stime.tv_sec + usage.ru_utime.tv_sec + ((usage.ru_stime.tv_usec + usage.ru_utime.tv_usec) / 1000000.0);

data/ext/ruby_prof/rp_measurement.c

@@ -16,7 +16,7 @@ void rp_init_measure_memory(void);
 void rp_init_measure_process_time(void);
 void rp_init_measure_wall_time(void);
 
-prof_measurer_t* prof_get_measurer(prof_measure_mode_t measure, bool track_allocations)
+prof_measurer_t* prof_measurer_create(prof_measure_mode_t measure, bool track_allocations)
 {
     switch (measure)
     {
@@ -43,6 +43,7 @@ double prof_measure(prof_measurer_t* measurer, rb_trace_arg_t* trace_arg)
 prof_measurement_t* prof_measurement_create(void)
 {
     prof_measurement_t* result = ALLOC(prof_measurement_t);
+    result->owner = OWNER_C;
     result->total_time = 0;
     result->self_time = 0;
     result->wait_time = 0;
@@ -51,24 +52,66 @@ prof_measurement_t* prof_measurement_create(void)
     return result;
 }
 
+/* call-seq:
+     new(total_time, self_time, wait_time, called) -> Measurement
+
+   Creates a new measuremen instance. */
+static VALUE prof_measurement_initialize(VALUE self, VALUE total_time, VALUE self_time, VALUE wait_time, VALUE called)
+{
+  prof_measurement_t* result = prof_get_measurement(self);
+
+  result->total_time = NUM2DBL(total_time);
+  result->self_time = NUM2DBL(self_time);
+  result->wait_time = NUM2DBL(wait_time);
+  result->called = NUM2INT(called);
+  result->object = self;
+  return self;
+}
+
+prof_measurement_t* prof_measurement_copy(prof_measurement_t* other)
+{
+  prof_measurement_t* result = prof_measurement_create();
+  result->called = other->called;
+  result->total_time = other->total_time;
+  result->self_time = other->self_time;
+  result->wait_time = other->wait_time;
+
+  return result;
+}
+
+static VALUE prof_measurement_initialize_copy(VALUE self, VALUE other)
+{
+  // This object was created by Ruby either via Measurment#clone or Measurement#dup 
+  // and thus prof_measurement_allocate was called so the object is owned by Ruby
+
+  if (self == other)
+    return self;
+
+  prof_measurement_t* self_ptr = prof_get_measurement(self);
+  prof_measurement_t* other_ptr = prof_get_measurement(other);
+
+  self_ptr->called = other_ptr->called;
+  self_ptr->total_time = other_ptr->total_time;
+  self_ptr->self_time = other_ptr->self_time;
+  self_ptr->wait_time = other_ptr->wait_time;
+
+  return self;
+}
+
 void prof_measurement_mark(void* data)
 {
     if (!data) return;
 
-    prof_measurement_t* measurement_data = (prof_measurement_t*)data;
+    prof_measurement_t* measurement = (prof_measurement_t*)data;
 
-    if (measurement_data->object != Qnil)
-        rb_gc_mark(measurement_data->object);
+    if (measurement->object != Qnil)
+        rb_gc_mark_movable(measurement->object);
 }
 
-static void prof_measurement_ruby_gc_free(void* data)
+void prof_measurement_compact(void* data)
 {
-    if (data)
-    {
-        // Measurements are freed by their owning object (call info or method)
-        prof_measurement_t* measurement = (prof_measurement_t*)data;
-        measurement->object = Qnil;
-    }
+    prof_measurement_t* measurement = (prof_measurement_t*)data;
+    measurement->object = rb_gc_location(measurement->object);
 }
 
 void prof_measurement_free(prof_measurement_t* measurement)
@@ -84,6 +127,27 @@ void prof_measurement_free(prof_measurement_t* measurement)
     xfree(measurement);
 }
 
+static void prof_measurement_ruby_gc_free(void* data)
+{
+  prof_measurement_t* measurement = (prof_measurement_t*)data;
+
+  if (!measurement)
+  {
+    // Object has already been freed by C code
+    return;
+  }
+  else if (measurement->owner == OWNER_RUBY)
+  {
+    // Ruby owns this object, we need to free the underlying C struct
+    prof_measurement_free(measurement);
+  }
+  else
+  {
+    // The Ruby object is being freed, but not the underlying C structure. So unlink the two.
+    measurement->object = Qnil;
+  }
+}
+
 size_t prof_measurement_size(const void* data)
 {
     return sizeof(prof_measurement_t);
@@ -97,6 +161,7 @@ static const rb_data_type_t measurement_type =
         .dmark = prof_measurement_mark,
         .dfree = prof_measurement_ruby_gc_free,
         .dsize = prof_measurement_size,
+        .dcompact = prof_measurement_compact
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
@@ -114,6 +179,8 @@ VALUE prof_measurement_wrap(prof_measurement_t* measurement)
 static VALUE prof_measurement_allocate(VALUE klass)
 {
     prof_measurement_t* measurement = prof_measurement_create();
+    // This object is being created by Ruby
+    measurement->owner = OWNER_RUBY;
     measurement->object = prof_measurement_wrap(measurement);
     return measurement->object;
 }
@@ -140,6 +207,17 @@ static VALUE prof_measurement_total_time(VALUE self)
     return rb_float_new(result->total_time);
 }
 
+/* call-seq:
+   total_time=value -> value
+
+Sets the call count to n. */
+static VALUE prof_measurement_set_total_time(VALUE self, VALUE value)
+{
+  prof_measurement_t* result = prof_get_measurement(self);
+  result->total_time = NUM2DBL(value);
+  return value;
+}
+
 /* call-seq:
    self_time -> float
 
@@ -152,6 +230,17 @@ prof_measurement_self_time(VALUE self)
     return rb_float_new(result->self_time);
 }
 
+/* call-seq:
+   self_time=value -> value
+
+Sets the call count to value. */
+static VALUE prof_measurement_set_self_time(VALUE self, VALUE value)
+{
+  prof_measurement_t* result = prof_get_measurement(self);
+  result->self_time = NUM2DBL(value);
+  return value;
+}
+
 /* call-seq:
    wait_time -> float
 
@@ -163,6 +252,17 @@ static VALUE prof_measurement_wait_time(VALUE self)
     return rb_float_new(result->wait_time);
 }
 
+/* call-seq:
+   wait_time=value -> value
+
+Sets the wait time to value. */
+static VALUE prof_measurement_set_wait_time(VALUE self, VALUE value)
+{
+  prof_measurement_t* result = prof_get_measurement(self);
+  result->wait_time = NUM2DBL(value);
+  return value;
+}
+
 /* call-seq:
    called -> int
 
@@ -174,23 +274,44 @@ static VALUE prof_measurement_called(VALUE self)
 }
 
 /* call-seq:
-   called=n -> n
+   called=value -> value
 
-Sets the call count to n. */
-static VALUE prof_measurement_set_called(VALUE self, VALUE called)
+Sets the call count to value. */
+static VALUE prof_measurement_set_called(VALUE self, VALUE value)
 {
-    prof_measurement_t* result = prof_get_measurement(self);
-    result->called = NUM2INT(called);
-    return called;
+  prof_measurement_t* result = prof_get_measurement(self);
+  result->called = NUM2INT(value);
+  return value;
 }
 
 /* :nodoc: */
-static VALUE
-prof_measurement_dump(VALUE self)
+void prof_measurement_merge_internal(prof_measurement_t* self, prof_measurement_t* other)
+{
+  self->called += other->called;
+  self->total_time += other->total_time;
+  self->self_time += other->self_time;
+  self->wait_time += other->wait_time;
+}
+
+/* call-seq:
+   merge(other)
+
+   Adds the content of other measurement to this measurement */
+VALUE prof_measurement_merge(VALUE self, VALUE other)
+{
+  prof_measurement_t* self_ptr = prof_get_measurement(self);
+  prof_measurement_t* other_ptr = prof_get_measurement(other);
+  prof_measurement_merge_internal(self_ptr, other_ptr);
+  return self;
+}
+
+/* :nodoc: */
+static VALUE prof_measurement_dump(VALUE self)
 {
     prof_measurement_t* measurement_data = prof_get_measurement(self);
     VALUE result = rb_hash_new();
 
+    rb_hash_aset(result, ID2SYM(rb_intern("owner")), INT2FIX(measurement_data->owner));
     rb_hash_aset(result, ID2SYM(rb_intern("total_time")), rb_float_new(measurement_data->total_time));
     rb_hash_aset(result, ID2SYM(rb_intern("self_time")), rb_float_new(measurement_data->self_time));
     rb_hash_aset(result, ID2SYM(rb_intern("wait_time")), rb_float_new(measurement_data->wait_time));
@@ -206,6 +327,7 @@ prof_measurement_load(VALUE self, VALUE data)
     prof_measurement_t* measurement = prof_get_measurement(self);
     measurement->object = self;
 
+    measurement->owner = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("owner"))));
     measurement->total_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("total_time"))));
     measurement->self_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("self_time"))));
     measurement->wait_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("wait_time"))));
@@ -223,14 +345,19 @@ void rp_init_measure()
     rp_init_measure_memory();
 
     cRpMeasurement = rb_define_class_under(mProf, "Measurement", rb_cObject);
-    rb_undef_method(CLASS_OF(cRpMeasurement), "new");
     rb_define_alloc_func(cRpMeasurement, prof_measurement_allocate);
 
+    rb_define_method(cRpMeasurement, "initialize", prof_measurement_initialize, 4);
+    rb_define_method(cRpMeasurement, "initialize_copy", prof_measurement_initialize_copy, 1);
+    rb_define_method(cRpMeasurement, "merge!", prof_measurement_merge, 1);
     rb_define_method(cRpMeasurement, "called", prof_measurement_called, 0);
     rb_define_method(cRpMeasurement, "called=", prof_measurement_set_called, 1);
     rb_define_method(cRpMeasurement, "total_time", prof_measurement_total_time, 0);
+    rb_define_method(cRpMeasurement, "total_time=", prof_measurement_set_total_time, 1);
     rb_define_method(cRpMeasurement, "self_time", prof_measurement_self_time, 0);
+    rb_define_method(cRpMeasurement, "self_time=", prof_measurement_set_self_time, 1);
     rb_define_method(cRpMeasurement, "wait_time", prof_measurement_wait_time, 0);
+    rb_define_method(cRpMeasurement, "wait_time=", prof_measurement_set_wait_time, 1);
 
     rb_define_method(cRpMeasurement, "_dump_data", prof_measurement_dump, 0);
     rb_define_method(cRpMeasurement, "_load_data", prof_measurement_load, 1);

data/ext/ruby_prof/rp_measurement.h

@@ -29,6 +29,7 @@ typedef struct prof_measurer_t
 /* Callers and callee information for a method. */
 typedef struct prof_measurement_t
 {
+    prof_owner_t owner;
     double total_time;
     double self_time;
     double wait_time;
@@ -36,14 +37,16 @@ typedef struct prof_measurement_t
     VALUE object;
 } prof_measurement_t;
 
-prof_measurer_t* prof_get_measurer(prof_measure_mode_t measure, bool track_allocations);
+prof_measurer_t* prof_measurer_create(prof_measure_mode_t measure, bool track_allocations);
 double prof_measure(prof_measurer_t* measurer, rb_trace_arg_t* trace_arg);
 
 prof_measurement_t* prof_measurement_create(void);
+prof_measurement_t* prof_measurement_copy(prof_measurement_t* other);
 void prof_measurement_free(prof_measurement_t* measurement);
 VALUE prof_measurement_wrap(prof_measurement_t* measurement);
 prof_measurement_t* prof_get_measurement(VALUE self);
 void prof_measurement_mark(void* data);
+void prof_measurement_merge_internal(prof_measurement_t* destination, prof_measurement_t* other);
 
 void rp_init_measure(void);