ruby-prof 0.13.1 → 1.4.2

data/ext/ruby_prof/rp_allocation.h

@@ -0,0 +1,31 @@
+/* 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_ALLOCATION_
+#define _RP_ALLOCATION_
+
+#include "ruby_prof.h"
+#include "rp_method.h"
+
+typedef struct prof_allocation_t
+{
+    st_data_t key;                    /* Key in hash table */
+    unsigned int klass_flags;         /* Information about the type of class */
+    VALUE klass;                      /* Klass that was created */
+    VALUE klass_name;                 /* Name of the class that was created */
+    VALUE source_file;                /* Line number where allocation happens */
+    int source_line;                  /* Line number where allocation happens */
+    int count;                        /* Number of allocations */
+    size_t memory;                    /* Amount of allocated memory */
+    VALUE object;                     /* Cache to wrapped object */
+} prof_allocation_t;
+
+void rp_init_allocation(void);
+void prof_allocation_free(prof_allocation_t* allocation);
+void prof_allocation_mark(void* data);
+VALUE prof_allocation_wrap(prof_allocation_t* allocation);
+prof_allocation_t* prof_allocation_get(VALUE self);
+prof_allocation_t* prof_allocate_increment(prof_method_t* method, rb_trace_arg_t* trace_arg);
+
+
+#endif //_RP_ALLOCATION_

data/ext/ruby_prof/rp_call_tree.c

