ruby-prof 1.1.0 → 1.2.0

data/ext/ruby_prof/rp_profile.h

@@ -16,7 +16,6 @@ typedef struct
     VALUE paused;
 
     prof_measurer_t* measurer;
-    VALUE threads;
 
     VALUE tracepoints;
 

data/ext/ruby_prof/rp_stack.c

@@ -3,31 +3,12 @@
 
 #include "rp_stack.h"
 
-#define INITIAL_STACK_SIZE 32
+#define INITIAL_STACK_SIZE 16
 
-void
-prof_frame_pause(prof_frame_t *frame, double current_measurement)
+// Creates a stack of prof_frame_t to keep track of timings for active methods.
+prof_stack_t* prof_stack_create()
 {
-    if (frame && prof_frame_is_unpaused(frame))
-        frame->pause_time = current_measurement;
-}
-
-void
-prof_frame_unpause(prof_frame_t *frame, double current_measurement)
-{
-    if (frame && prof_frame_is_paused(frame))
-    {
-        frame->dead_time += (current_measurement - frame->pause_time);
-        frame->pause_time = -1;
-    }
-}
-
-/* Creates a stack of prof_frame_t to keep track
-   of timings for active methods. */
-prof_stack_t *
-prof_stack_create()
-{
-    prof_stack_t *stack = ALLOC(prof_stack_t);
+    prof_stack_t* stack = ALLOC(prof_stack_t);
     stack->start = ZALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
     stack->ptr = stack->start;
     stack->end = stack->start + INITIAL_STACK_SIZE;
@@ -35,22 +16,24 @@ prof_stack_create()
     return stack;
 }
 
-void
-prof_stack_free(prof_stack_t *stack)
+void prof_stack_free(prof_stack_t* stack)
 {
     xfree(stack->start);
     xfree(stack);
 }
 
-prof_frame_t *
-prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measurement, int paused)
+prof_frame_t* prof_stack_last(prof_stack_t* stack)
 {
-    prof_frame_t *result;
-    prof_frame_t* parent_frame;
+    if (stack->ptr == stack->start)
+        return NULL;
+    else
+        return stack->ptr - 1;
+}
 
-    /* Is there space on the stack?  If not, double
-     its size. */
-    if (stack->ptr == stack->end - 1)
+void prof_stack_verify_size(prof_stack_t* stack)
+{
+    // Is there space on the stack?  If not, double its size.
+    if (stack->ptr == stack->end)
     {
         size_t len = stack->ptr - stack->start;
         size_t new_capacity = (stack->end - stack->start) * 2;
@@ -60,14 +43,53 @@ prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measure
         stack->ptr = stack->start + len;
         stack->end = stack->start + new_capacity;
     }
+}
+
+prof_frame_t* prof_stack_push(prof_stack_t* stack)
+{
+    prof_stack_verify_size(stack);
 
-    parent_frame = stack->ptr;
+    prof_frame_t* result = stack->ptr;
     stack->ptr++;
+    return result;
+}
+
+prof_frame_t* prof_stack_pop(prof_stack_t* stack)
+{
+    prof_frame_t* result = prof_stack_last(stack);
+    if (result)
+        stack->ptr--;
+
+    return result;
+}
+
+// ----------------  Frame Methods  ----------------------------
+void prof_frame_pause(prof_frame_t* frame, double current_measurement)
+{
+    if (frame && prof_frame_is_unpaused(frame))
+        frame->pause_time = current_measurement;
+}
+
+void prof_frame_unpause(prof_frame_t* frame, double current_measurement)
+{
+    if (prof_frame_is_paused(frame))
+    {
+        frame->dead_time += (current_measurement - frame->pause_time);
+        frame->pause_time = -1;
+    }
+}
+
+prof_frame_t* prof_frame_current(prof_stack_t* stack)
+{
+    return prof_stack_last(stack);
+}
 
