ruby-prof-danielhoey 0.8.1

data/examples/graph.txt

@@ -0,0 +1,170 @@
+= Graph Profiles
+
+Graph profiles show how long each method runs, which methods call it
+and which methods it calls.
+
+As an example, here is the output from running printers_test.rb:
+
+
+Thread ID: 21277412
+  %total   %self     total      self    children               calls   Name
+ --------------------------------------------------------------------------------
+ 100.00%   0.00%      8.77      0.00      8.77                   1     #toplevel
+                      8.77      0.00      8.77                 1/1     Object#run_primes
+ --------------------------------------------------------------------------------
+                      8.77      0.00      8.77                 1/1     #toplevel
+ 100.00%   0.00%      8.77      0.00      8.77                   1     Object#run_primes
+                      0.02      0.00      0.02                 1/1     Object#make_random_array
+                      2.09      0.00      2.09                 1/1     Object#find_largest
+                      6.66      0.00      6.66                 1/1     Object#find_primes
+ --------------------------------------------------------------------------------
+                      6.63      4.06      2.56             500/501     Object#is_prime
+                      2.09      0.00      2.09               1/501     Object#find_largest
+  99.48%  46.34%      8.72      4.06      4.66                 501     Integer#upto
+                      0.00      0.00      0.00               61/61     Array#[]
+                      0.00      0.00      0.00               61/61     Fixnum#>
+                      2.09      2.09      0.00               61/61     Kernel.sleep
+                      1.24      1.24      0.00       250862/250862     Fixnum#==
+                      1.33      1.33      0.00       250862/250862     Fixnum#%
+ --------------------------------------------------------------------------------
+                      6.66      0.01      6.64                 1/1     Object#find_primes
+  75.93%   0.17%      6.66      0.01      6.64                   1     Array#select
+                      6.64      0.01      6.63             500/500     Object#is_prime
+ --------------------------------------------------------------------------------
+                      6.66      0.00      6.66                 1/1     Object#run_primes
+  75.93%   0.00%      6.66      0.00      6.66                   1     Object#find_primes
+                      6.66      0.01      6.64                 1/1     Array#select
+ --------------------------------------------------------------------------------
+                      6.64      0.01      6.63             500/500     Array#select
+  75.76%   0.17%      6.64      0.01      6.63                 500     Object#is_prime
+                      0.00      0.00      0.00             500/501     Fixnum#-
+                      6.63      4.06      2.56             500/501     Integer#upto
+ --------------------------------------------------------------------------------
+                      2.09      0.00      2.09                 1/1     Object#run_primes
+  23.89%   0.00%      2.09      0.00      2.09                   1     Object#find_largest
+                      0.00      0.00      0.00               1/501     Fixnum#-
+                      2.09      0.00      2.09               1/501     Integer#upto
+                      0.00      0.00      0.00                 1/1     Array#first
+                      0.00      0.00      0.00                 1/1     Array#length
+ --------------------------------------------------------------------------------
+                      2.09      2.09      0.00               61/61     Integer#upto
+  23.89%  23.89%      2.09      2.09      0.00                  61     Kernel.sleep
+ --------------------------------------------------------------------------------
+                      1.33      1.33      0.00       250862/250862     Integer#upto
+  15.12%  15.12%      1.33      1.33      0.00              250862     Fixnum#%
+ --------------------------------------------------------------------------------
+                      1.24      1.24      0.00       250862/250862     Integer#upto
+  14.13%  14.13%      1.24      1.24      0.00              250862     Fixnum#==
+ --------------------------------------------------------------------------------
+                      0.02      0.00      0.02                 1/1     Object#run_primes
+   0.18%   0.00%      0.02      0.00      0.02                   1     Object#make_random_array
+                      0.02      0.02      0.00                 1/1     Array#each_index
+                      0.00      0.00      0.00                 1/1     Class#new
+ --------------------------------------------------------------------------------
+                      0.02      0.02      0.00                 1/1     Object#make_random_array
+   0.18%   0.18%      0.02      0.02      0.00                   1     Array#each_index
+                      0.00      0.00      0.00             500/500     Kernel.rand
+                      0.00      0.00      0.00             500/500     Array#[]=
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00             500/501     Object#is_prime
+                      0.00      0.00      0.00               1/501     Object#find_largest
+   0.00%   0.00%      0.00      0.00      0.00                 501     Fixnum#-
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00                 1/1     Kernel.rand
+   0.00%   0.00%      0.00      0.00      0.00                   1     Integer#to_int
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00                 1/1     Object#find_largest
+   0.00%   0.00%      0.00      0.00      0.00                   1     Array#first
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00                 1/1     Class#new
+   0.00%   0.00%      0.00      0.00      0.00                   1     Array#initialize
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00                 1/1     Object#find_largest
+   0.00%   0.00%      0.00      0.00      0.00                   1     Array#length
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00                 1/1     Object#make_random_array
+   0.00%   0.00%      0.00      0.00      0.00                   1     Class#new
+                      0.00      0.00      0.00                 1/1     Array#initialize
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00               61/61     Integer#upto
+   0.00%   0.00%      0.00      0.00      0.00                  61     Fixnum#>
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00               61/61     Integer#upto
+   0.00%   0.00%      0.00      0.00      0.00                  61     Array#[]
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00             500/500     Array#each_index
+   0.00%   0.00%      0.00      0.00      0.00                 500     Array#[]=
+ --------------------------------------------------------------------------------
+                      0.00      0.00      0.00             500/500     Array#each_index
+   0.00%   0.00%      0.00      0.00      0.00                 500     Kernel.rand
+                      0.00      0.00      0.00                 1/1     Integer#to_int
+
+
+
+== Overview
+Dashed lines divide the report into entries, with one entry
+per method.  Entries are sorted by total time which is the 
+time spent in the method plus its children. 
+
+Each entry has a primary line demarked by values in the 
+%total and %self columns.  The primary line represents 
+the method being profiled.  Lines above it are the methods
+that called this method (parents) while the lines below it
+are the methods it called (children).
+
+All values are in seconds.  For the primary line, the columns represent:
+
+	%total       - The percentage of time spent in this method and its children
+	%self        - The percentage of time spent in this method
+	total        - The time spent in this method and its children.
+	self         - The time spent in this method.
+	children     - The time spent in this method's children.
+	calls        - The number of times this method was called.
+	name         - The name of the method.
+  
+The interpretation of method names is:
+* #toplevel - The root method that calls all other methods
+* MyObject#test - An instance method "test" of the class "MyObject"
+* <Object:MyObject>#test - The <> characters indicate a singleton method on a singleton class.
+
+For example, we see that 99.48% of the time was spent in Integer#upto and its children.
+Of that time, 4.06 seconds was spent in Integer#upto itself and 4.66 in its children.
+Overall, Integer#upto was called 501 times.
+
+== Parents
+In each entry, the lines above the primary line are the methods that 
+called the current method.  If the current method is a root method then
+no parents are shown.
+
+
+For parent lines, the columns represent:
+
+	total        - The time spent in the current method and it children on behalf of the parent method.
+	self         - The time spent in this method on behalf of the parent method.
+	children     - The time spent in this method's children on behalf of the parent.
+	calls        - The number of times the parent method called this child
+  
+Looking at Integer#upto again, we see that it was called 500 times from Object#is_prime
+and 1 time from find_largest.  Of the 8.72 total seconds spent in Integer#upto, 6.63
+were done for Object#is_prime and 2.09 for Object#find_largest.
+
+
+== Children
+In each entry, the lines below the primary line are the methods that 
+the current method called.  If the current method is a leaf method then
+no children are shown.
+
+For children lines, the columns represent:
+
+	total        - The time spent in the child, and its children, on behalf of the current method
+	self         - The time spent in the child on behalf of the current method.
+	children     - The time spent in the child's children (ie, granchildren) in behalf of the current method
+	calls        - The number of times the child method was called by the current method.
+
+Taking our example of Integer#upto, we see that it called five other methods - Array#[],
+Fixnum#>, Kernel.sleep, Fixnum#= and Fixnum#%.  Looking at Kernel.sleep, we see that 
+its spent 2.09 seconds working for Integer#upto and its children spent 0 time working for
+Integer#upto.  To see the overall time Kernel.sleep took we would have to look up its entry
+in the graph table.
+
+

