ruby-prof 1.1.0-x64-mingw32 → 1.4.2-x64-mingw32

data/ext/ruby_prof/rp_call_tree.h

@@ -0,0 +1,43 @@
+/* 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__

data/ext/ruby_prof/rp_call_trees.c

@@ -0,0 +1,288 @@
+/* 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"
+
+#define INITIAL_CALL_TREES_SIZE 2
+
+VALUE cRpCallTrees;
+
+/* =======  Call Infos   ========*/
+prof_call_trees_t* prof_get_call_trees(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+    prof_call_trees_t* result = RTYPEDDATA_DATA(self);
+
+    if (!result)
+        rb_raise(rb_eRuntimeError, "This RubyProf::CallTrees instance has already been freed, likely because its profile has been freed.");
+
+    return result;
+}
+
+prof_call_trees_t* prof_call_trees_create()
+{
+    prof_call_trees_t* result = ALLOC(prof_call_trees_t);
+    result->start = ALLOC_N(prof_call_tree_t*, INITIAL_CALL_TREES_SIZE);
+    result->end = result->start + INITIAL_CALL_TREES_SIZE;
+    result->ptr = result->start;
+    result->object = Qnil;
+    return result;
+}
+
+void prof_call_trees_mark(void* data)
+{
+    if (!data) return;
+
+    prof_call_trees_t* call_trees = (prof_call_trees_t*)data;
+    prof_call_tree_t** call_tree;
+    for (call_tree = call_trees->start; call_tree < call_trees->ptr; call_tree++)
+    {
+        prof_call_tree_mark(*call_tree);
+    }
+}
+
+void prof_call_trees_free(prof_call_trees_t* call_trees)
+{
+    /* Has this method object been accessed by Ruby?  If
+       yes clean it up so to avoid a segmentation fault. */
+    if (call_trees->object != Qnil)
+    {
+        RTYPEDDATA(call_trees->object)->data = NULL;
+        call_trees->object = Qnil;
+    }
+
+    // Note we do not free our call_tree structures - since they have no parents they will free themselves
+    xfree(call_trees);
+}
+
+void prof_call_trees_ruby_gc_free(void* data)
+{
+    if (data)
+    {
+        // This object gets freed by its owning method
+        prof_call_trees_t* call_trees = (prof_call_trees_t*)data;
+        call_trees->object = Qnil;
+    }
+}
+
+static int prof_call_trees_collect_aggregates(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);
+    rb_ary_push(result, aggregate_call_tree);
+
+    return ST_CONTINUE;
+}
+
+static int prof_call_trees_collect_callees(st_data_t key, st_data_t value, st_data_t hash)
+{
+    st_table* callers = (st_table*)hash;
+    prof_call_tree_t* call_tree_data = (prof_call_tree_t*)value;
+
+    prof_call_tree_t* aggregate_call_tree_data = NULL;
+
+    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);
+    }
+    else
+    {
+        aggregate_call_tree_data = prof_call_tree_copy(call_tree_data);
+        rb_st_insert(callers, call_tree_data->method->key, (st_data_t)aggregate_call_tree_data);
+    }
+
+    return ST_CONTINUE;
+}
+
+size_t prof_call_trees_size(const void* data)
+{
+    return sizeof(prof_call_trees_t);
+}
+
+static const rb_data_type_t call_trees_type =
+{
+    .wrap_struct_name = "CallTrees",
+    .function =
+    {
+        .dmark = prof_call_trees_mark,
+        .dfree = prof_call_trees_ruby_gc_free,
+        .dsize = prof_call_trees_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE prof_call_trees_wrap(prof_call_trees_t* call_trees)
+{
+    if (call_trees->object == Qnil)
+    {
+        call_trees->object = TypedData_Wrap_Struct(cRpCallTrees, &call_trees_type, call_trees);
+    }
+    return call_trees->object;
+}
+
+void prof_add_call_tree(prof_call_trees_t* call_trees, prof_call_tree_t* call_tree)
+{
+    if (call_trees->ptr == call_trees->end)
+    {
+        size_t len = call_trees->ptr - call_trees->start;
+        size_t new_capacity = (call_trees->end - call_trees->start) * 2;
+        REALLOC_N(call_trees->start, prof_call_tree_t*, new_capacity);
+        call_trees->ptr = call_trees->start + len;
+        call_trees->end = call_trees->start + new_capacity;
+    }
+    *call_trees->ptr = call_tree;
+    call_trees->ptr++;
+}
+
+/* ================  Call Infos   =================*/
+/* Document-class: RubyProf::CallTrees
+The RubyProf::MethodInfo class stores profiling data for a method.
+One instance of the RubyProf::MethodInfo class is created per method
+called per thread.  Thus, if a method is called in two different
+thread then there will be two RubyProf::MethodInfo objects
+created.  RubyProf::MethodInfo objects can be accessed via
+the RubyProf::Profile object. */
+VALUE prof_call_trees_allocate(VALUE klass)
+{
+    prof_call_trees_t* call_trees_data = prof_call_trees_create();
+    call_trees_data->object = prof_call_trees_wrap(call_trees_data);
+    return call_trees_data->object;
+}
+
+
+/* call-seq:
+   min_depth -> Integer
+
+Returns the minimum depth of this method in any call tree */
+VALUE prof_call_trees_min_depth(VALUE self)
+{
+    unsigned int depth = INT_MAX;
+
+    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);
+        if (call_tree_depth < depth)
+            depth = call_tree_depth;
+    }
+
+    return UINT2NUM(depth);
+}
+
+/* call-seq:
+   callers -> array
+
+Returns an array of all CallTree objects that called this method. */
+VALUE prof_call_trees_call_trees(VALUE self)
+{
+    VALUE result = rb_ary_new();
+
+    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++)
+    {
+        VALUE call_tree = prof_call_tree_wrap(*p_call_tree);
+        rb_ary_push(result, call_tree);
+    }
+    return result;
+}
+
+/* call-seq:
+   callers -> array
+
+Returns an array of aggregated CallTree objects that called this method (ie, parents).*/
+VALUE prof_call_trees_callers(VALUE self)
+{
+    st_table* callers = rb_st_init_numtable();
+
+    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++)
+    {
+        prof_call_tree_t* parent = (*p_call_tree)->parent;
+        if (parent == NULL)
+            continue;
+
+        prof_call_tree_t* aggregate_call_tree_data = NULL;
+
+        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);
+        }
+        else
+        {
+            aggregate_call_tree_data = prof_call_tree_copy(*p_call_tree);
+            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_free_table(callers);
+    return result;
+}
+
+/* call-seq:
+   callees -> array
+
+Returns an array of aggregated CallTree objects that this method called (ie, children).*/
+VALUE prof_call_trees_callees(VALUE self)
+{
+    st_table* callees = rb_st_init_numtable();
+
+    prof_call_trees_t* call_trees = prof_get_call_trees(self);
+    for (prof_call_tree_t** call_tree = call_trees->start; call_tree < call_trees->ptr; call_tree++)
+    {
+        rb_st_foreach((*call_tree)->children, prof_call_trees_collect_callees, (st_data_t)callees);
+    }
+
+    VALUE result = rb_ary_new_capa((long)callees->num_entries);
+    rb_st_foreach(callees, prof_call_trees_collect_aggregates, result);
+    rb_st_free_table(callees);
+    return result;
+}
+
+/* :nodoc: */
+VALUE prof_call_trees_dump(VALUE self)
+{
+    VALUE result = rb_hash_new();
+    rb_hash_aset(result, ID2SYM(rb_intern("call_trees")), prof_call_trees_call_trees(self));
+
+    return result;
+}
+
+/* :nodoc: */
+VALUE prof_call_trees_load(VALUE self, VALUE data)
+{
+    prof_call_trees_t* call_trees_data = prof_get_call_trees(self);
+    call_trees_data->object = self;
+
+    VALUE call_trees = rb_hash_aref(data, ID2SYM(rb_intern("call_trees")));
+    for (int i = 0; i < rb_array_len(call_trees); i++)
+    {
+        VALUE call_tree = rb_ary_entry(call_trees, i);
+        prof_call_tree_t* call_tree_data = prof_get_call_tree(call_tree);
+        prof_add_call_tree(call_trees_data, call_tree_data);
+    }
+
+    return data;
+}
+
+void rp_init_call_trees()
+{
+    cRpCallTrees = rb_define_class_under(mProf, "CallTrees", rb_cObject);
+    rb_undef_method(CLASS_OF(cRpCallTrees), "new");
+    rb_define_alloc_func(cRpCallTrees, prof_call_trees_allocate);
+
+    rb_define_method(cRpCallTrees, "min_depth", prof_call_trees_min_depth, 0);
+
+    rb_define_method(cRpCallTrees, "call_trees", prof_call_trees_call_trees, 0);
+    rb_define_method(cRpCallTrees, "callers", prof_call_trees_callers, 0);
+    rb_define_method(cRpCallTrees, "callees", prof_call_trees_callees, 0);
+
+    rb_define_method(cRpCallTrees, "_dump_data", prof_call_trees_dump, 0);
+    rb_define_method(cRpCallTrees, "_load_data", prof_call_trees_load, 1);
+}