-    result = stack->ptr;
-    result->call_info = call_info;
-    result->call_info->depth = (int)(stack->ptr - stack->start); // shortening of 64 bit into 32;
-    result->passes = 0;
+prof_frame_t* prof_frame_push(prof_stack_t* stack, prof_call_tree_t* call_tree, double measurement, bool paused)
+{
+    prof_frame_t* parent_frame = prof_stack_last(stack);
+    prof_frame_t* result = prof_stack_push(stack);
+
+    result->call_tree = call_tree;
 
     result->start_time = measurement;
     result->pause_time = -1; // init as not paused.
@@ -78,21 +100,22 @@ prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measure
     result->source_file = Qnil;
     result->source_line = 0;
 
-    call_info->measurement->called++;
-    call_info->visits++;
+    call_tree->measurement->called++;
+    call_tree->visits++;
 
-    if (call_info->method->visits > 0)
+    if (call_tree->method->visits > 0)
     {
-        call_info->method->recursive = true;
+        call_tree->method->recursive = true;
     }
-    call_info->method->measurement->called++;
-    call_info->method->visits++;
+    call_tree->method->measurement->called++;
+    call_tree->method->visits++;
 
     // Unpause the parent frame, if it exists.
     // If currently paused then:
     //   1) The child frame will begin paused.
     //   2) The parent will inherit the child's dead time.
-    prof_frame_unpause(parent_frame, measurement);
+    if (parent_frame)
+        prof_frame_unpause(parent_frame, measurement);
 
     if (paused)
     {
@@ -103,92 +126,77 @@ prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measure
     return result;
 }
 
-prof_frame_t *
-prof_stack_pop(prof_stack_t *stack, double measurement)
+prof_frame_t* prof_frame_unshift(prof_stack_t* stack, prof_call_tree_t* parent_call_tree, prof_call_tree_t* call_tree, double measurement)
 {
-  prof_frame_t *frame;
-  prof_frame_t *parent_frame;
-  prof_call_info_t *call_info;
+    if (prof_stack_last(stack))
+        rb_raise(rb_eRuntimeError, "Stach unshift can only be called with an empty stack");
 
-  double total_time;
-  double self_time;
+    parent_call_tree->measurement->total_time = call_tree->measurement->total_time;
+    parent_call_tree->measurement->self_time = 0;
+    parent_call_tree->measurement->wait_time = call_tree->measurement->wait_time;
 
-  if (stack->ptr == stack->start)
-      return NULL;
+    parent_call_tree->method->measurement->total_time += call_tree->measurement->total_time;
+    parent_call_tree->method->measurement->wait_time += call_tree->measurement->wait_time;
 
-  frame = stack->ptr;
-
-  /* Match passes until we reach the frame itself. */
-  if (prof_frame_is_pass(frame))
-  {
-    frame->passes--;
-    /* Additional frames can be consumed. See pop_frames(). */
-    return frame;
-  }
-
-  /* Consume this frame. */
-  stack->ptr--;
-
-  parent_frame = stack->ptr;
+    return prof_frame_push(stack, parent_call_tree, measurement, false);
+}
 
-  /* Calculate the total time this method took */
-  prof_frame_unpause(frame, measurement);
-  
-  total_time = measurement - frame->start_time - frame->dead_time;
-  self_time = total_time - frame->child_time - frame->wait_time;
+prof_frame_t* prof_frame_pop(prof_stack_t* stack, double measurement)
+{
+    prof_frame_t* frame = prof_stack_pop(stack);
 
-  /* Update information about the current method */
-  call_info = frame->call_info;
+    if (!frame)
+        return NULL;
 
-  // Update method measurement
-  call_info->method->measurement->self_time += self_time;
-  call_info->method->measurement->wait_time += frame->wait_time;
-  if (call_info->method->visits == 1)
-    call_info->method->measurement->total_time += total_time;
+    /* Calculate the total time this method took */
+    prof_frame_unpause(frame, measurement);
 
-  call_info->method->visits--;
+    double total_time = measurement - frame->start_time - frame->dead_time;
+    double self_time = total_time - frame->child_time - frame->wait_time;
 
-  // Update method measurement
-  call_info->measurement->self_time += self_time;
-  call_info->measurement->wait_time += frame->wait_time;
-  if (call_info->visits == 1)
-      call_info->measurement->total_time += total_time;
+    /* Update information about the current method */
+    prof_call_tree_t* call_tree = frame->call_tree;
 
-  call_info->visits--;
+    // Update method measurement
+    call_tree->method->measurement->self_time += self_time;
+    call_tree->method->measurement->wait_time += frame->wait_time;
+    if (call_tree->method->visits == 1)
+        call_tree->method->measurement->total_time += total_time;
 
-  if (parent_frame)
-  {
-      parent_frame->child_time += total_time;
-      parent_frame->dead_time += frame->dead_time;
-  }
+    call_tree->method->visits--;
 
-  return frame;
-}
+    // Update method measurement
+    call_tree->measurement->self_time += self_time;
+    call_tree->measurement->wait_time += frame->wait_time;
+    if (call_tree->visits == 1)
+        call_tree->measurement->total_time += total_time;
 
-prof_frame_t *
-prof_stack_pass(prof_stack_t *stack)
-{
-    prof_frame_t* frame = stack->ptr;
-    if (frame)
+    call_tree->visits--;
+    
+    prof_frame_t* parent_frame = prof_stack_last(stack);
+    if (parent_frame)
     {
-        frame->passes++;
+        parent_frame->child_time += total_time;
+        parent_frame->dead_time += frame->dead_time;
     }
+
+    frame->source_file = Qnil;
+
     return frame;
 }
 
-prof_method_t*
-prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line)
+prof_method_t* prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line)
 {
     prof_frame_t* frame = stack->ptr;
     while (frame >= stack->start)
     {
-        if (!frame->call_info)
+        if (!frame->call_tree)
             return NULL;
 
-        if (rb_str_equal(source_file, frame->call_info->method->source_file) &&
-            source_line >= frame->call_info->method->source_line)
+        if (rb_str_equal(source_file, frame->call_tree->method->source_file) &&
+            source_line >= frame->call_tree->method->source_line)
         {
-            return frame->call_info->method;
+            return frame->call_tree->method;
         }
         frame--;
     }

data/ext/ruby_prof/rp_stack.h

@@ -5,20 +5,19 @@
 #define __RP_STACK__
 
 #include "ruby_prof.h"
-#include "rp_call_info.h"
+#include "rp_call_tree.h"
 
-/* Temporary object that maintains profiling information
-   for active methods.  They are created and destroyed
-   as the program moves up and down its stack. */
+   /* Temporary object that maintains profiling information
+      for active methods.  They are created and destroyed
+      as the program moves up and down its stack. */
 typedef struct
 {
     /* Caching prof_method_t values significantly
        increases performance. */
-    prof_call_info_t *call_info;
+    prof_call_tree_t* call_tree;
 
     VALUE source_file;
     unsigned int source_line;
-    unsigned int passes; /* Count of "pass" frames, _after_ this one. */
 
     double start_time;
     double switch_time;  /* Time at switch to different thread */
@@ -28,9 +27,6 @@ typedef struct
     double dead_time; // Time to ignore (i.e. total amount of time between pause/resume blocks)
 } prof_frame_t;
 
-#define prof_frame_is_real(f) ((f)->passes == 0)
-#define prof_frame_is_pass(f) ((f)->passes > 0)
-
 #define prof_frame_is_paused(f) (f->pause_time >= 0)
 #define prof_frame_is_unpaused(f) (f->pause_time < 0)
 
@@ -40,17 +36,18 @@ void prof_frame_unpause(prof_frame_t*, double current_measurement);
 /* Current stack of active methods.*/
 typedef struct
 {
-    prof_frame_t *start;
-    prof_frame_t *end;
-    prof_frame_t *ptr;
+    prof_frame_t* start;
+    prof_frame_t* end;
+    prof_frame_t* ptr;
 } prof_stack_t;
 
-prof_stack_t *prof_stack_create(void);
-void prof_stack_free(prof_stack_t *stack);
+prof_stack_t* prof_stack_create(void);
+void prof_stack_free(prof_stack_t* stack);
 
-prof_frame_t *prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measurement, int paused);
-prof_frame_t *prof_stack_pop(prof_stack_t *stack, double measurement);
-prof_frame_t *prof_stack_pass(prof_stack_t *stack);
-prof_method_t *prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line);
+prof_frame_t* prof_frame_current(prof_stack_t* stack);
+prof_frame_t* prof_frame_push(prof_stack_t* stack, prof_call_tree_t* call_tree, double measurement, bool paused);
+prof_frame_t* prof_frame_unshift(prof_stack_t* stack, prof_call_tree_t* parent_call_tree, prof_call_tree_t* call_tree, double measurement);
+prof_frame_t* prof_frame_pop(prof_stack_t* stack, double measurement);
+prof_method_t* prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line);
 
 #endif //__RP_STACK__