@@ -0,0 +1,369 @@
+/* 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 */
+
+#include "rp_call_tree.h"
+
+#define INITIAL_CALL_TREES_SIZE 2
+
+VALUE cRpCallTree;
+
+/* =======  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* result = ALLOC(prof_call_tree_t);
+    result->method = method;
+    result->parent = parent;
+    result->object = Qnil;
+    result->visits = 0;
+    result->source_line = source_line;
+    result->source_file = source_file;
+    result->children = rb_st_init_numtable();
+    result->measurement = prof_measurement_create();
+
+    return result;
+}
+
+prof_call_tree_t* prof_call_tree_copy(prof_call_tree_t* other)
+{
+    prof_call_tree_t* result = ALLOC(prof_call_tree_t);
+    result->children = rb_st_init_numtable();
+    result->object = Qnil;
+    result->visits = 0;
+
+    result->method = other->method;
+    result->parent = other->parent;
+    result->source_line = other->source_line;
+    result->source_file = other->source_file;
+
+    result->measurement = prof_measurement_create();
+    result->measurement->called = other->measurement->called;
+    result->measurement->total_time = other->measurement->total_time;
+    result->measurement->self_time = other->measurement->self_time;
+    result->measurement->wait_time = other->measurement->wait_time;
+    result->measurement->object = Qnil;
+
+    return result;
+}
+
+void prof_call_tree_merge(prof_call_tree_t* result, prof_call_tree_t* other)
+{
+    result->measurement->called += other->measurement->called;
+    result->measurement->total_time += other->measurement->total_time;
+    result->measurement->self_time += other->measurement->self_time;
+    result->measurement->wait_time += other->measurement->wait_time;
+}
+
+static int prof_call_tree_collect_children(st_data_t key, st_data_t value, st_data_t result)
+{
+    prof_call_tree_t* call_tree = (prof_call_tree_t*)value;
+    VALUE arr = (VALUE)result;
+    rb_ary_push(arr, prof_call_tree_wrap(call_tree));
+    return ST_CONTINUE;
+}
+
+static int prof_call_tree_mark_children(st_data_t key, st_data_t value, st_data_t data)
+{
+    prof_call_tree_t* call_tree = (prof_call_tree_t*)value;
+    rb_st_foreach(call_tree->children, prof_call_tree_mark_children, data);
+    prof_call_tree_mark(call_tree);
+    return ST_CONTINUE;
+}
+
+void prof_call_tree_mark(void* data)
+{
+    if (!data)
+        return;
+
+    prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
+
+    if (call_tree->object != Qnil)
+        rb_gc_mark(call_tree->object);
+
+    if (call_tree->source_file != Qnil)
+        rb_gc_mark(call_tree->source_file);
+
+    prof_method_mark(call_tree->method);
+    prof_measurement_mark(call_tree->measurement);
+
+    // Recurse down through the whole call tree but only from the top node
+    // to avoid calling mark over and over and over.
+    if (!call_tree->parent)
+        rb_st_foreach(call_tree->children, prof_call_tree_mark_children, 0);
+}
+
+static void prof_call_tree_ruby_gc_free(void* data)
+{
+    if (data)
+    {
+        prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
+        call_tree->object = Qnil;
+    }
+}
+
+static int prof_call_tree_free_children(st_data_t key, st_data_t value, st_data_t data)
+{
+    prof_call_tree_t* call_tree = (prof_call_tree_t*)value;
+    prof_call_tree_free(call_tree);
+    return ST_CONTINUE;
+}
+
+void prof_call_tree_free(prof_call_tree_t* call_tree_data)
+{
+    /* Has this call info object been accessed by Ruby?  If
+       yes clean it up so to avoid a segmentation fault. */
+    if (call_tree_data->object != Qnil)
+    {
+        RTYPEDDATA(call_tree_data->object)->data = NULL;
+        call_tree_data->object = Qnil;
+    }
+
+    // Free children
+    rb_st_foreach(call_tree_data->children, prof_call_tree_free_children, 0);
+    rb_st_free_table(call_tree_data->children);
+
+    // Free measurement
+    prof_measurement_free(call_tree_data->measurement);
+
+    // Finally free self
+    xfree(call_tree_data);
+}
+
+size_t prof_call_tree_size(const void* data)
+{
+    return sizeof(prof_call_tree_t);
+}
+
+static const rb_data_type_t call_tree_type =
+{
+    .wrap_struct_name = "CallTree",
+    .function =
+    {
+        .dmark = prof_call_tree_mark,
+        .dfree = prof_call_tree_ruby_gc_free,
+        .dsize = prof_call_tree_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE prof_call_tree_wrap(prof_call_tree_t* call_tree)
+{
+    if (call_tree->object == Qnil)
+    {
+        call_tree->object = TypedData_Wrap_Struct(cRpCallTree, &call_tree_type, call_tree);
+    }
+    return call_tree->object;
+}
+
+static VALUE prof_call_tree_allocate(VALUE klass)
+{
+    prof_call_tree_t* call_tree = prof_call_tree_create(NULL, NULL, Qnil, 0);
+    call_tree->object = prof_call_tree_wrap(call_tree);
+    return call_tree->object;
+}
+
+prof_call_tree_t* prof_get_call_tree(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+    prof_call_tree_t* result = RTYPEDDATA_DATA(self);
+
+    if (!result)
+        rb_raise(rb_eRuntimeError, "This RubyProf::CallTree instance has already been freed, likely because its profile has been freed.");
+
+    return result;
+}
+
+/* =======  Call Tree Table   ========*/
+static size_t call_tree_table_insert(st_table* table, st_data_t key, prof_call_tree_t* val)
+{
+    return rb_st_insert(table, (st_data_t)key, (st_data_t)val);
+}
+
+prof_call_tree_t* call_tree_table_lookup(st_table* table, st_data_t key)
+{
+    st_data_t val;
+    if (rb_st_lookup(table, (st_data_t)key, &val))
+    {
+        return (prof_call_tree_t*)val;
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+uint32_t prof_call_figure_depth(prof_call_tree_t* call_tree_data)
+{
+    uint32_t result = 0;
+
+    while (call_tree_data->parent)
+    {
+        result++;
+        call_tree_data = call_tree_data->parent;
+    }
+
+    return result;
+}
+
+void prof_call_tree_add_parent(prof_call_tree_t* self, prof_call_tree_t* parent)
+{
+    prof_call_tree_add_child(parent, self);
+    self->parent = parent;
+}
+
+void prof_call_tree_add_child(prof_call_tree_t* self, prof_call_tree_t* child)
+{
+    call_tree_table_insert(self->children, child->method->key, child);
+}
+
+/* =======  RubyProf::CallTree   ========*/
+
+/* call-seq:
+   parent -> call_tree
+
+Returns the CallTree parent call_tree object (the method that called this method).*/
+static VALUE prof_call_tree_parent(VALUE self)
+{
+    prof_call_tree_t* call_tree = prof_get_call_tree(self);
+    if (call_tree->parent)
+        return prof_call_tree_wrap(call_tree->parent);
+    else
+        return Qnil;
+}
+
+/* call-seq:
+   callees -> array
+
+Returns an array of call info objects that this method called (ie, children).*/
+static VALUE prof_call_tree_children(VALUE self)
+{
+    prof_call_tree_t* call_tree = prof_get_call_tree(self);
+    VALUE result = rb_ary_new();
+    rb_st_foreach(call_tree->children, prof_call_tree_collect_children, result);
+    return result;
+}
+
+/* call-seq:
+   called -> MethodInfo
+
+Returns the target method. */
+static VALUE prof_call_tree_target(VALUE self)
+{
+    prof_call_tree_t* call_tree = prof_get_call_tree(self);
+    return prof_method_wrap(call_tree->method);
+}
+
+/* call-seq:
+   called -> Measurement
+
+Returns the measurement associated with this call_tree. */
+static VALUE prof_call_tree_measurement(VALUE self)
+{
+    prof_call_tree_t* call_tree = prof_get_call_tree(self);
+    return prof_measurement_wrap(call_tree->measurement);
+}
+
+/* call-seq:
+   depth -> int
+
+   returns the depth of this call info in the call graph */
+static VALUE prof_call_tree_depth(VALUE self)
+{
+    prof_call_tree_t* call_tree_data = prof_get_call_tree(self);
+    uint32_t depth = prof_call_figure_depth(call_tree_data);
+    return rb_int_new(depth);
+}
+
+/* call-seq:
+   source_file => string
+
+return the source file of the method
+*/
+static VALUE prof_call_tree_source_file(VALUE self)
+{
+    prof_call_tree_t* result = prof_get_call_tree(self);
+    return result->source_file;
+}
+
+/* call-seq:
+   line_no -> int
+
+   returns the line number of the method */
+static VALUE prof_call_tree_line(VALUE self)
+{
+    prof_call_tree_t* result = prof_get_call_tree(self);
+    return INT2FIX(result->source_line);
+}
+
+/* :nodoc: */
+static VALUE prof_call_tree_dump(VALUE self)
+{
+    prof_call_tree_t* call_tree_data = prof_get_call_tree(self);
+    VALUE result = rb_hash_new();
+
+    rb_hash_aset(result, ID2SYM(rb_intern("measurement")), prof_measurement_wrap(call_tree_data->measurement));
+
+    rb_hash_aset(result, ID2SYM(rb_intern("source_file")), call_tree_data->source_file);
+    rb_hash_aset(result, ID2SYM(rb_intern("source_line")), INT2FIX(call_tree_data->source_line));
+
+    rb_hash_aset(result, ID2SYM(rb_intern("parent")), prof_call_tree_parent(self));
+    rb_hash_aset(result, ID2SYM(rb_intern("children")), prof_call_tree_children(self));
+    rb_hash_aset(result, ID2SYM(rb_intern("target")), prof_call_tree_target(self));
+
+    return result;
+}
+
+/* :nodoc: */
+static VALUE prof_call_tree_load(VALUE self, VALUE data)
+{
+    VALUE target = Qnil;
+    VALUE parent = Qnil;
+    prof_call_tree_t* call_tree = prof_get_call_tree(self);
+    call_tree->object = self;
+
+    VALUE measurement = rb_hash_aref(data, ID2SYM(rb_intern("measurement")));
+    call_tree->measurement = prof_get_measurement(measurement);
+
+    call_tree->source_file = rb_hash_aref(data, ID2SYM(rb_intern("source_file")));
+    call_tree->source_line = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("source_line"))));
+
+    parent = rb_hash_aref(data, ID2SYM(rb_intern("parent")));
+    if (parent != Qnil)
+        call_tree->parent = prof_get_call_tree(parent);
+
+    VALUE callees = rb_hash_aref(data, ID2SYM(rb_intern("children")));
+    for (int i = 0; i < rb_array_len(callees); i++)
+    {
+        VALUE call_tree_object = rb_ary_entry(callees, i);
+        prof_call_tree_t* call_tree_data = prof_get_call_tree(call_tree_object);
+
+        st_data_t key = call_tree_data->method ? call_tree_data->method->key : method_key(Qnil, 0);
+        call_tree_table_insert(call_tree->children, key, call_tree_data);
+    }
+
+    target = rb_hash_aref(data, ID2SYM(rb_intern("target")));
+    call_tree->method = prof_get_method(target);
+
+    return data;
+}
+
+void rp_init_call_tree()
+{
+    /* CallTree */
+    cRpCallTree = rb_define_class_under(mProf, "CallTree", rb_cObject);
+    rb_undef_method(CLASS_OF(cRpCallTree), "new");
+    rb_define_alloc_func(cRpCallTree, prof_call_tree_allocate);
+
+    rb_define_method(cRpCallTree, "parent", prof_call_tree_parent, 0);
+    rb_define_method(cRpCallTree, "children", prof_call_tree_children, 0);
+    rb_define_method(cRpCallTree, "target", prof_call_tree_target, 0);
+    rb_define_method(cRpCallTree, "measurement", prof_call_tree_measurement, 0);
+
+    rb_define_method(cRpCallTree, "depth", prof_call_tree_depth, 0);
+    rb_define_method(cRpCallTree, "source_file", prof_call_tree_source_file, 0);
+    rb_define_method(cRpCallTree, "line", prof_call_tree_line, 0);
+
+    rb_define_method(cRpCallTree, "_dump_data", prof_call_tree_dump, 0);
+    rb_define_method(cRpCallTree, "_load_data", prof_call_tree_load, 1);
+}

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);
+}