ruby-prof 1.4.5-x64-mingw-ucrt → 1.5.0-x64-mingw-ucrt

data/ext/ruby_prof/rp_method.c

@@ -40,7 +40,7 @@ VALUE resolve_klass(VALUE klass, unsigned int* klass_flags)
             *klass_flags |= kObjectSingleton;
             result = rb_class_superclass(klass);
         }
-        /* Ok, this could be other things like an array made put onto
+        /* Ok, this could be other things like an array put onto
            a singleton object (yeah, it happens, see the singleton
            objects test case). */
         else
@@ -97,7 +97,12 @@ st_data_t method_key(VALUE klass, VALUE msym)
         resolved_klass = RBASIC(klass)->klass;
     }
 
-    return (resolved_klass << 4) + (msym);
+    st_data_t hash = rb_hash_start(0);
+    hash = rb_hash_uint(hash, resolved_klass);
+    hash = rb_hash_uint(hash, msym);
+    hash = rb_hash_end(hash);
+
+    return hash;
 }
 
 /* ======   Allocation Table  ====== */
@@ -309,6 +314,45 @@ created.  RubyProf::MethodInfo objects can be accessed via
 the RubyProf::Profile object.
 */
 
+/* call-seq:
+   new(klass, method_name) -> method_info
+
+Creates a new MethodInfo instance. +Klass+ should be a reference to
+a Ruby class and +method_name+ a symbol identifying one of its instance methods.*/
+static VALUE prof_method_initialize(VALUE self, VALUE klass, VALUE method_name)
+{
+  prof_method_t* method_ptr = prof_get_method(self);
+  method_ptr->klass = klass;
+  method_ptr->method_name = method_name;
+
+  // Setup method key
+  method_ptr->key = method_key(klass, method_name);
+
+  // Get method object
+  VALUE ruby_method = rb_funcall(klass, rb_intern("instance_method"), 1, method_name);
+
+  // Get source file and line number
+  VALUE location_array = rb_funcall(ruby_method, rb_intern("source_location"), 0);
+  if (location_array != Qnil && RARRAY_LEN(location_array) == 2)
+  {
+    method_ptr->source_file = rb_ary_entry(location_array, 0);
+    method_ptr->source_line = NUM2INT(rb_ary_entry(location_array, 1));
+  }
+
+  return self;
+}
+
+/* call-seq:
+   hash -> hash
+
+Returns the hash key for this method info. The hash key is calculated based on the
+klass name and method name */
+static VALUE prof_method_hash(VALUE self)
+{
+  prof_method_t* method_ptr = prof_get_method(self);
+  return ULL2NUM(method_ptr->key);
+}
+
 /* call-seq:
    allocations -> array
 
@@ -334,7 +378,7 @@ static VALUE prof_method_measurement(VALUE self)
 /* call-seq:
    source_file => string
 
-return the source file of the method
+Returns the source file of the method
 */
 static VALUE prof_method_source_file(VALUE self)
 {
@@ -420,7 +464,7 @@ static VALUE prof_method_dump(VALUE self)
     rb_hash_aset(result, ID2SYM(rb_intern("klass_flags")), INT2FIX(method_data->klass_flags));
     rb_hash_aset(result, ID2SYM(rb_intern("method_name")), method_data->method_name);
 
-    rb_hash_aset(result, ID2SYM(rb_intern("key")), INT2FIX(method_data->key));
+    rb_hash_aset(result, ID2SYM(rb_intern("key")), ULL2NUM(method_data->key));
     rb_hash_aset(result, ID2SYM(rb_intern("recursive")), prof_method_recursive(self));
     rb_hash_aset(result, ID2SYM(rb_intern("source_file")), method_data->source_file);
     rb_hash_aset(result, ID2SYM(rb_intern("source_line")), INT2FIX(method_data->source_line));
@@ -441,7 +485,7 @@ static VALUE prof_method_load(VALUE self, VALUE data)
     method_data->klass_name = rb_hash_aref(data, ID2SYM(rb_intern("klass_name")));
     method_data->klass_flags = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("klass_flags"))));
     method_data->method_name = rb_hash_aref(data, ID2SYM(rb_intern("method_name")));