data/ext/ruby_prof/rp_thread.c

@@ -14,21 +14,20 @@ You cannot create an instance of RubyProf::Thread, instead you access it from a
     thread.root_methods.sort.each do |method|
       puts method.total_time
     end
-  end
-*/
+  end */
 
 #include "rp_thread.h"
 #include "rp_profile.h"
 
 VALUE cRpThread;
 
-/* ======   thread_data_t  ====== */
-thread_data_t*
-thread_data_create(void)
+// ======   thread_data_t  ====== 
+thread_data_t* thread_data_create(void)
 {
     thread_data_t* result = ALLOC(thread_data_t);
     result->stack = prof_stack_create();
     result->method_table = method_table_create();
+    result->call_tree = NULL;
     result->object = Qnil;
     result->methods = Qnil;
     result->fiber_id = Qnil;
@@ -38,81 +37,87 @@ thread_data_create(void)
     return result;
 }
 
-static void
-prof_thread_free(thread_data_t* thread_data)
+static int mark_methods(st_data_t key, st_data_t value, st_data_t result)
 {
-    /* Has this method object been accessed by Ruby?  If
-       yes then set its data to nil to avoid a segmentation fault on the next mark and sweep. */
-    if (thread_data->object != Qnil)
-    {
-        RDATA(thread_data->object)->dmark = NULL;
-        RDATA(thread_data->object)->dfree = NULL;
-        RDATA(thread_data->object)->data = NULL;
-        thread_data->object = Qnil;
-    }
-    
-    method_table_free(thread_data->method_table);
-    prof_stack_free(thread_data->stack);
-
-
-    xfree(thread_data);
-}
-
-static int
-mark_methods(st_data_t key, st_data_t value, st_data_t result)
-{
-    prof_method_t *method = (prof_method_t *) value;
+    prof_method_t* method = (prof_method_t*)value;
     prof_method_mark(method);
     return ST_CONTINUE;
 }
 
