ruby-prof 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2baeb563dfcb30c82aa1235965228b951b096e333c2367274412ace61ec5fbc6
-  data.tar.gz: 23840f6343ea4361776e1a01925b829da43e3e45c18717e14dde26eeef8b5858
+  metadata.gz: d37fba2001af9994daa9e1c13e316d0a4fe069c769e431915ef573413241203f
+  data.tar.gz: f3e9ff45b63fd26c76fd73cca3f20b67a400c39a1183b135364ce89386a51096
 SHA512:
-  metadata.gz: 26a1d898c0679b366e57451993117146ea160eb9c8bbcde626306f7deac9ce8760ac1633cccb6058574e352fafd32f4e9abb1b3325c6ac6cf13e2fec11794f82
-  data.tar.gz: 226493ef8ed88ea3d43ca54925ea43e53558c3a0771bb346992d266de89c2fd4d1b69f8ab1cf2a37e7102eccfbf94340a361f39862171ef90afba58311c488c2
+  metadata.gz: 9e4e378eef6217b03f62497c38fc765275aab3176e0559449b62e68b2f0e38931dde75ffafb28c01bebf44dc9bfed86a3664c891bdb9dc49f10bb4a1228c28d3
+  data.tar.gz: 4bb4a9a4c41549e5618e3b0cb4e8d7aa14163dfa6b742c739b0c1be16196eb7035bd0f9d9e8ceaf0be7b5d9127acbaec4811094835661a2583bcdf4a5c0adbfa

data/CHANGES

@@ -1,3 +1,10 @@
+1.1.0 (2019-12-14)
+=====================
+Changes
+
+* Reimplement merge_fibers (Charlie Savage)
+* Fix crash caused by threads being freed when profiles are freed (Charlie Savage)
+
 1.0.0 (2019-07-29)
 =====================
 ruby-prof's development stretches all the way back to 2005. Fourteen years later, it seems time for version 1.0!
@@ -7,6 +14,8 @@ Changes (Charlie Savage):
 
 * Profiling is significantly faster - 5x in some cases
 * Recursive profiles are finally handled correctly.  Yeah!!!
+* Redesigned reports (Chirs Whitefield)
+* New documentation website (https://ruby-prof.github.io)
 * The ability to measure allocations and memory usage using a standard (unpatched) version of ruby
 * The ability to save and reload profiling results for later analysis
 * The ability track object allocations

data/ext/ruby_prof/rp_allocation.c

@@ -83,15 +83,15 @@ prof_allocation_ruby_gc_free(void *data)
 {
     prof_allocation_t* allocation = (prof_allocation_t*)data;
 
-    /* Has this thread object been accessed by Ruby?  If
+    /* Has this allocation object been accessed by Ruby?  If
        yes clean it up so to avoid a segmentation fault. */
     if (allocation->object != Qnil)
     {
-        RDATA(allocation->object)->data = NULL;
-        RDATA(allocation->object)->dfree = NULL;
         RDATA(allocation->object)->dmark = NULL;
+        RDATA(allocation->object)->dfree = NULL;
+        RDATA(allocation->object)->data = NULL;
+        allocation->object = Qnil;
     }
-    allocation->object = Qnil;
 }
 
 void
@@ -124,25 +124,12 @@ prof_allocation_mark(void *data)
         rb_gc_mark(allocation->source_file);
 }
 
-static const rb_data_type_t allocation_type =
-{
-    .wrap_struct_name = "Allocation",
-    .function =
-    {
-        .dmark = prof_allocation_mark,
-        .dfree = prof_allocation_ruby_gc_free,
-        .dsize = prof_allocation_size,
-    },
-    .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
-
 VALUE
 prof_allocation_wrap(prof_allocation_t *allocation)
 {
     if (allocation->object == Qnil)
     {
-        allocation->object = TypedData_Wrap_Struct(cRpAllocation, &allocation_type, allocation);
+        allocation->object = Data_Wrap_Struct(cRpAllocation, prof_allocation_mark , prof_allocation_ruby_gc_free, allocation);
     }
     return allocation->object;
 }

data/ext/ruby_prof/rp_call_info.c

@@ -31,20 +31,21 @@ prof_call_info_ruby_gc_free(void *data)
 {
     prof_call_info_t *call_info = (prof_call_info_t*)data;
 
-    /* Has this thread object been accessed by Ruby?  If
+    /* Has this call info object been accessed by Ruby?  If
 	   yes clean it up so to avoid a segmentation fault. */
 	if (call_info->object != Qnil)
 	{
-		RDATA(call_info->object)->data = NULL;
-		RDATA(call_info->object)->dfree = NULL;
-		RDATA(call_info->object)->dmark = NULL;
+        RDATA(call_info->object)->dmark = NULL;
+        RDATA(call_info->object)->dfree = NULL;
+        RDATA(call_info->object)->data = NULL;
+        call_info->object = Qnil;
     }
-	call_info->object = Qnil;
 }
 
 void
 prof_call_info_free(prof_call_info_t *call_info)
 {
+    prof_measurement_free(call_info->measurement);
     prof_call_info_ruby_gc_free(call_info);
     xfree(call_info);
 }
@@ -75,25 +76,12 @@ prof_call_info_mark(void *data)
     prof_measurement_mark(call_info->measurement);
 }
 