-    method_data->key = FIX2LONG(rb_hash_aref(data, ID2SYM(rb_intern("key"))));
+    method_data->key = RB_NUM2ULL(rb_hash_aref(data, ID2SYM(rb_intern("key"))));
 
     method_data->recursive = rb_hash_aref(data, ID2SYM(rb_intern("recursive"))) == Qtrue ? true : false;
 
@@ -469,8 +513,16 @@ void rp_init_method_info()
 {
     /* MethodInfo */
     cRpMethodInfo = rb_define_class_under(mProf, "MethodInfo", rb_cObject);
-    rb_undef_method(CLASS_OF(cRpMethodInfo), "new");
+
+    rb_define_const(cRpMethodInfo, "MODULE_INCLUDEE", INT2NUM(kModuleIncludee));
+    rb_define_const(cRpMethodInfo, "CLASS_SINGLETON", INT2NUM(kClassSingleton));
+    rb_define_const(cRpMethodInfo, "MODULE_SINGLETON", INT2NUM(kModuleSingleton));
+    rb_define_const(cRpMethodInfo, "OBJECT_SINGLETON", INT2NUM(kObjectSingleton));
+    rb_define_const(cRpMethodInfo, "OTHER_SINGLETON", INT2NUM(kOtherSingleton));
+
     rb_define_alloc_func(cRpMethodInfo, prof_method_allocate);
+    rb_define_method(cRpMethodInfo, "initialize", prof_method_initialize, 2);
+    rb_define_method(cRpMethodInfo, "hash", prof_method_hash, 0);
 
     rb_define_method(cRpMethodInfo, "klass_name", prof_method_klass_name, 0);
     rb_define_method(cRpMethodInfo, "klass_flags", prof_method_klass_flags, 0);

data/ext/ruby_prof/rp_method.h

@@ -15,7 +15,7 @@ enum {
     kClassSingleton = 0x2,                    // Singleton of a class
     kModuleSingleton = 0x4,                   // Singleton of a module
     kObjectSingleton = 0x8,                   // Singleton of an object
-    kOtherSingleton = 0x10                    // Singleton of unkown object
+    kOtherSingleton = 0x10                    // Singleton of unknown object
 };
 
 // Profiling information for each method.

data/ext/ruby_prof/rp_profile.c

@@ -779,6 +779,36 @@ static VALUE prof_threads(VALUE self)
     return result;
 }
 