-size_t
-prof_thread_size(const void *data)
+size_t prof_thread_size(const void* data)
 {
-    return sizeof(prof_call_info_t);
+    return sizeof(prof_call_tree_t);
 }
 
-void
-prof_thread_mark(void *data)
+void prof_thread_mark(void* data)
 {
-    thread_data_t *thread = (thread_data_t*)data;
-    
+    thread_data_t* thread = (thread_data_t*)data;
+
     if (thread->object != Qnil)
         rb_gc_mark(thread->object);
-    
+
+    rb_gc_mark(thread->fiber);
+
     if (thread->methods != Qnil)
         rb_gc_mark(thread->methods);
-    
+
     if (thread->fiber_id != Qnil)
         rb_gc_mark(thread->fiber_id);
-    
+
     if (thread->thread_id != Qnil)
         rb_gc_mark(thread->thread_id);
-    
-    st_foreach(thread->method_table, mark_methods, 0);
+
+    if (thread->call_tree)
+        prof_call_tree_mark(thread->call_tree);
+
+    rb_st_foreach(thread->method_table, mark_methods, 0);
 }
 
+void prof_thread_ruby_gc_free(void* data)
+{
+    thread_data_t* thread_data = (thread_data_t*)data;
+    thread_data->object = Qnil;
+}
+
+static void prof_thread_free(thread_data_t* thread_data)
+{
+    /* Has this method object been accessed by Ruby?  If
+       yes then set its data to nil to avoid a segmentation fault on the next mark and sweep. */
+    if (thread_data->object != Qnil)
+    {
+        RDATA(thread_data->object)->dmark = NULL;
+        RDATA(thread_data->object)->dfree = NULL;
+        RDATA(thread_data->object)->data = NULL;
+        thread_data->object = Qnil;
+    }
+
+    method_table_free(thread_data->method_table);
+
+    if (thread_data->call_tree)
+        prof_call_tree_free(thread_data->call_tree);
+
+    prof_stack_free(thread_data->stack);
+
+    xfree(thread_data);
+}
 