-static const rb_data_type_t call_info_type =
-{
-    .wrap_struct_name = "CallInfo",
-    .function =
-    {
-        .dmark = prof_call_info_mark,
-        .dfree = prof_call_info_ruby_gc_free,
-        .dsize = prof_call_info_size,
-    },
-    .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
-
 VALUE
 prof_call_info_wrap(prof_call_info_t *call_info)
 {
     if (call_info->object == Qnil)
     {
-        call_info->object =  TypedData_Wrap_Struct(cRpCallnfo, &call_info_type, call_info);
+        call_info->object =  Data_Wrap_Struct(cRpCallnfo, prof_call_info_mark, prof_call_info_ruby_gc_free, call_info);
     }
     return call_info->object;
 }

data/ext/ruby_prof/rp_measure_process_time.c

@@ -15,17 +15,21 @@ measure_process_time(rb_trace_arg_t* trace_arg)
     FILETIME  sysTime;
     FILETIME  userTime;
 
-	ULARGE_INTEGER sysTimeInt;
-	ULARGE_INTEGER userTimeInt;
+    ULARGE_INTEGER sysTimeInt;
+    ULARGE_INTEGER userTimeInt;
 
-	GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &userTime); 
+    GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &userTime);
 
-	sysTimeInt.LowPart = sysTime.dwLowDateTime;
-	sysTimeInt.HighPart = sysTime.dwHighDateTime;
+    sysTimeInt.LowPart = sysTime.dwLowDateTime;
+    sysTimeInt.HighPart = sysTime.dwHighDateTime;
     userTimeInt.LowPart = userTime.dwLowDateTime;
     userTimeInt.HighPart = userTime.dwHighDateTime;
 
-	return sysTimeInt.QuadPart + userTimeInt.QuadPart;
+    return sysTimeInt.QuadPart + userTimeInt.QuadPart;
+#elif !defined(CLOCK_PROCESS_CPUTIME_ID)
+    struct rusage usage;
+    getrusage(RUSAGE_SELF, &usage);
+    return usage.ru_stime.tv_sec + usage.ru_utime.tv_sec + ((usage.ru_stime.tv_usec + usage.ru_utime.tv_usec)/1000000.0);
 #else
     struct timespec clock;
     clock_gettime(CLOCK_PROCESS_CPUTIME_ID , &clock);

data/ext/ruby_prof/rp_measurement.c

@@ -56,15 +56,22 @@ prof_measurement_ruby_gc_free(void *data)
 {
     prof_measurement_t* measurement = (prof_measurement_t*)data;
 
-    /* Has this thread object been accessed by Ruby?  If
+    /* Has this measurement object been accessed by Ruby?  If
        yes clean it up so to avoid a segmentation fault. */
     if (measurement->object != Qnil)
     {
-        RDATA(measurement->object)->data = NULL;
-        RDATA(measurement->object)->dfree = NULL;
         RDATA(measurement->object)->dmark = NULL;
+        RDATA(measurement->object)->dfree = NULL;
+        RDATA(measurement->object)->data = NULL;
+        measurement->object = Qnil;
     }
-    measurement->object = Qnil;
+}
+
+void
+prof_measurement_free(prof_measurement_t* measurement)
+{
+    prof_measurement_ruby_gc_free(measurement);
+    xfree(measurement);
 }
 
 size_t
@@ -81,25 +88,12 @@ prof_measurement_mark(void *data)
         rb_gc_mark(measurement->object);
 }
 