data/ext/ruby_prof/call_tree.c

@@ -0,0 +1,392 @@
+#include "call_tree.h"
+#include "list.h"
+#include <assert.h>
+
+VALUE cCallTree;
+static ID call_tree_class_id;
+int NULL_TIME = -1;
+VALUE root;
+
+#ifdef DEBUG
+  #define LOG_EVENT(event) \
+    printf("%s::%s %s at %u\n", rb_id2name(ct->klass), rb_id2name(ct->mid), event, (unsigned int) time);    
+
+  #define LOG(printf_string, ...) \
+    printf(printf_string, ##__VA_ARGS__);
+#else
+  #define LOG_EVENT(event);
+  #define LOG(printf_string, ...);
+#endif //DEBUG
+
+static VALUE method_name_text(ID mid)
+{
+    char* name = rb_id2name(mid);
+    if (name == NULL) return rb_str_new2("[No method]");
+    else            return rb_str_new2(name);
+}
+
+static VALUE class_name_text(ID mid)
+{
+    char* name = rb_id2name(mid);
+    if (name == NULL) return rb_str_new2("[No class]");
+    else            return rb_str_new2(name);
+}
+
+
+typedef struct call_tree_t {
+    ID mid;
+    ID klass;
+    VALUE parent;
+    char* file;
+    list children;
+    int call_count;
+    prof_measure_t start_time;
+    prof_measure_t time;
+} call_tree_t;
+
+
+static int match(call_tree_t* ct, ID klass, ID mid, char* file)
+{
+    int match_class_and_mid = (klass == ct->klass) && (mid == ct->mid);
+    if (file) return match_class_and_mid && (strcmp(file, ct->file) == 0);
+    else      return match_class_and_mid;
+}
+
+
+static VALUE call_tree_create(VALUE self, ID klass, ID mid, char* file)
+{
+    VALUE args[4] = {self, klass, mid, file};
+    return rb_class_new_instance(4, &args[0], cCallTree);
+}
+
+/* CallTreeMethod */
+/* :nodoc: */
+VALUE call_tree_create_root()
+{
+    root = call_tree_create(Qnil, rb_str_new2(""), rb_str_new2(""), "");
+    return root;
+}
+
+
+static int mark(st_data_t key, st_data_t value, st_data_t data)
+{
+    rb_gc_mark(value);
+    return ST_CONTINUE;
+}
+
+static void call_tree_mark(call_tree_t* ct)
+{
+    rb_gc_mark(ct->klass);
+    rb_gc_mark(ct->parent);
+
+    //mark each of the children
+    int i;
+    for(i=0; i<list_size(ct->children); i++)
+    {
+        rb_gc_mark(list_get(ct->children, i));
+    }
+}
+
+static void call_tree_free(call_tree_t* ct)
+{
+    delete_list(ct->children);
+    xfree(ct);
+}
+
+static VALUE call_tree_alloc(ID klass)
+{
+    call_tree_t* call_tree_stuct;
+    call_tree_stuct = ALLOC(call_tree_t);
+    call_tree_stuct->children = new_list(10);
+    return Data_Wrap_Struct(klass, call_tree_mark, call_tree_free, call_tree_stuct);
+}
+
+static call_tree_t* get_call_tree(VALUE c_call_tree)
+{
+    call_tree_t* ct;
+    Data_Get_Struct(c_call_tree, call_tree_t, ct);
+    return ct;
+}
+
+
+
+void init_call_tree()
+{
+    cCallTree = rb_define_class("CallTree", rb_cObject);
+    call_tree_class_id = rb_intern("CallTree");
+    rb_define_alloc_func(cCallTree, call_tree_alloc);
+    rb_define_method(cCallTree, "initialize", call_tree_initialize, 4);
+    rb_define_method(cCallTree, "initialize_copy", call_tree_initialize_copy, 3);
+    rb_define_method(cCallTree, "[]", call_tree_fetch, 1);
+    rb_define_method(cCallTree, "size", call_tree_size, 0);
+    rb_define_method(cCallTree, "parent", call_tree_parent, 0);
+    rb_define_method(cCallTree, "children", call_tree_children, 0);
+    rb_define_method(cCallTree, "method", call_tree_method, 0);
+    rb_define_method(cCallTree, "klass", call_tree_klass, 0);
+    rb_define_method(cCallTree, "time", call_tree_time, 0);
+    rb_define_method(cCallTree, "file", call_tree_file, 0);
+    rb_define_method(cCallTree, "call_count", call_tree_call_count, 0);
+    rb_define_method(cCallTree, "method_start", call_tree_method_start, 4);
+    rb_define_method(cCallTree, "method_stop", call_tree_method_stop, 1);
+}
+
+VALUE call_tree_initialize(VALUE self, VALUE parent, ID klass, ID mid, char* file)
+{
+    call_tree_t* ct = get_call_tree(self);
+    ct->mid = mid;
+    ct->klass = klass;
+    ct->parent = parent;
+    ct->file = file;
+    ct->time = 0;
+    ct->call_count = 0;
+    return self;
+}
+
+VALUE call_tree_initialize_copy(VALUE copy, VALUE original)
+{
+    return copy;
+}
+
+VALUE call_tree_children(VALUE self)
+{
+    list children = get_call_tree(self)->children;
+    return rb_ary_new4(list_size(children), list_data(children));
+}
+
+VALUE call_tree_fetch(VALUE self, VALUE index)
+{
+    list children = get_call_tree(self)->children;
+    int i = NUM2INT(index);
+    
+    if (i >= list_size(children)) { return Qnil; }
+    
+    return list_get(children, i);
+}
+
+VALUE call_tree_size(VALUE self)
+{
+    return INT2NUM(call_tree_size2(self));
+}
+
+int call_tree_size2(VALUE self)
+{
+    list children = get_call_tree(self)->children;
+    int i;
+    int size = list_size(children);
+    int total_size = size;
+    for (i=0; i < size; i++)
+    {
+        total_size += call_tree_size2(list_get(children, i));
+    }
+    return total_size; 
+}
+
+VALUE call_tree_add(VALUE self, ID klass, ID mid, char* file)
+{
+    VALUE child = call_tree_create(self, klass, mid, file);
+    list_add(get_call_tree(self)->children, child);
+    return child;
+}
+
+VALUE call_tree_find_parent(VALUE self, ID klass, ID mid, char* file)
+{
+    if (NIL_P(self)) { return Qnil; }    
+    call_tree_t* ct = get_call_tree(self);
+        
+    if (match(ct, klass, mid, file))
+    {
+        return self;
+    }
+ 
+    return call_tree_find_parent(ct->parent, klass, mid, file);
+}
+
+VALUE find_thread_root(VALUE self)
+{
+    VALUE thread_new = call_tree_find_parent(self, rb_intern("[thread]"), Qnil, NULL);
+    
+    if (!NIL_P(thread_new)) return thread_new;
+    else                    return root;
+    
+}
+
+VALUE call_tree_create_thread(VALUE current, char* thread_id, char* file, prof_measure_t time)
+{
+      VALUE thread_new = call_tree_find_parent(current, rb_intern("<Class::Thread>"), rb_intern("new"), NULL);
+    return call_tree_method_start(call_tree_parent(thread_new), rb_str_new2("[thread]"), rb_intern(thread_id), file, time);
+}
+
+void update_time(call_tree_t* ct, prof_measure_t time)
+{
+    if (ct->start_time == NULL_TIME) return;
+
+    prof_measure_t ct_time = ct->time;
+    prof_measure_t start_time = ct->start_time;
+    prof_measure_t diff = time - start_time;
+    ct_time += diff;
+    ct->time = ct_time;
+    ct->start_time = NULL_TIME;
+    LOG("%s::%s time: %u\n", rb_id2name(ct->klass), rb_id2name(ct->mid), (unsigned int) ct->time);    
+}
+
+int thread_root(call_tree_t* ct)
+{
+    return ct->klass == rb_intern("[thread]");    
+}
+
+int sleep_method(call_tree_t* ct)
+{
+    return match(ct, rb_intern("Kernel"), rb_intern("sleep"), NULL);
+}
+
+void call_tree_method_pause(VALUE self, prof_measure_t time)
+{
+    VALUE method = self;
+    
+    while(1) 
+    {    
+      call_tree_t* ct = get_call_tree(method);
+      if (sleep_method(ct)) break;
+      LOG_EVENT("pause");
+      if (thread_root(ct) && ct->start_time == NULL_TIME) break;
+      assert(ct->start_time != NULL_TIME);
+      update_time(ct, time);
+      if (method == root || thread_root(ct)) break;
+      method = ct->parent;
+    }
+    LOG("pause complete\n");
+}
+
+void call_tree_method_resume(VALUE self, prof_measure_t time)
+{
+    VALUE method = self;
+    
+    while(1) 
+    {    
+        call_tree_t* ct = get_call_tree(method);
+        if (sleep_method(ct)) break;
+        LOG_EVENT("resume");
+        assert(ct->start_time == NULL_TIME);
+        ct->start_time = time;    
+        if (method == root || thread_root(ct)) break;
+        method = ct->parent;
+    }
+    LOG("resume complete\n");
+}
+
+VALUE call_tree_method_start(VALUE self, VALUE klass_string, ID mid, char* file, prof_measure_t time)
+{
+    if (NIL_P(self)) { return self; }
+    ID klass = rb_intern(StringValuePtr(klass_string));
+    if (klass == call_tree_class_id) { return self; }
+
+    call_tree_t* parent = get_call_tree(self);
+    if (parent->start_time == NULL_TIME && thread_root(parent))
+    {
+        call_tree_method_resume(self, time);
+    }
+
+    int is_recursive = 0;
+    VALUE method_call = call_tree_find_child(self, klass, mid, file);
+    if (NIL_P(method_call))
+    {
+        method_call = call_tree_find_parent(self, klass, mid, file);
+        if (NIL_P(method_call))
+        {
+            method_call = call_tree_add(self, klass, mid, file);
+        }
+        else
+        {
+            is_recursive = 1;
+        }
+    }
+    else if (NIL_P(call_tree_find_parent(self, klass, mid, file)))
+    {
+        is_recursive = 1;
+    }
+
+
+    call_tree_t* ct = get_call_tree(method_call);
+    if (!is_recursive || ct->start_time == NULL_TIME) 
+    { 
+        LOG_EVENT("start");
+        ct->start_time = time;
+    }
+    ct->call_count++;
+    return method_call;
+}
+  
+int recursive_call_child(call_tree_t* ct)
+{
+    return (NIL_P(call_tree_find_parent(ct->parent, ct->klass, ct->mid, ct->file))); 
+}
+
+VALUE call_tree_method_stop(VALUE self, prof_measure_t time)
+{
+    if (NIL_P(self)) { return self; }
+
+    call_tree_t* ct = get_call_tree(self);
+     
+    LOG_EVENT("stop");
+    if (recursive_call_child(ct))
+    {
+        update_time(ct, time);
+    }
+
+    call_tree_t* parent = get_call_tree(ct->parent);
+    if (thread_root(parent))
+    {
+        call_tree_method_pause(ct->parent, time);
+    }
+    return ct->parent;
+}
+
+VALUE call_tree_find_child(VALUE self, ID klass, ID mid, char* file)
+{
+    list children = get_call_tree(self)->children;
+    int size = list_size(children);
+
+    int i;
+    for (i=0; i < size; i++)
+    {
+        VALUE child = list_get(children, i);
+        call_tree_t* ct = get_call_tree(child);
+        if (match(ct, klass, mid, file)) 
+        {
+            return child;
+        }
+    }
+    return Qnil;
+}
+
+
+
+VALUE call_tree_method(VALUE self)
+{
+    return method_name_text(get_call_tree(self)->mid);
+}
+
+VALUE call_tree_klass(VALUE self)
+{
+    return class_name_text(get_call_tree(self)->klass);
+}
+
+VALUE call_tree_time(VALUE self)
+{
+    return rb_float_new(convert_measurement(get_call_tree(self)->time));
+}
+
+VALUE call_tree_call_count(VALUE self)
+{
+    return rb_int_new(get_call_tree(self)->call_count);
+}
+
+VALUE call_tree_parent(VALUE self)
+{
+    return get_call_tree(self)->parent;
+}
+
+VALUE call_tree_file(VALUE self)
+{
+    return rb_str_new2(get_call_tree(self)->file);
+}