-VALUE
-prof_thread_wrap(thread_data_t *thread)
+VALUE prof_thread_wrap(thread_data_t* thread)
 {
     if (thread->object == Qnil)
     {
-        thread->object = Data_Wrap_Struct(cRpThread, prof_thread_mark, NULL, thread);
+        thread->object = Data_Wrap_Struct(cRpThread, prof_thread_mark, prof_thread_ruby_gc_free, thread);
     }
     return thread->object;
 }
 
-static VALUE
-prof_thread_allocate(VALUE klass)
+static VALUE prof_thread_allocate(VALUE klass)
 {
     thread_data_t* thread_data = thread_data_create();
     thread_data->object = prof_thread_wrap(thread_data);
     return thread_data->object;
 }
 
-static thread_data_t*
-prof_get_thread(VALUE self)
+static thread_data_t* prof_get_thread(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
        ending up in endless recursion. */
@@ -123,38 +128,33 @@ prof_get_thread(VALUE self)
     return result;
 }
 
-/* ======   Thread Table  ====== */
-/* The thread table is hash keyed on ruby thread_id that stores instances
-   of thread_data_t. */
+// ======   Thread Table  ======
+// The thread table is hash keyed on ruby fiber_id that stores instances of thread_data_t. 
 
-st_table *
-threads_table_create()
+st_table* threads_table_create()
 {
-    return st_init_numtable();
+    return rb_st_init_numtable();
 }
 
-static int
-thread_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
+static int thread_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
 {
     prof_thread_free((thread_data_t*)value);
     return ST_CONTINUE;
 }
 
-void
-threads_table_free(st_table *table)
+void threads_table_free(st_table* table)
 {
-    st_foreach(table, thread_table_free_iterator, 0);
-    st_free_table(table);
+    rb_st_foreach(table, thread_table_free_iterator, 0);
+    rb_st_free_table(table);
 }
 
-thread_data_t *
-threads_table_lookup(void *prof, VALUE fiber)
+thread_data_t* threads_table_lookup(void* prof, VALUE fiber)
 {
-    prof_profile_t *profile = prof;
+    prof_profile_t* profile = prof;
     thread_data_t* result = NULL;
     st_data_t val;
 
-    if (st_lookup(profile->threads_tbl, fiber, &val))
+    if (rb_st_lookup(profile->threads_tbl, fiber, &val))
     {
         result = (thread_data_t*)val;
     }
@@ -162,24 +162,23 @@ threads_table_lookup(void *prof, VALUE fiber)
     return result;
 }
 