-static const rb_data_type_t measurement_type =
-{
-    .wrap_struct_name = "Measurement",
-    .function =
-    {
-        .dmark = prof_measurement_mark,
-        .dfree = prof_measurement_ruby_gc_free,
-        .dsize = prof_measurement_size,
-    },
-    .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
-
 VALUE
 prof_measurement_wrap(prof_measurement_t* measurement)
 {
     if (measurement->object == Qnil)
     {
-        measurement->object = TypedData_Wrap_Struct(cRpMeasurement, &measurement_type, measurement);
+        measurement->object = Data_Wrap_Struct(cRpMeasurement, prof_measurement_mark, prof_measurement_ruby_gc_free, measurement);
     }
     return measurement->object;
 }

data/ext/ruby_prof/rp_measurement.h

@@ -40,6 +40,7 @@ prof_measurer_t *prof_get_measurer(prof_measure_mode_t measure, bool track_alloc
 double prof_measure(prof_measurer_t *measurer, rb_trace_arg_t* trace_arg);
 
 prof_measurement_t *prof_measurement_create(void);
+void prof_measurement_free(prof_measurement_t* measurement);
 VALUE prof_measurement_wrap(prof_measurement_t *measurement);
 prof_measurement_t* prof_get_measurement(VALUE self);
 void prof_measurement_mark(void *data);

data/ext/ruby_prof/rp_method.c

@@ -237,15 +237,15 @@ prof_method_ruby_gc_free(void *data)
 {
     prof_method_t* method = (prof_method_t*)data;
 
-    /* Has this thread object been accessed by Ruby?  If
+    /* Has this method object been accessed by Ruby?  If
 	   yes clean it up so to avoid a segmentation fault. */
 	if (method->object != Qnil)
 	{
-		RDATA(method->object)->data = NULL;
-		RDATA(method->object)->dfree = NULL;
-		RDATA(method->object)->dmark = NULL;
-	}
-	method->object = Qnil;
+        RDATA(method->object)->dmark = NULL;
+        RDATA(method->object)->dfree = NULL;
+        RDATA(method->object)->data = NULL;
+        method->object = Qnil;
+    }
     method->klass_name = Qnil;
     method->method_name = Qnil;
 }
@@ -261,6 +261,7 @@ prof_method_free(prof_method_t* method)
     call_info_table_free(method->parent_call_infos);
     xfree(method->child_call_infos);
 
+    prof_measurement_free(method->measurement);
     xfree(method);
 }
 
@@ -290,19 +291,6 @@ prof_method_mark(void *data)
     st_foreach(method->allocations_table, prof_method_mark_allocations, 0);
 }
 
-static const rb_data_type_t method_info_type =
-{
-    .wrap_struct_name = "MethodInfo",
-    .function =
-    {
-        .dmark = prof_method_mark,
-        .dfree = prof_method_ruby_gc_free,
-        .dsize = prof_method_size,
-    },
-    .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
-
 static VALUE
 prof_method_allocate(VALUE klass)
 {
@@ -316,7 +304,7 @@ prof_method_wrap(prof_method_t *method)
 {
   if (method->object == Qnil)
   {
-      method->object = TypedData_Wrap_Struct(cRpMethodInfo, &method_info_type, method);
+      method->object = Data_Wrap_Struct(cRpMethodInfo, prof_method_mark, prof_method_ruby_gc_free, method);
   }
   return method->object;
 }

data/ext/ruby_prof/rp_profile.c

@@ -101,13 +101,20 @@ get_event_name(rb_event_flag_t event)
     }
 }
 