+/* call-seq:
+   add_thread(thread) -> thread
+
+Adds the specified RubyProf thread to the profile. */
+static VALUE prof_add_thread(VALUE self, VALUE thread)
+{
+  prof_profile_t* profile_ptr = prof_get_profile(self);
+
+  // This thread is now going to be owned by C
+  thread_data_t* thread_ptr = prof_get_thread(thread);
+  thread_ptr->owner = OWNER_C;
+
+  rb_st_insert(profile_ptr->threads_tbl, thread_ptr->fiber_id, (st_data_t)thread_ptr);
+  return thread;
+}
+
+/* call-seq:
+   remove_thread(thread) -> thread
+
+Removes the specified thread from the profile. This is used to remove threads
+after they have been merged togher. Retuns the removed thread. */
+static VALUE prof_remove_thread(VALUE self, VALUE thread)
+{
+  prof_profile_t* profile_ptr = prof_get_profile(self);
+  thread_data_t* thread_ptr = prof_get_thread(thread);
+  VALUE fiber_id = thread_ptr->fiber_id;
+  rb_st_delete(profile_ptr->threads_tbl, (st_data_t*)&fiber_id, NULL);
+  return thread;
+}
+
 /* Document-method: RubyProf::Profile#Profile
    call-seq:
    profile(&block) -> self
@@ -897,19 +927,22 @@ void rp_init_profile(void)
 
     rb_define_singleton_method(cProfile, "profile", prof_profile_class, -1);
     rb_define_method(cProfile, "initialize", prof_initialize, -1);
+    rb_define_method(cProfile, "profile", prof_profile_object, 0);
     rb_define_method(cProfile, "start", prof_start, 0);
     rb_define_method(cProfile, "stop", prof_stop, 0);
     rb_define_method(cProfile, "resume", prof_resume, 0);
     rb_define_method(cProfile, "pause", prof_pause, 0);
     rb_define_method(cProfile, "running?", prof_running, 0);
     rb_define_method(cProfile, "paused?", prof_paused, 0);
-    rb_define_method(cProfile, "threads", prof_threads, 0);
-    rb_define_method(cProfile, "exclude_method!", prof_exclude_method, 2);
-    rb_define_method(cProfile, "profile", prof_profile_object, 0);
 
+    rb_define_method(cProfile, "exclude_method!", prof_exclude_method, 2);
     rb_define_method(cProfile, "measure_mode", prof_profile_measure_mode, 0);
     rb_define_method(cProfile, "track_allocations?", prof_profile_track_allocations, 0);
 
+    rb_define_method(cProfile, "threads", prof_threads, 0);
+    rb_define_method(cProfile, "add_thread", prof_add_thread, 1);
+    rb_define_method(cProfile, "remove_thread", prof_remove_thread, 1);
+
     rb_define_method(cProfile, "_dump_data", prof_profile_dump, 0);
     rb_define_method(cProfile, "_load_data", prof_profile_load, 1);
 }

data/ext/ruby_prof/rp_thread.c

@@ -25,6 +25,7 @@ VALUE cRpThread;
 thread_data_t* thread_data_create(void)
 {
     thread_data_t* result = ALLOC(thread_data_t);
+    result->owner = OWNER_C;
     result->stack = prof_stack_create();
     result->method_table = method_table_create();
     result->call_tree = NULL;
@@ -76,15 +77,6 @@ void prof_thread_mark(void* data)
     rb_st_foreach(thread->method_table, mark_methods, 0);
 }
 
-void prof_thread_ruby_gc_free(void* data)
-{
-    if (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
@@ -105,6 +97,27 @@ static void prof_thread_free(thread_data_t* thread_data)
     xfree(thread_data);
 }
 
+void prof_thread_ruby_gc_free(void* data)
+{
+    thread_data_t* thread_data = (thread_data_t*)data;
+
+    if (!thread_data)
+    {
+        // Object has already been freed by C code
+        return;
+    }
+    else if (thread_data->owner == OWNER_RUBY)
+    {
+        // Ruby owns this object, we need to free the underlying C struct
+        prof_thread_free(thread_data);
+    }
+    else
+    {
+        // The Ruby object is being freed, but not the underlying C structure. So unlink the two.
+        thread_data->object = Qnil;
+    }
+}
+
 static const rb_data_type_t thread_type =
 {
     .wrap_struct_name = "ThreadInfo",
@@ -130,6 +143,7 @@ VALUE prof_thread_wrap(thread_data_t* thread)
 static VALUE prof_thread_allocate(VALUE klass)
 {
     thread_data_t* thread_data = thread_data_create();
+    thread_data->owner = OWNER_RUBY;
     thread_data->object = prof_thread_wrap(thread_data);
     return thread_data->object;
 }
@@ -171,7 +185,8 @@ thread_data_t* threads_table_lookup(void* prof, VALUE fiber)
     thread_data_t* result = NULL;
     st_data_t val;
 
-    if (rb_st_lookup(profile->threads_tbl, fiber, &val))
+    VALUE fiber_id = rb_obj_id(fiber);
+    if (rb_st_lookup(profile->threads_tbl, fiber_id, &val))
     {
         result = (thread_data_t*)val;
     }
@@ -188,7 +203,7 @@ thread_data_t* threads_table_insert(void* prof, VALUE fiber)
     result->fiber = fiber;
     result->fiber_id = rb_obj_id(fiber);
     result->thread_id = rb_obj_id(thread);
-    rb_st_insert(profile->threads_tbl, (st_data_t)fiber, (st_data_t)result);
+    rb_st_insert(profile->threads_tbl, (st_data_t)result->fiber_id, (st_data_t)result);
 
     // Are we tracing this thread?
     if (profile->include_threads_tbl && !rb_st_lookup(profile->include_threads_tbl, thread, 0))
@@ -267,6 +282,26 @@ static int collect_methods(st_data_t key, st_data_t value, st_data_t result)
 }
 
 // ======   RubyProf::Thread  ======
+/* call-seq:
+   new(call_tree, thread, fiber) -> thread
+
+Creates a new RubyProf thread instance. +call_tree+ is the root call_tree instance,
++thread+ is a reference to a Ruby thread and +fiber+ is a reference to a Ruby fiber.*/
+static VALUE prof_thread_initialize(VALUE self, VALUE call_tree, VALUE thread, VALUE fiber)
+{
+  thread_data_t* thread_ptr = prof_get_thread(self);
+
+  // This call tree must now be managed by C
+  thread_ptr->call_tree = prof_get_call_tree(call_tree);
+  thread_ptr->call_tree->owner = OWNER_C;
+
+  thread_ptr->fiber = fiber;
+  thread_ptr->fiber_id = rb_obj_id(fiber);
+  thread_ptr->thread_id = rb_obj_id(thread);
+
+  return self;
+}
+
 /* call-seq:
    id -> number
 
@@ -290,7 +325,7 @@ static VALUE prof_fiber_id(VALUE self)
 /* call-seq:
    call_tree -> CallTree
 
-Returns the root of the call tree. */
+Returns the root call tree. */
 static VALUE prof_call_tree(VALUE self)
 {
     thread_data_t* thread = prof_get_thread(self);
@@ -313,12 +348,22 @@ static VALUE prof_thread_methods(VALUE self)
     return thread->methods;
 }
 