-thread_data_t*
-threads_table_insert(void *prof, VALUE fiber)
+thread_data_t* threads_table_insert(void* prof, VALUE fiber)
 {
-    prof_profile_t *profile = prof;
-    thread_data_t *result = thread_data_create();
+    prof_profile_t* profile = prof;
+    thread_data_t* result = thread_data_create();
     VALUE thread = rb_thread_current();
 
     result->fiber = fiber;
     result->fiber_id = rb_obj_id(fiber);
     result->thread_id = rb_obj_id(thread);
-    st_insert(profile->threads_tbl, (st_data_t)fiber, (st_data_t)result);
+    rb_st_insert(profile->threads_tbl, (st_data_t)fiber, (st_data_t)result);
 
     // Are we tracing this thread?
-    if (profile->include_threads_tbl && !st_lookup(profile->include_threads_tbl, thread, 0))
+    if (profile->include_threads_tbl && !rb_st_lookup(profile->include_threads_tbl, thread, 0))
     {
-        result->trace= false;
+        result->trace = false;
     }
-    else if (profile->exclude_threads_tbl && st_lookup(profile->exclude_threads_tbl, thread, 0))
+    else if (profile->exclude_threads_tbl && rb_st_lookup(profile->exclude_threads_tbl, thread, 0))
     {
         result->trace = false;
     }
@@ -187,25 +186,28 @@ threads_table_insert(void *prof, VALUE fiber)
     {
         result->trace = true;
     }
-    
+
     return result;
 }
 