data/ext/ruby_prof/rp_call_trees.h

@@ -0,0 +1,28 @@
+/* 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 */
+
+#ifndef __RP_CALL_TREES_H__
+#define __RP_CALL_TREES_H__
+
+#include "ruby_prof.h"
+#include "rp_call_tree.h"
+
+   /* Array of call_tree objects */
+typedef struct prof_call_trees_t
+{
+    prof_call_tree_t** start;
+    prof_call_tree_t** end;
+    prof_call_tree_t** ptr;
+
+    VALUE object;
+} prof_call_trees_t;
+
+
+void rp_init_call_trees();
+prof_call_trees_t* prof_call_trees_create();
+void prof_call_trees_free(prof_call_trees_t* call_trees);
+prof_call_trees_t* prof_get_call_trees(VALUE self);
+void prof_add_call_tree(prof_call_trees_t* call_trees, prof_call_tree_t* call_tree);
+VALUE prof_call_trees_wrap(prof_call_trees_t* call_trees);
+
+#endif //__RP_CALL_TREES_H__

data/ext/ruby_prof/rp_measure_allocations.c

@@ -8,14 +8,12 @@
 static VALUE cMeasureAllocations;
 VALUE total_allocated_objects_key;
 
-static double
-measure_allocations_via_gc_stats(rb_trace_arg_t* trace_arg)
+static double measure_allocations_via_gc_stats(rb_trace_arg_t* trace_arg)
 {
-    return rb_gc_stat(total_allocated_objects_key);
+    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_via_tracing(rb_trace_arg_t* trace_arg)
 {
     static double result = 0;
 
@@ -30,17 +28,17 @@ measure_allocations_via_tracing(rb_trace_arg_t* trace_arg)
 
 prof_measurer_t* prof_measurer_allocations(bool track_allocations)
 {
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->mode = MEASURE_ALLOCATIONS;
-  measure->multiplier = 1;
-  measure->track_allocations = track_allocations;
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_ALLOCATIONS;
+    measure->multiplier = 1;
+    measure->track_allocations = track_allocations;
 
-  if (track_allocations)
-      measure->measure = measure_allocations_via_tracing;
-  else
-      measure->measure = measure_allocations_via_gc_stats;
+    if (track_allocations)
+        measure->measure = measure_allocations_via_tracing;
+    else
+        measure->measure = measure_allocations_via_gc_stats;
 
-  return measure;
+    return measure;
 }
 
 void rp_init_measure_allocations()

data/ext/ruby_prof/rp_measure_process_time.c

@@ -6,8 +6,7 @@
 
 static VALUE cMeasureProcessTime;
 
-static double
-measure_process_time(rb_trace_arg_t* trace_arg)
+static double measure_process_time(rb_trace_arg_t* trace_arg)
 {
 #if defined(_WIN32)
     FILETIME  createTime;
@@ -25,20 +24,19 @@ measure_process_time(rb_trace_arg_t* trace_arg)
     userTimeInt.LowPart = userTime.dwLowDateTime;
     userTimeInt.HighPart = userTime.dwHighDateTime;
 
-    return sysTimeInt.QuadPart + userTimeInt.QuadPart;
+    return (double)(sysTimeInt.QuadPart + userTimeInt.QuadPart);
 #elif !defined(CLOCK_PROCESS_CPUTIME_ID)
     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);
+    return usage.ru_stime.tv_sec + usage.ru_utime.tv_sec + ((usage.ru_stime.tv_usec + usage.ru_utime.tv_usec) / 1000000.0);
 #else
     struct timespec clock;
-    clock_gettime(CLOCK_PROCESS_CPUTIME_ID , &clock);
-    return clock.tv_sec + (clock.tv_nsec/1000000000.0);
+    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &clock);
+    return clock.tv_sec + (clock.tv_nsec / 1000000000.0);
 #endif
 }
 
-static double
-multiplier_process_time(void)
+static double multiplier_process_time(void)
 {
 #if defined(_WIN32)
     // Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
@@ -50,12 +48,12 @@ multiplier_process_time(void)
 
 prof_measurer_t* prof_measurer_process_time(bool track_allocations)
 {
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->mode = MEASURE_PROCESS_TIME;
-  measure->measure = measure_process_time;
-  measure->multiplier = multiplier_process_time();
-  measure->track_allocations = track_allocations;
-  return measure;
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_PROCESS_TIME;
+    measure->measure = measure_process_time;
+    measure->multiplier = multiplier_process_time();
+    measure->track_allocations = track_allocations;
+    return measure;
 }
 
 void rp_init_measure_process_time()