ruby-prof 1.7.1 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fbaeec67f3e4771202c58f1902376076dc8e9185e0923e0bad648f6fdaae8a5
-  data.tar.gz: be5b6c0740418aae93dc7cbe90d13d992b71ffe822cf7332075c1930f3cb6501
+  metadata.gz: 5755a16ded5472a0dd58f411dd22a1da4213136a8050eef0c9f392f558a86970
+  data.tar.gz: d8b67fcd1b208fe448864b24b7c76630bce578eda1f4588ef11e0644987d9632
 SHA512:
-  metadata.gz: 40403f7f034a87120c6a7328057ff9ad2e922f0c1c8aa080720c6f70c8ae84a08bc71bfaecfe040f38f5ebdfb38497326c84136fe2e5ce6f7e4fd775f368739f
-  data.tar.gz: e5e9def95a8b0240ce330f1d093f549ea9555cfb491d45ba06647c3112dd55229244fb8d42ec871b81cad0b72bb1c9a5e49df1db0ff8008060a197d381acbe8e
+  metadata.gz: d1d8167a024ac0ec233d0ad2e1638bde210c4279caf28c8d9c091c371e23eb5d4c6aa54bb9aecb60a3ae04611a03e4c3fb504140e4d0943e3b34467cebf75af4
+  data.tar.gz: 75e8cd9be4f9cb5bb7c82ef8460b2f0c7f807325d9e65df4389063fce416991908aaf09cf58d6295d8603f5231a1af4780ea099159cb486daa0e6edcae28c984

data/CHANGES

@@ -1,3 +1,11 @@
+1.7.2 (2025-05-21)
+=====================
+* Fix compiling on Ubuntu and Arch Linux
+* Update tests for Ruby 3.4
+* Remove tests for Ruby 3.1
+* Update MacOS to use clock_gettime (same as Linux) instead of proprietary mach_absolute_time API
+* Add CMake support
+
 1.7.1 (2024-10-19)
 =====================
 * Fix crashes when calling merge due to inconsistent method keys (Chris Heald)

data/ext/ruby_prof/extconf.rb

@@ -1,22 +1,23 @@
-require "mkmf"
-
-# Let's go with a modern version of C! want to intermix declarations and code (ie, don't define
-# all variables at the top of the method). If using Visual Studio, you'll need 2019 version
-# 16.8 or higher
-if RUBY_PLATFORM =~ /mswin/
-  $CFLAGS += ' /std:c11'
-else
-  $CFLAGS += ' -std=c11'
-end
-
-# For gcc add -s to strip symbols, reducing library size from 17MB to 78KB (at least on Windows with mingw64)
-if RUBY_PLATFORM !~ /mswin/
-  $LDFLAGS += ' -s'
-end
-
-# And since we are using C99 we want to disable Ruby sending these warnings to gcc
-if CONFIG['warnflags']
-  CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
-end
-
-create_makefile("ruby_prof")
+require "mkmf"
+
+# Let's go with a modern version of C! want to intermix declarations and code (ie, don't define
+# all variables at the top of the method). If using Visual Studio, you'll need 2019 version
+# 16.8 or higher
+if RUBY_PLATFORM =~ /mswin/
+  $CFLAGS += ' /std:c11'
+else
+  # Need -D_POSIX_C_SOURCE=199309L for clock_gettime
+  $CFLAGS += ' -std=c11 -D_POSIX_C_SOURCE=199309L'
+end
+
+# For gcc add -s to strip symbols, reducing library size from 17MB to 78KB (at least on Windows with mingw64)
+if RUBY_PLATFORM !~ /mswin/
+  $LDFLAGS += ' -s'
+end
+
+# And since we are using C99 we want to disable Ruby sending these warnings to gcc
+if CONFIG['warnflags']
+  CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+end
+
+create_makefile("ruby_prof")

data/ext/ruby_prof/rp_call_trees.c

@@ -1,296 +1,296 @@
-/* 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_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(void)
-{
-    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(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_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_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);
-    }
-
-    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_tree_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_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, 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, 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(void)
-{
-    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);
-}
+/* 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_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(void)
+{
+    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(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_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_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);
+    }
+
+    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_tree_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_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, 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, 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(void)
+{
+    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);
+}