-void
-switch_thread(void *prof, thread_data_t *thread_data, double measurement)
+// ======   Profiling Methods  ======
+void switch_thread(void* prof, thread_data_t* thread_data, double measurement)
 {
-    prof_profile_t *profile = prof;
+    prof_profile_t* profile = prof;
 
     /* Get current frame for this thread */
-    prof_frame_t* frame = thread_data->stack->ptr;
-    frame->wait_time += measurement - frame->switch_time;
-    frame->switch_time = measurement;
- 
+    prof_frame_t* frame = prof_frame_current(thread_data->stack);
+    if (frame)
+    {
+        frame->wait_time += measurement - frame->switch_time;
+        frame->switch_time = 0;
+    }
+
     /* Save on the last thread the time of the context switch
        and reset this thread's last context switch to 0.*/
     if (profile->last_thread_data)
     {
-        prof_frame_t* last_frame = profile->last_thread_data->stack->ptr;
+        prof_frame_t* last_frame = prof_frame_current(profile->last_thread_data->stack);
         if (last_frame)
             last_frame->switch_time = measurement;
     }
@@ -215,10 +217,10 @@ switch_thread(void *prof, thread_data_t *thread_data, double measurement)
 
 int pause_thread(st_data_t key, st_data_t value, st_data_t data)
 {
-    thread_data_t* thread_data = (thread_data_t *) value;
+    thread_data_t* thread_data = (thread_data_t*)value;
     prof_profile_t* profile = (prof_profile_t*)data;
 
-    prof_frame_t* frame = thread_data->stack->ptr;
+    prof_frame_t* frame = prof_frame_current(thread_data->stack);
     prof_frame_pause(frame, profile->measurement_at_pause_resume);
 
     return ST_CONTINUE;
@@ -226,37 +228,33 @@ int pause_thread(st_data_t key, st_data_t value, st_data_t data)
 
 int unpause_thread(st_data_t key, st_data_t value, st_data_t data)
 {
-    thread_data_t* thread_data = (thread_data_t *) value;
+    thread_data_t* thread_data = (thread_data_t*)value;
     prof_profile_t* profile = (prof_profile_t*)data;
 
-    prof_frame_t* frame = thread_data->stack->ptr;
+    prof_frame_t* frame = prof_frame_current(thread_data->stack);
     prof_frame_unpause(frame, profile->measurement_at_pause_resume);
 
     return ST_CONTINUE;
 }
 
-static int
-collect_methods(st_data_t key, st_data_t value, st_data_t result)
+// ======   Helper Methods  ======
+static int collect_methods(st_data_t key, st_data_t value, st_data_t result)
 {
     /* Called for each method stored in a thread's method table.
        We want to store the method info information into an array.*/
-    VALUE methods = (VALUE) result;
-    prof_method_t *method = (prof_method_t *) value;
-
-    if (!method->excluded)
-    {
-      rb_ary_push(methods, prof_method_wrap(method));
-    }
+    VALUE methods = (VALUE)result;
+    prof_method_t* method = (prof_method_t*)value;
+    rb_ary_push(methods, prof_method_wrap(method));
 
     return ST_CONTINUE;
 }
 
+// ======   RubyProf::Thread  ======
 /* call-seq:
    id -> number
 
 Returns the thread id of this thread. */
-static VALUE
-prof_thread_id(VALUE self)
+static VALUE prof_thread_id(VALUE self)
 {
     thread_data_t* thread = prof_get_thread(self);
     return thread->thread_id;
@@ -266,57 +264,66 @@ prof_thread_id(VALUE self)
    fiber_id -> number
 
 Returns the fiber id of this thread. */
-static VALUE
-prof_fiber_id(VALUE self)
+static VALUE prof_fiber_id(VALUE self)
 {
     thread_data_t* thread = prof_get_thread(self);
     return thread->fiber_id;
 }
 
+/* call-seq:
+   call_tree -> CallTree
+
+Returns the root of the call tree. */
+static VALUE prof_call_tree(VALUE self)
+{
+    thread_data_t* thread = prof_get_thread(self);
+    return prof_call_tree_wrap(thread->call_tree);
+}
+
 /* call-seq:
    methods -> [RubyProf::MethodInfo]
 
 Returns an array of methods that were called from this
 thread during program execution. */
-static VALUE
-prof_thread_methods(VALUE self)
+static VALUE prof_thread_methods(VALUE self)
 {
     thread_data_t* thread = prof_get_thread(self);
     if (thread->methods == Qnil)
     {
         thread->methods = rb_ary_new();
-        st_foreach(thread->method_table, collect_methods, thread->methods);
+        rb_st_foreach(thread->method_table, collect_methods, thread->methods);
     }
     return thread->methods;
 }
 
 /* :nodoc: */
-static VALUE
-prof_thread_dump(VALUE self)
+static VALUE prof_thread_dump(VALUE self)
 {
     thread_data_t* thread_data = DATA_PTR(self);
 
     VALUE result = rb_hash_new();
     rb_hash_aset(result, ID2SYM(rb_intern("fiber_id")), thread_data->fiber_id);
     rb_hash_aset(result, ID2SYM(rb_intern("methods")), prof_thread_methods(self));
+    rb_hash_aset(result, ID2SYM(rb_intern("call_tree")), prof_call_tree(self));
 
     return result;
 }
 
 /* :nodoc: */
-static VALUE
-prof_thread_load(VALUE self, VALUE data)
+static VALUE prof_thread_load(VALUE self, VALUE data)
 {
     thread_data_t* thread_data = DATA_PTR(self);
-    thread_data->object = self;
+
+    VALUE call_tree = rb_hash_aref(data, ID2SYM(rb_intern("call_tree")));
+    thread_data->call_tree = prof_get_call_tree(call_tree);
 
     thread_data->fiber_id = rb_hash_aref(data, ID2SYM(rb_intern("fiber_id")));
-    VALUE methods = rb_hash_aref(data, ID2SYM(rb_intern("methods")));
 
+    VALUE methods = rb_hash_aref(data, ID2SYM(rb_intern("methods")));
     for (int i = 0; i < rb_array_len(methods); i++)
     {
         VALUE method = rb_ary_entry(methods, i);
-        prof_method_t *method_data = DATA_PTR(method);
+        prof_method_t* method_data = DATA_PTR(method);
         method_table_insert(thread_data->method_table, method_data->key, method_data);
     }
 
@@ -330,6 +337,7 @@ void rp_init_thread(void)
     rb_define_alloc_func(cRpThread, prof_thread_allocate);
 
     rb_define_method(cRpThread, "id", prof_thread_id, 0);
+    rb_define_method(cRpThread, "call_tree", prof_call_tree, 0);
     rb_define_method(cRpThread, "fiber_id", prof_fiber_id, 0);
     rb_define_method(cRpThread, "methods", prof_thread_methods, 0);
     rb_define_method(cRpThread, "_dump_data", prof_thread_dump, 0);