ruby-prof 0.18.0 → 1.2.0

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,266 @@
+/* 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 = DATA_PTR(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(prof_call_trees_t* call_trees)
+{
+    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)
+    {
+        RDATA(call_trees->object)->dmark = NULL;
+        RDATA(call_trees->object)->dfree = NULL;
+        RDATA(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)
+{
+    // 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;
+}
+
+VALUE prof_call_trees_wrap(prof_call_trees_t* call_trees)
+{
+    if (call_trees->object == Qnil)
+    {
+        call_trees->object = Data_Wrap_Struct(cRpCallTrees, prof_call_trees_mark, prof_call_trees_ruby_gc_free, 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(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(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 = DATA_PTR(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_cData);
+    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,29 @@
+/* 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_mark(prof_call_trees_t* call_trees);
+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

@@ -3,74 +3,48 @@
 
 /* :nodoc: */
 
-#include "ruby_prof.h"
+#include "rp_measurement.h"
 
 static VALUE cMeasureAllocations;
+VALUE total_allocated_objects_key;
 
-#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
-  unsigned LONG_LONG rb_os_allocated_objects();
-#endif
-
-#if defined(HAVE_RB_GC_STAT)
-size_t rb_gc_stat(VALUE key);
-
-#if RUBY_PROF_RUBY_VERSION >= 20200
-#define TOTAL_ALLOCATED_OBJECTS_STRING "total_allocated_objects"
-#else
-#define TOTAL_ALLOCATED_OBJECTS_STRING "total_allocated_object"
-#endif
-
-#endif
+static double measure_allocations_via_gc_stats(rb_trace_arg_t* trace_arg)
+{
+    return rb_gc_stat(total_allocated_objects_key);
+}
 
-static double
-measure_allocations()
+static double measure_allocations_via_tracing(rb_trace_arg_t* trace_arg)
 {
-#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
-#define MEASURE_ALLOCATIONS_ENABLED Qtrue
-    return rb_os_allocated_objects();
+    static double result = 0;
 
-#elif defined(HAVE_RB_GC_STAT) && RUBY_PROF_RUBY_VERSION >= 20100
-#define MEASURE_ALLOCATIONS_ENABLED Qtrue
-    static VALUE total_alloc_symbol = 0;
-    if (!total_alloc_symbol) {
-      total_alloc_symbol = ID2SYM(rb_intern_const(TOTAL_ALLOCATED_OBJECTS_STRING));
+    if (trace_arg)
+    {
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
+            result++;
     }
-    return rb_gc_stat(total_alloc_symbol);
-
-#else
-#define MEASURE_ALLOCATIONS_ENABLED Qfalse
-    return 0;
-#endif
+    return result;
 }
 
-
-prof_measurer_t* prof_measurer_allocations()
+prof_measurer_t* prof_measurer_allocations(bool track_allocations)
 {
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_allocations;
-  return measure;
-}
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_ALLOCATIONS;
+    measure->multiplier = 1;
+    measure->track_allocations = track_allocations;
 
-/* call-seq:
-     measure -> int
+    if (track_allocations)
+        measure->measure = measure_allocations_via_tracing;
+    else
+        measure->measure = measure_allocations_via_gc_stats;
 
-Returns the number of Ruby object allocations. */
-
-static VALUE
-prof_measure_allocations(VALUE self)
-{
-#if defined(HAVE_LONG_LONG)
-    return ULL2NUM(measure_allocations());
-#else
-    return ULONG2NUM(measure_allocations());
-#endif
+    return measure;
 }
 
 void rp_init_measure_allocations()
 {
+    total_allocated_objects_key = ID2SYM(rb_intern("total_allocated_objects"));
     rb_define_const(mProf, "ALLOCATIONS", INT2NUM(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);
 }

data/ext/ruby_prof/rp_measure_memory.c

@@ -1,77 +1,42 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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 */
 
 /* :nodoc: */
 
-#include "ruby_prof.h"
+#include "rp_measurement.h"
 
 static VALUE cMeasureMemory;
 
-
-#if defined(HAVE_RB_GC_ALLOCATED_SIZE)
-  VALUE rb_gc_allocated_size();
-#endif
-
-#if defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
-  size_t rb_gc_malloc_allocated_size();
-#endif
-
-#if defined(HAVE_RB_HEAP_TOTAL_MEM)
-  //FIXME: did not find the patch to check prototype, assuming it to return size_t
-  size_t rb_heap_total_mem();
-#endif
-
 static double
-measure_memory()
+measure_memory_via_tracing(rb_trace_arg_t* trace_arg)
 {
-#if defined(HAVE_RB_GC_ALLOCATED_SIZE)
-#define MEASURE_MEMORY_ENABLED Qtrue
-#if defined(HAVE_LONG_LONG)
-    return NUM2LL(rb_gc_allocated_size()) / 1024.0;
-#else
-    return NUM2ULONG(rb_gc_allocated_size()) / 1024.0;
-#endif
-
-#elif defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
-#define MEASURE_MEMORY_ENABLED Qtrue
-    return rb_gc_malloc_allocated_size() / 1024.0;
-
-#elif defined(HAVE_RB_GC_TOTAL_MALLOCED_BYTES)
-#define MEASURE_MEMORY_ENABLED Qtrue
-    return rb_gc_total_malloced_bytes() / 1024.0;
-
-#elif defined(HAVE_RB_HEAP_TOTAL_MEM)
-#define MEASURE_MEMORY_ENABLED Qtrue
-    return rb_heap_total_mem() / 1024.0;
-
-#else
-#define MEASURE_MEMORY_ENABLED Qfalse
-    return 0;
-#endif
+    static double result = 0;
+
+    if (trace_arg)
+    {
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
+        {
+            VALUE object = rb_tracearg_object(trace_arg);
+            result += rb_obj_memsize_of(object);
+        }
+    }
+    return result;
 }
 
-prof_measurer_t* prof_measurer_memory()
+prof_measurer_t* prof_measurer_memory(bool track_allocations)
 {
   prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_memory;
+  measure->mode = MEASURE_MEMORY;
+  measure->measure = measure_memory_via_tracing;
+  measure->multiplier = 1;
+  measure->track_allocations = true;
   return measure;
 }
 
-/* call-seq:
-   measure_process_time -> float
-
-Returns the process time.*/
-static VALUE
-prof_measure_memory(VALUE self)
-{
-    return rb_float_new(measure_memory());
-}
-
 void rp_init_measure_memory()
 {
     rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
-    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);
+    cMeasureMemory = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
 }