+static VALUE prof_thread_merge(VALUE self, VALUE other)
+{
+  thread_data_t* self_ptr = prof_get_thread(self);
+  thread_data_t* other_ptr = prof_get_thread(other);
+  prof_call_tree_merge_internal(self_ptr->call_tree, other_ptr->call_tree);
+  
+  return other;
+}
+
 /* :nodoc: */
 static VALUE prof_thread_dump(VALUE self)
 {
     thread_data_t* thread_data = RTYPEDDATA_DATA(self);
 
     VALUE result = rb_hash_new();
+    rb_hash_aset(result, ID2SYM(rb_intern("owner")), INT2FIX(thread_data->owner));
     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));
@@ -331,6 +376,8 @@ static VALUE prof_thread_load(VALUE self, VALUE data)
 {
     thread_data_t* thread_data = RTYPEDDATA_DATA(self);
 
+    thread_data->owner = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("owner"))));
+
     VALUE call_tree = rb_hash_aref(data, ID2SYM(rb_intern("call_tree")));
     thread_data->call_tree = prof_get_call_tree(call_tree);
 
@@ -350,13 +397,14 @@ static VALUE prof_thread_load(VALUE self, VALUE data)
 void rp_init_thread(void)
 {
     cRpThread = rb_define_class_under(mProf, "Thread", rb_cObject);
-    rb_undef_method(CLASS_OF(cRpThread), "new");
     rb_define_alloc_func(cRpThread, prof_thread_allocate);
+    rb_define_method(cRpThread, "initialize", prof_thread_initialize, 3);
 
     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, "merge!", prof_thread_merge, 1);
     rb_define_method(cRpThread, "_dump_data", prof_thread_dump, 0);
     rb_define_method(cRpThread, "_load_data", prof_thread_load, 1);
 }

data/ext/ruby_prof/rp_thread.h