+VALUE get_fiber(prof_profile_t* profile)
+{
+    if (profile->merge_fibers)
+        return rb_thread_current();
+    else
+        return rb_fiber_current();
+}
 /* ===========  Profiling ================= */
 thread_data_t* check_fiber(prof_profile_t *profile, double measurement)
 {
     thread_data_t* result = NULL;
     
     /* Get the current thread and fiber information. */
-    VALUE fiber = rb_fiber_current();
+    VALUE fiber = get_fiber(profile);
     
     /* We need to switch the profiling context if we either had none before,
      we don't merge fibers and the fiber ids differ, or the thread ids differ. */
@@ -131,7 +138,7 @@ static void
 prof_trace(prof_profile_t* profile, rb_trace_arg_t *trace_arg, double measurement)
 {
     static VALUE last_fiber = Qnil;
-    VALUE fiber = rb_fiber_current();
+    VALUE fiber = get_fiber(profile);
     
     rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
     const char* event_name = get_event_name(event);
@@ -432,7 +439,8 @@ prof_allocate(VALUE klass)
     profile->exclude_threads_tbl = NULL;
     profile->include_threads_tbl = NULL;
     profile->running = Qfalse;
-    profile->allow_exceptions = 0;
+    profile->allow_exceptions = false;
+    profile->merge_fibers = false;
     profile->exclude_methods_tbl = method_table_create();
     profile->running = Qfalse;
     profile->tracepoints = rb_ary_new();
@@ -479,6 +487,9 @@ prof_stop_threads(prof_profile_t* profile)
                       all other threads.
    allow_exceptions:: Whether to raise exceptions encountered during profiling,
                       or to suppress all exceptions during profiling
+   merge_fibers::     Whether profiling data for a given thread's fibers should all be
+                      subsumed under a single entry. Basically only useful to produce
+                      callgrind profiles.
 */
 static VALUE
 prof_initialize(int argc,  VALUE *argv, VALUE self)
@@ -490,6 +501,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
     VALUE include_threads = Qnil;
     VALUE exclude_common = Qnil;
     VALUE allow_exceptions = Qfalse;
+    VALUE merge_fibers = Qfalse;
     VALUE track_allocations = Qfalse;
 
     int i;
@@ -509,6 +521,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
             mode = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("measure_mode")));
             track_allocations = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("track_allocations")));
             allow_exceptions = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("allow_exceptions")));
+            merge_fibers = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("merge_fibers")));
             exclude_common = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_common")));
             exclude_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_threads")));
             include_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("include_threads")));
@@ -529,6 +542,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
     }
     profile->measurer = prof_get_measurer(NUM2INT(mode), track_allocations == Qtrue);
     profile->allow_exceptions = (allow_exceptions == Qtrue);
+    profile->merge_fibers = (merge_fibers == Qtrue);
 
     if (exclude_threads != Qnil)
     {
@@ -624,7 +638,7 @@ prof_start(VALUE self)
 
     profile->running = Qtrue;
     profile->paused = Qfalse;
-    profile->last_thread_data = threads_table_insert(profile, rb_fiber_current());
+    profile->last_thread_data = threads_table_insert(profile, get_fiber(profile));
 
     /* open trace file if environment wants it */
     trace_file_name = getenv("RUBY_PROF_TRACE");

data/ext/ruby_prof/rp_profile.h

@@ -27,6 +27,7 @@ typedef struct
     thread_data_t* last_thread_data;
     double measurement_at_pause_resume;
     bool allow_exceptions;
+    bool merge_fibers;
 } prof_profile_t;
 
 void rp_init_profile(void);

data/ext/ruby_prof/rp_thread.c

@@ -41,9 +41,20 @@ thread_data_create(void)
 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);
     prof_stack_free(thread_data->stack);
 
+
     xfree(thread_data);
 }
 
@@ -81,25 +92,13 @@ prof_thread_mark(void *data)
     st_foreach(thread->method_table, mark_methods, 0);
 }
 
-static const rb_data_type_t thread_type =
-{
-    .wrap_struct_name = "ThreadInfo",
-    .function =
-    {
-        .dmark = prof_thread_mark,
-        .dfree = NULL, /* The profile class frees its thread table which frees each underlying thread_data instance */
-        .dsize = prof_thread_size,
-    },
-    .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
 
 VALUE
 prof_thread_wrap(thread_data_t *thread)
 {
     if (thread->object == Qnil)
     {
-        thread->object = TypedData_Wrap_Struct(cRpThread, &thread_type, thread);
+        thread->object = Data_Wrap_Struct(cRpThread, prof_thread_mark, NULL, thread);
     }
     return thread->object;
 }

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -102,12 +102,12 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-2.6.3vc\include\ruby-2.6.0\x64-mswin64_140;C:\msys64\usr\local\ruby-2.6.3vc\include\ruby-2.6.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-2.6.5vc\include\ruby-2.6.0\x64-mswin64_140;C:\msys64\usr\local\ruby-2.6.5vc\include\ruby-2.6.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>HAVE_RB_TRACEARG_CALLEE_ID;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-2.6.3vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-2.6.5vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>x64-vcruntime140-ruby260.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
     </Link>

data/lib/ruby-prof.rb

@@ -18,7 +18,6 @@ require 'ruby-prof/rack'
 require 'ruby-prof/thread'
 
 module RubyProf
-  autoload :AggregateCallInfo, 'ruby-prof/aggregate_call_info'
   autoload :CallInfoVisitor, 'ruby-prof/call_info_visitor'
 
   autoload :AbstractPrinter, 'ruby-prof/printers/abstract_printer'

data/lib/ruby-prof/assets/call_stack_printer.html.erb

@@ -0,0 +1,713 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=utf-8">
+    <title>ruby-prof call tree</title>
+    <style type="text/css">
+      body {
+        font-size: 70%;
+        padding: 0;
+        margin: 5px;
+        margin-right: 0px;
+        margin-left: 0px;
+        background: #ffffff;
+      }
+
+      ul {
+        margin-left: 0px;
+        margin-top: 0px;
+        margin-bottom: 0px;
+        padding-left: 0px;
+        list-style-type: none;
+      }
+
+      li {
+        margin-left: 11px;
+        padding: 0px;
+        white-space: nowrap;
+        border-top: 1px solid #cccccc;
+        border-left: 1px solid #cccccc;
+        border-bottom: none;
+      }
+
+      .thread {
+        margin-left: 11px;
+        background: #708090;
+        padding-top: 3px;
+        padding-left: 12px;
+        padding-bottom: 2px;
+        border-left: 1px solid #CCCCCC;
+        border-top: 1px solid #CCCCCC;
+        font-weight: bold;
+      }
+
+      .hidden {
+        display: none;
+        width: 0px;
+        height: 0px;
+        margin: 0px;
+        padding: 0px;
+        border-style: none;
+      }
+
+      .color01 {
+        background: #adbdeb
+      }
+
+      .color05 {
+        background: #9daddb
+      }
+
+      .color0 {
+        background: #8d9dcb
+      }
+
+      .color1 {
+        background: #89bccb
+      }
+
+      .color2 {
+        background: #56e3e7
+      }
+
+      .color3 {
+        background: #32cd70
+      }
+
+      .color4 {
+        background: #a3d53c
+      }
+
+      .color5 {
+        background: #c4cb34
+      }
+
+      .color6 {
+        background: #dcb66d
+      }
+
+      .color7 {
+        background: #cda59e
+      }
+
+      .color8 {
+        background: #be9d9c
+      }
+
+      .color9 {
+        background: #cf947a
+      }
+
+      #commands {
+        font-size: 10pt;
+        padding: 10px;
+        margin-left: 11px;
+        margin-bottom: 0px;
+        margin-top: 0px;
+        background: #708090;
+        border-top: 1px solid #cccccc;
+        border-left: 1px solid #cccccc;
+        border-bottom: none;
+      }
+
+      #titlebar {
+        font-size: 10pt;
+        padding: 10px;
+        margin-left: 11px;
+        margin-bottom: 0px;
+        margin-top: 10px;
+        background: #8090a0;
+        border-top: 1px solid #cccccc;
+        border-left: 1px solid #cccccc;
+        border-bottom: none;
+      }
+
+      #help {
+        font-size: 10pt;
+        padding: 10px;
+        margin-left: 11px;
+        margin-bottom: 0px;
+        margin-top: 0px;
+        background: #8090a0;
+        display: none;
+        border-top: 1px solid #cccccc;
+        border-left: 1px solid #cccccc;
+        border-bottom: none;
+      }
+
+      #sentinel {
+        height: 400px;
+        margin-left: 11px;
+        background: #8090a0;
+        border-top: 1px solid #cccccc;
+        border-left: 1px solid #cccccc;
+        border-bottom: none;
+      }
+
+      input {
+        margin-left: 10px;
+      }
+
+      .toggle {
+        background: url(data:image/png;base64,<%= base64_image %>) no-repeat left center;
+        float: left;
+        width: 9px;
+        height: 9px;
+        margin: 2px 1px 1px 1px;
+      }
+
+      .toggle.minus {
+        background-position: -9px 0;
+      }
+
+      .toggle.plus {
+        background-position: -18px 0;
+      }
+    </style>
+
+    <script type="text/javascript">
+      function rootNode()
+      {
+        return currentThread
+      }
+
+      function showUL(node, show)
+      {
+        Array.prototype.forEach.call(node.childNodes, function(child)
+        {
+          if (child.nodeName == 'LI')
+            toggle(child, show)
+        })
+      }
+
+      function findUlChild(li)
+      {
+        var ul = li.childNodes[2]
+        while (ul && ul.nodeName != "UL")
+        {
+          ul = ul.nextSibling
+        }
+        return ul
+      }
+
+      function isLeafNode(li)
+      {
+        var element = li.querySelector('a')
+        return element.classList.contains('empty')
+      }
+
+      function toggle(li, show)
+      {
+        if (isLeafNode(li))
+          return
+
+        var img = li.firstChild
+        img.className = 'toggle '
+        img.className += show ? 'minus' : 'plus'
+
+        var ul = findUlChild(li)
+        if (ul)
+        {
+          ul.style.display = show ? 'block' : 'none'
+          showUL(ul, true)
+        }
+      }
+
+      function toggleLI(li)
+      {
+        var img = li.firstChild
+        if (img.className.indexOf("minus") > -1)
+          toggle(li, false)
+        else
+        {
+          if (img.className.indexOf("plus") > -1)
+            toggle(li, true)
+        }
+      }
+
+      function aboveThreshold(text, threshold)
+      {
+        var match = text.match(/\d+[.,]\d+%/)
+        if (!match)
+        {
+          return true
+        }
+        else
+        {
+          var value = parseFloat(match[0].replace(/,/, '.'))
+          return value >= threshold
+        }
+      }
+
+      function setThresholdLI(li, threshold)
+      {
+        var a = li.querySelector('a')
+        var span = li.querySelector('span')
+        var ul = li.querySelector('ul')
+
+        var visible = aboveThreshold(span.textContent, threshold) ? 1 : 0
+
+        var count = 0
+        if (ul)
+        {
+          count = setThresholdUL(ul, threshold)
+        }
+
+        if (count > 0)
+        {
+          a.className = 'toggle minus'
+        }
+        else
+        {
+          a.className = 'toggle empty'
+        }
+
+        if (visible)
+        {
+          li.style.display = 'block'
+        } else
+        {
+          li.style.display = 'none'
+        }
+        return visible
+      }
+
+      function setThresholdUL(node, threshold)
+      {
+        var count = 0
+        Array.prototype.forEach.call(node.childNodes, function(child)
+        {
+          if (child.nodeName == 'LI')
+            count = count + setThresholdLI(child, threshold)
+        })
+
+        var visible = (count > 0) ? 1 : 0
+        if (visible)
+        {
+          node.style.display = 'block'
+        } else
+        {
+          node.style.display = 'none'
+        }
+        return visible
+      }
+
+      function toggleChildren(img, event)
+      {
+        event.cancelBubble = true
+        if (img.className.indexOf('empty') > -1)
+          return
+
+        var minus = (img.className.indexOf('minus') > -1)
+
+        if (minus)
+        {
+          img.className = 'toggle plus'
+        } else
+          img.className = 'toggle minus'
+
+        var li = img.parentNode
+        var ul = findUlChild(li)
+        if (ul)
+        {
+          if (minus)
+            ul.style.display = 'none'
+          else
+            ul.style.display = 'block'
+        }
+        if (minus)
+          moveSelectionIfNecessary(li)
+      }
+
+      function showChildren(li)
+      {
+        var img = li.firstChild
+        if (img.className.indexOf('empty') > -1)
+          return
+        img.className = 'toggle minus'
+
+        var ul = findUlChild(li)
+        if (ul)
+        {
+          ul.style.display = 'block'
+        }
+      }
+
+      function setThreshold()
+      {
+        var tv = document.getElementById("threshold").value
+        if (tv.match(/[0-9]+([.,][0-9]+)?/))
+        {
+          var f = parseFloat(tv.replace(/,/, '.'))
+          var threads = document.getElementsByName("thread")
+          var l = threads.length
+          for (var i = 0; i < l; i++)
+          {
+            setThresholdUL(threads[i], f)
+          }
+          var p = selectedNode
+          while (p && p.style.display == 'none')
+            p = p.parentNode.parentNode
+          if (p && p.nodeName == "LI")
+            selectNode(p)
+        } else
+        {
+          alert("Please specify a decimal number as threshold value!")
+        }
+      }
+
+      function expandAll(event)
+      {
+        toggleAll(event, true)
+      }
+
+      function collapseAll(event)
+      {
+        toggleAll(event, false)
+        selectNode(rootNode(), null)
+      }
+
+      function toggleAll(event, show)
+      {
+        event.cancelBubble = true
+        var threads = document.getElementsByName("thread")
+        var l = threads.length
+        for (var i = 0; i < l; i++)
+        {
+          showUL(threads[i], show)
+        }
+      }
+
+      function toggleHelp(node)
+      {
+        var help = document.getElementById("help")
+        if (node.value == "Show Help")
+        {
+          node.value = "Hide Help"
+          help.style.display = 'block'
+        } else
+        {
+          node.value = "Show Help"
+          help.style.display = 'none'
+        }
+      }
+
+      var selectedNode = null
+      var selectedColor = null
+      var selectedThread = null
+
+      function descendentOf(a, b)
+      {
+        while (a != b && b != null)
+          b = b.parentNode
+        return (a == b)
+      }
+
+      function moveSelectionIfNecessary(node)
+      {
+        if (descendentOf(node, selectedNode))
+          selectNode(node, null)
+      }
+
+      function selectNode(node, event)
+      {
+        if (event)
+        {
+          event.cancelBubble = true
+          thread = findThread(node)
+          selectThread(thread)
+        }
+        if (selectedNode)
+        {
+          selectedNode.style.background = selectedColor
+        }
+        selectedNode = node
+        selectedColor = node.style.background
+        selectedNode.style.background = "red"
+        selectedNode.scrollIntoView()
+        window.scrollBy(0, -400)
+      }
+
+      function moveUp()
+      {
+        move(selectedNode.previousSibling)
+      }
+
+      function moveDown()
+      {
+        move(selectedNode.nextSibling)
+      }
+
+      function move(p)
+      {
+        while (p && p.style.display == 'none')
+          p = p.nextSibling
+        if (p && p.nodeName == "LI")
+        {
+          selectNode(p, null)
+        }
+      }
+
+      function moveLeft()
+      {
+        var p = selectedNode.parentNode.parentNode
+        if (p && p.nodeName == "LI")
+        {
+          selectNode(p, null)
+        }
+      }
+
+      function moveRight()
+      {
+        if (!isLeafNode(selectedNode))
+        {
+          showChildren(selectedNode)
+          var ul = findUlChild(selectedNode)
+          if (ul)
+          {
+            selectNode(ul.firstChild, null)
+          }
+        }
+      }
+
+      function moveForward()
+      {
+        if (isLeafNode(selectedNode))
+        {
+          var p = selectedNode
+          while ((p.nextSibling == null || p.nextSibling.style.display == 'none') && p.nodeName == "LI")
+          {
+            p = p.parentNode.parentNode
+          }
+          if (p.nodeName == "LI")
+            selectNode(p.nextSibling, null)
+        } else
+        {
+          moveRight()
+        }
+      }
+
+      function isExpandedNode(li)
+      {
+        var img = li.firstChild
+        return (img.className.indexOf('minus') > -1)
+      }
+
+      function moveBackward()
+      {
+        var p = selectedNode
+        var q = p.previousSibling
+        while (q != null && q.style.display == 'none')
+          q = q.previousSibling
+        if (q == null)
+        {
+          p = p.parentNode.parentNode
+        } else
+        {
+          while (!isLeafNode(q) && isExpandedNode(q))
+          {
+            q = findUlChild(q).lastChild
+            while (q.style.display == 'none')
+              q = q.previousSibling
+          }
+          p = q
+        }
+        if (p.nodeName == "LI")
+          selectNode(p, null)
+      }
+
+      function moveHome()
+      {
+        selectNode(currentThread)
+      }
+
+      var currentThreadIndex = null
+
+      function findThread(node)
+      {
+        while (node && !node.parentNode.nodeName.match(/BODY|DIV/g))
+        {
+          node = node.parentNode
+        }
+        return node.firstChild
+      }
+
+      function selectThread(node)
+      {
+        var threads = document.getElementsByName("thread")
+        currentThread = node
+        for (var i = 0; i < threads.length; i++)
+        {
+          if (threads[i] == currentThread.parentNode)
+            currentThreadIndex = i
+        }
+      }
+
+      function nextThread()
+      {
+        var threads = document.getElementsByName("thread")
+        if (currentThreadIndex == threads.length - 1)
+          currentThreadIndex = 0
+        else
+          currentThreadIndex += 1
+        currentThread = threads[currentThreadIndex].firstChild
+        selectNode(currentThread, null)
+      }
+
+      function previousThread()
+      {
+        var threads = document.getElementsByName("thread")
+        if (currentThreadIndex == 0)
+          currentThreadIndex = threads.length - 1
+        else
+          currentThreadIndex -= 1
+        currentThread = threads[currentThreadIndex].firstChild
+        selectNode(currentThread, null)
+      }
+
+      function switchThread(node, event)
+      {
+        event.cancelBubble = true
+        selectThread(node.nextSibling.firstChild)
+        selectNode(currentThread, null)
+      }
+
+      function handleKeyEvent(event)
+      {
+        var code = event.charCode ? event.charCode : event.keyCode
+        var str = String.fromCharCode(code)
+        switch (str)
+        {
+          case "a":
+            moveLeft()
+            break
+          case "s":
+            moveDown()
+            break
+          case "d":
+            moveRight()
+            break
+          case "w":
+            moveUp()
+            break
+          case "f":
+            moveForward()
+            break
+          case "b":
+            moveBackward()
+            break
+          case "x":
+            toggleChildren(selectedNode.firstChild, event)
+            break
+          case "*":
+            toggleLI(selectedNode)
+            break
+          case "n":
+            nextThread()
+            break
+          case "h":
+            moveHome()
+            break
+          case "p":
+            previousThread()
+            break
+        }
+      }
+
+      document.onkeypress = function (event)
+      {
+        handleKeyEvent(event)
+      }
+
+      window.onload = function ()
+      {
+        var images = document.querySelectorAll(".toggle")
+        for (var i = 0; i < images.length; i++)
+        {
+          var img = images[i]
+          img.onclick = function (event)
+          {
+            toggleChildren(this, event)
+            return false
+          }
+        }
+        var divs = document.getElementsByTagName("div")
+        for (i = 0; i < divs.length; i++)
+        {
+          var div = divs[i]
+          if (div.className == "thread")
+            div.onclick = function (event)
+            {
+              switchThread(this, event)
+            }
+        }
+        var lis = document.getElementsByTagName("li")
+        for (var i = 0; i < lis.length; i++)
+        {
+          lis[i].onclick = function (event)
+          {
+            selectNode(this, event)
+          }
+        }
+
+        var threads = document.getElementsByName("thread")
+        currentThreadIndex = 0
+        currentThread = threads[0].querySelector('li')
+        selectNode(currentThread, null)
+      }
+    </script>
+
+    <% @overall_time = @result.threads.reduce(0) do |val, thread|
+      val += thread.total_time
+    end %>
+  </head>
+  <body>
+    <div style="display: inline-block;">
+      <div id="titlebar">
+        Call tree for application <strong><%= application %> <%= arguments %></strong><br/> Generated on <%= Time.now %>
+        with options <%= @options.inspect %><br/>
+      </div>
+      <div id="commands">
+        <span style="font-size: 11pt; font-weight: bold;">Threshold:</span>
+        <input value="1.0" size="3" id="threshold" type="text">
+        <input value="Apply" onclick="setThreshold();" type="submit">
+        <input value="Expand All" onclick="expandAll(event);" type="submit">
+        <input value="Collapse All" onclick="collapseAll(event);" type="submit">
+        <input value="Show Help" onclick="toggleHelp(this);" type="submit">
+      </div>
+      <ul style="display: none;" id="help">
+        <li>* indicates recursively called methods</li>
+        <li>Enter a decimal value <i>d</i> into the threshold field and click "Apply" to hide all nodes marked with time
+          values lower than <em>d</em>.
+        </li>
+        <li>Click on "Expand All" for full tree expansion.</li>
+        <li>Click on "Collapse All" to show only top level nodes.</li>
+        <li>Use a, s, d, w as in Quake or Urban Terror to navigate the tree.</li>
+        <li>Use f and b to navigate the tree in preorder forward and backwards.</li>
+        <li>Use x to toggle visibility of a subtree.</li>
+        <li>Use * to expand/collapse a whole subtree.</li>
+        <li>Use h to navigate to thread root.</li>
+        <li>Use n and p to navigate between threads.</li>
+        <li>Click on background to move focus to a subtree.</li>
+      </ul>
+
+      <% @result.threads.each do |thread| %>
+        <% thread_percent = 100 * (thread.total_time / @overall_time)
+           thread_info = "#{"%4.2f%%" % thread_percent} ~ #{@overall_time}" %>
+        <div class="thread">
+          <span>Thread: <%= thread.id %>, Fiber: <%= thread.fiber_id %> (<%= thread_info %>)</span>
+          <ul name="thread">
+            <% call_infos = thread.root_methods.map(&:callers).flatten %>
+            <% call_infos.each do |call_info| %>
+              <% visited = Set.new
+                 output = StringIO.new('')
+                 print_stack(output, visited, call_info, call_info.total_time) %>
+              <%= output.string %>
+            <% end %>
+          </ul>
+        </div>
+      <% end %>
+      <div id="sentinel"></div>
+    </div>
+  </body>
+</html>