@@ -10,7 +10,7 @@
 /* Profiling information for a thread. */
 typedef struct thread_data_t
 {
-    // Runtime
+    prof_owner_t owner;               /* Who owns this object */
     VALUE object;                     /* Cache to wrapped object */
     VALUE fiber;                      /* Fiber */
     prof_stack_t* stack;              /* Stack of frames */

data/ext/ruby_prof/ruby_prof.c

@@ -29,7 +29,6 @@
 #include "rp_measurement.h"
 #include "rp_method.h"
 #include "rp_call_tree.h"
-#include "rp_aggregate_call_tree.h"
 #include "rp_call_trees.h"
 #include "rp_profile.h"
 #include "rp_stack.h"
@@ -43,7 +42,6 @@ void Init_ruby_prof()
 
     rp_init_allocation();
     rp_init_call_tree();
-    rp_init_aggregate_call_tree();
     rp_init_call_trees();
     rp_init_measure();
     rp_init_method_info();

data/ext/ruby_prof/ruby_prof.h

@@ -23,4 +23,12 @@ extern VALUE mProf;
 // This method is not exposed in Ruby header files - at least not as of Ruby 2.6.3 :(
 extern size_t rb_obj_memsize_of(VALUE);
 
+typedef enum
+{
+  OWNER_UNKNOWN = 0,
+  OWNER_RUBY = 1,
+  OWNER_C = 2
+} prof_owner_t;
+
+
 #endif //__RUBY_PROF_H__

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -66,7 +66,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <TargetExt>.so</TargetExt>
-    <OutDir>$(SolutionDir)\..</OutDir>
+    <OutDir>$(SolutionDir)\..\..\..\lib\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -104,14 +104,14 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.1.2-vc\include\ruby-3.1.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.1.2-vc\include\ruby-3.1.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.2.0-vc\include\ruby-3.2.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.2.0-vc\include\ruby-3.2.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <WarningLevel>Level3</WarningLevel>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.1.2-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>x64-vcruntime140-ruby310.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.2.0-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>x64-vcruntime140-ruby320.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
       <SubSystem>Console</SubSystem>
     </Link>
@@ -127,7 +127,6 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="..\rp_aggregate_call_tree.h" />
     <ClInclude Include="..\rp_allocation.h" />
     <ClInclude Include="..\rp_call_tree.h" />
     <ClInclude Include="..\rp_call_trees.h" />
@@ -139,7 +138,6 @@
     <ClInclude Include="..\ruby_prof.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\rp_aggregate_call_tree.c" />
     <ClCompile Include="..\rp_allocation.c" />
     <ClCompile Include="..\rp_call_tree.c" />
     <ClCompile Include="..\rp_call_trees.c" />

data/lib/ruby-prof/method_info.rb

@@ -52,7 +52,14 @@ module RubyProf
       self.total_time - self.self_time - self.wait_time
     end
 
-    # :enddoc:
+    def eql?(other)
+      self.hash == other.hash
+    end
+
+    def ==(other)
+      self.eql?(other)
+    end
+
     def <=>(other)
       if other.nil?
         -1

data/lib/ruby-prof/printers/call_tree_printer.rb

@@ -68,8 +68,6 @@ module RubyProf
 
     def print_threads
       remove_subsidiary_files_from_previous_profile_runs
-      # TODO: merge fibers of a given thread here, instead of relying
-      # on the profiler to merge fibers.
       @result.threads.each do |thread|
         print_thread(thread)
       end

data/lib/ruby-prof/profile.rb

@@ -4,7 +4,6 @@ require 'ruby-prof/exclude_common_methods'
 
 module RubyProf
   class Profile
-    # :nodoc:
     def measure_mode_string
       case self.measure_mode
         when WALL_TIME
@@ -33,5 +32,39 @@ module RubyProf
     def exclude_singleton_methods!(mod, *method_or_methods)
       exclude_methods!(mod.singleton_class, *method_or_methods)
     end
+
+    # call-seq:
+    # merge! -> self
+    #
+    # Merges RubyProf threads whose root call_trees reference the same target method. This is useful
+    # when profiling code that uses a main thread/fiber to distribute work to multiple workers.
+    # If there are tens or hundreds of workers, viewing results per worker thread/fiber can be
+    # overwhelming. Using +merge!+ will combine the worker times together into one result.
+    #
+    # Note the reported time will be much greater than the actual wall time. For example, if there
+    # are 10 workers that each run for 5 seconds, merged results will show one thread that
+    # ran for 50 seconds.
+    #
+    def merge!
+      # First group threads by their root call tree target (method). If the methods are
+      # different than there is nothing to merge
+      grouped = threads.group_by do |thread|
+        thread.call_tree.target
+      end
+
+      # For each target, get the first thread. Then loop over the remaining threads,
+      # and merge them into the first one and ten delete them. So we will be left with
+      # one thread per target.
+      grouped.each do |target, threads|
+        thread = threads.shift
+        threads.each do |other_thread|
+          thread.merge!(other_thread)
+          remove_thread(other_thread)
+        end
+        thread
+      end
+
+      self
+    end
   end
 end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.4.5"
+  VERSION = "1.5.0"
 end

data/test/call_tree_builder.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', __FILE__)
+require 'base64'
+
+# Create a DummyClass with methods so we can create call trees in the test_merge method below
+class DummyClass
+  %i[root a b aa ab ba bb].each do |method_name|
+    define_method(method_name) do
+    end
+  end
+end
+
+def create_call_tree(method_name)
+  method_info = RubyProf::MethodInfo.new(DummyClass, method_name)
+  RubyProf::CallTree.new(method_info)
+end
+
+def build_call_tree(tree_hash)
+  # tree_hash is a hash keyed on the parent method_name whose values are
+  # child methods. Example:
+  #
+  # tree_hash = {:root => [:a, :b],
+  #              :a => [:aa, :ab],
+  #              :b => [:bb]}
+  #
+  # Note this is a simplified structure for testing. It assumes methods
+  # are only called from one call_tree.
+
+  call_trees = Hash.new
+  tree_hash.each do |method_name, children|
+    parent = call_trees[method_name] ||= create_call_tree(method_name)
+    children.each do |child_method_name|
+      child = call_trees[child_method_name] ||= create_call_tree(child_method_name)
+      parent.add_child(child)
+    end
+  end
+
+  call_trees
+end
+
+def create_call_tree_1
+  #
+  #          root    
+  #        /     \   
+  #       a       b  
+  #     /  \       \ 
+  #   aa   ab      bb
+  #
+
+  # ------ Call Trees 1 -------------
+  tree_hash = {:root => [:a, :b],
+               :a => [:aa, :ab],
+               :b => [:bb]}
+
+  call_trees = build_call_tree(tree_hash)
+
+  # Setup times
+  call_trees[:aa].measurement.total_time = 1.5
+  call_trees[:aa].measurement.self_time = 1.5
+  call_trees[:ab].measurement.total_time = 2.2
+  call_trees[:ab].measurement.self_time = 2.2
+  call_trees[:a].measurement.total_time = 3.7
+
+  call_trees[:aa].target.measurement.total_time = 1.5
+  call_trees[:aa].target.measurement.self_time = 1.5
+  call_trees[:ab].target.measurement.total_time = 2.2
+  call_trees[:ab].target.measurement.self_time = 2.2
+  call_trees[:a].target.measurement.total_time = 3.7
+
+  call_trees[:bb].measurement.total_time = 4.3
+  call_trees[:bb].measurement.self_time = 4.3
+  call_trees[:b].measurement.total_time = 4.3
+
+  call_trees[:bb].target.measurement.total_time = 4.3
+  call_trees[:bb].target.measurement.self_time = 4.3
+  call_trees[:b].target.measurement.total_time = 4.3
+
+  call_trees[:root].measurement.total_time = 8.0
+  call_trees[:root].target.measurement.total_time = 8.0
+
+  call_trees[:root]
+end
+
+def create_call_tree_2
+  #
+  #      root
+  #    /     \
+  #   a       b
+  #    \     / \
+  #    ab  ba  bb
+
+  tree_hash = {:root => [:a, :b],
+               :a => [:ab],
+               :b => [:ba, :bb]}
+
+  call_trees = build_call_tree(tree_hash)
+
+  # Setup times
+  call_trees[:ab].measurement.total_time = 0.4
+  call_trees[:ab].measurement.self_time = 0.4
+  call_trees[:a].measurement.total_time = 0.4
+
+  call_trees[:ab].target.measurement.total_time = 0.4
+  call_trees[:ab].target.measurement.self_time = 0.4
+  call_trees[:a].target.measurement.total_time = 0.4
+
+  call_trees[:ba].measurement.total_time = 0.9
+  call_trees[:ba].measurement.self_time = 0.7
+  call_trees[:ba].measurement.wait_time = 0.2
+  call_trees[:bb].measurement.total_time = 2.3
+  call_trees[:bb].measurement.self_time = 2.3
+  call_trees[:b].measurement.total_time = 3.2
+
+  call_trees[:ba].target.measurement.total_time = 0.9
+  call_trees[:ba].target.measurement.self_time = 0.7
+  call_trees[:ba].target.measurement.wait_time = 0.2
+  call_trees[:bb].target.measurement.total_time = 2.3
+  call_trees[:bb].target.measurement.self_time = 2.3
+  call_trees[:b].target.measurement.total_time = 3.2
+
+  call_trees[:root].measurement.total_time = 3.6
+  call_trees[:root].target.measurement.total_time = 3.6
+
+  call_trees[:root]
+end