ruby-prof 0.7.10 → 0.8.1

data/CHANGES

@@ -1,3 +1,8 @@
+0.7.10 (2009-01-22)
+=======================
+* fix SEGFAULT in 1.9
+* add new printer flat_printer_with_line_numbers
+
 0.7.7 (2009-01-13)
 ======================
 * "fix" multi threading support for 1.9 http://redmine.ruby-lang.org/issues/show/2012

data/Rakefile

@@ -123,7 +123,7 @@ end
 
 require 'fileutils'
 
-desc 'Build ext/ruby_prof.so'
+desc 'Build ruby_prof.so'
 task :build do
  build(false)
 end
@@ -144,7 +144,7 @@ def build(with_debug)
 end
 
 desc 'build ruby_prof.so with verbose symbols enabled'
-task :build_with_debug do
+task :build_debug do
  build(true)
 end
 

data/bin/go.rb

@@ -0,0 +1,2 @@
+require 'rubygems'
+Gem::Specification

data/ext/ruby_prof.c

@@ -884,9 +884,6 @@ get_event_name(rb_event_flag_t event)
 }
 #endif
 
-
-// these differ 1.9/1.8
-
 static prof_method_t* 
 #ifdef RUBY_VM
  get_method(rb_event_flag_t event, VALUE klass, ID mid, int depth, st_table* method_table)
@@ -924,7 +921,6 @@ update_result(prof_measure_t total_time,
               prof_frame_t *frame)
 {
     prof_measure_t self_time = total_time - frame->child_time - frame->wait_time;
-    
     prof_call_info_t *call_info = frame->call_info;
     
     /* Update information about the current method */
@@ -941,15 +937,15 @@ update_result(prof_measure_t total_time,
 static thread_data_t *
 switch_thread(VALUE thread_id, prof_measure_t now)
 {
-    prof_frame_t *frame = NULL;
-    prof_measure_t wait_time = 0;
+	prof_frame_t *frame = NULL;
+	prof_measure_t wait_time = 0;
     /* Get new thread information. */
     thread_data_t *thread_data = threads_table_lookup(threads_tbl, thread_id);
 
     /* How long has this thread been waiting? */
     wait_time = now - thread_data->last_switch;
     
-    thread_data->last_switch = 0;
+    thread_data->last_switch = now; // XXXX a test that fails if this is 0
 
     /* Get the frame at the top of the stack.  This may represent
        the current method (EVENT_LINE, EVENT_RETURN)  or the
@@ -959,8 +955,6 @@ switch_thread(VALUE thread_id, prof_measure_t now)
     if (frame) {
       frame->wait_time += wait_time;
     }
-    
-    
       
     /* Save on the last thread the time of the context switch
        and reset this thread's last context switch to 0.*/
@@ -995,7 +989,7 @@ pop_frame(thread_data_t *thread_data, prof_measure_t now)
   parent_frame = stack_peek(thread_data->stack);
   if (parent_frame)
   {
-    parent_frame->child_time += total_time;
+  	parent_frame->child_time += total_time;
   }
     
   update_result(total_time, parent_frame, frame); // only time it's called
@@ -1024,18 +1018,19 @@ pop_frames(st_data_t key, st_data_t value, st_data_t now_arg)
 static void 
 prof_pop_threads()
 {
-    /* Get current measurement*/
+    /* Get current measurement */
     prof_measure_t now = get_measurement();
     st_foreach(threads_tbl, pop_frames, (st_data_t) &now);
 }
 
 
 #ifdef RUBY_VM
+
+/* These are mostly to avoid bugs in core */
+static inline void walk_up_until_right_frame(prof_frame_t *frame, thread_data_t* thread_data, ID mid, VALUE klass, prof_measure_t now);
 void prof_install_hook();
 void prof_remove_hook();
-#endif
 
-#ifdef RUBY_VM
 static void
 prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
 #else
@@ -1049,15 +1044,15 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     thread_data_t* thread_data = NULL;
     prof_frame_t *frame = NULL;
 
-
-#ifdef RUBY_VM
-
-    if (event != RUBY_EVENT_C_CALL && event != RUBY_EVENT_C_RETURN) {
-        // guess these are already set for C call in 1.9?
+    #ifdef RUBY_VM
+      if (event != RUBY_EVENT_C_CALL && event != RUBY_EVENT_C_RETURN) {
+        // guess these are already set for C calls in 1.9, then?
         rb_frame_method_id_and_class(&mid, &klass);
-    }
-    
-#endif
+      }
+    #endif
+
+    /* Get current timestamp */
+    now = get_measurement();
 
 #ifdef DEBUG
     /*  This code is here for debug purposes - uncomment it out
@@ -1068,9 +1063,9 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
 
         VALUE thread = rb_thread_current();
         VALUE thread_id = rb_obj_id(thread);
-        char* class_name = NULL;
-        char* method_name = rb_id2name(mid);
-        char* source_file = rb_sourcefile();
+        const char* class_name = NULL;
+        const char* method_name = rb_id2name(mid);
+        const char* source_file = rb_sourcefile();
         unsigned int source_line = rb_sourceline();
 
         char* event_name = get_event_name(event);
@@ -1083,9 +1078,9 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         if (last_thread_id != thread_id) {
           printf("\n");
         }
-
-        printf("%2u: %-8s %s:%2d  %s#%s\n",
-               thread_id, event_name, source_file, source_line, class_name, method_name);
+        
+        printf("%2u:%2ums %-8s %s:%2d  %s#%s\n",
+               (unsigned int) thread_id, (unsigned int) now, event_name, source_file, source_line, class_name, method_name);
         fflush(stdout);
         last_thread_id = thread_id;               
     }
@@ -1096,18 +1091,15 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
        the results but aren't important to them results. */
     if (self == mProf) return;
 
-    /* Get current measurement*/
-    now = get_measurement();
-    
     /* Get the current thread information. */
     thread = rb_thread_current();
     thread_id = rb_obj_id(thread);
     
-#ifdef RUBY_VM
-    /* ensure that new threads are hooked [sigh] */
-   prof_remove_hook();
-   prof_install_hook();
-#endif
+   # ifdef RUBY_VM
+     /* ensure that new threads are hooked [sigh] (bug in core) */
+     prof_remove_hook();
+     prof_install_hook();
+   # endif
 
     if (exclude_threads_tbl &&
         st_lookup(exclude_threads_tbl, (st_data_t) thread_id, 0)) 
@@ -1115,24 +1107,34 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
       return;
     }    
     
+    
     /* Was there a context switch? */
     if (!last_thread_data || last_thread_data->thread_id != thread_id)
       thread_data = switch_thread(thread_id, now);
     else
       thread_data = last_thread_data;
     
-    /* Get the current frame for the current thread. */
-    frame = stack_peek(thread_data->stack);
-
+    
     switch (event) {
     case RUBY_EVENT_LINE:
     {
       /* Keep track of the current line number in this method.  When
          a new method is called, we know what line number it was 
          called from. */
+         
+       /* Get the current frame for the current thread. */
+      frame = stack_peek(thread_data->stack);
+
       if (frame)
       {
-        frame->line = rb_sourceline();
+        frame->line = rb_sourceline();        
+        
+        # ifdef RUBY_VM
+          // disabled till I figure out why it causes
+          // us to lose valuable frame information...maybe mid comes in wrong sometimes?
+          // walk_up_until_right_frame(frame, thread_data, mid, klass, now);
+        # endif
+        
         break;
       }
 
@@ -1143,6 +1145,8 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     case RUBY_EVENT_CALL:
     case RUBY_EVENT_C_CALL:
     {
+        /* Get the current frame for the current thread. */
+        frame = stack_peek(thread_data->stack);
         prof_call_info_t *call_info = NULL;
         prof_method_t *method = NULL;
 
@@ -1154,20 +1158,20 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
           klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
           
         /* Assume this is the first time we have called this method. */
-#ifdef RUBY_VM
-        method = get_method(event, klass, mid, 0, thread_data->method_table);
-#else
-        method = get_method(event, node, klass, mid, 0, thread_data->method_table);
-#endif
+        #ifdef RUBY_VM
+          method = get_method(event, klass, mid, 0, thread_data->method_table);
+        #else
+          method = get_method(event, node, klass, mid, 0, thread_data->method_table);
+        #endif
         /* Check for a recursive call */
-        while (method->active) // it's while because we start at 0 and then go down to the right depth
+        while (method->active) // it's while because we start at 0 and then inc. to the right recursive depth
         {
           /* Yes, this method is already active somewhere up the stack */
-#ifdef RUBY_VM
-          method = get_method(event, klass, mid, method->key->depth + 1, thread_data->method_table);
-#else
-          method = get_method(event, node, klass, mid, method->key->depth + 1, thread_data->method_table);
-#endif
+          #ifdef RUBY_VM
+            method = get_method(event, klass, mid, method->key->depth + 1, thread_data->method_table);
+          #else
+            method = get_method(event, node, klass, mid, method->key->depth + 1, thread_data->method_table);
+          #endif
         }          
         method->active = 1;                
 
@@ -1195,27 +1199,35 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         frame->wait_time = 0;
         frame->child_time = 0;
         frame->line = rb_sourceline();
-
         break;
     }
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_C_RETURN:
-    {
-        frame = pop_frame(thread_data, now);
-#ifdef RUBY_VM
-          // we need to walk up the stack to find the right one [http://redmine.ruby-lang.org/issues/show/2610] (for now)
-          // sometimes frames don't have line and source somehow [like blank]
-          // if we hit one there's not much we can do...I guess...
-          // or maybe we don't have one because we're at the top or something.
-        while( frame && frame->call_info->target->key->mid && frame->call_info->target->key->klass && ((frame->call_info->target->key->mid != mid) || (frame->call_info->target->key->klass != klass))){
-           frame = pop_frame(thread_data, now);
-         }      
-#endif
-        break;
-      }
+    {      
+    	frame = pop_frame(thread_data, now);
+      
+      # ifdef RUBY_VM
+        // we need to walk up the stack to find the right one [http://redmine.ruby-lang.org/issues/show/2610] (for now)
+        // sometimes frames don't have line and source somehow [like blank]
+        // if we hit one there's not much we can do...I guess...
+        // or maybe we don't have one because we're at the top or something.
+        walk_up_until_right_frame(frame, thread_data, mid, klass, now);
+      # endif
+                
+      break;
+    }
     }
 }
 
+#ifdef RUBY_VM
+
+static inline void walk_up_until_right_frame(prof_frame_t *frame, thread_data_t* thread_data, ID mid, VALUE klass, prof_measure_t now) {
+  // while it doesn't match, pop on up until we have found where we belong...
+  while( frame && frame->call_info->target->key->mid && frame->call_info->target->key->klass && ((frame->call_info->target->key->mid != mid) || (frame->call_info->target->key->klass != klass))){
+    frame = pop_frame(thread_data, now);
+  }
+}
+#endif
 
 /* ========  ProfResult ============== */
 
@@ -1429,7 +1441,7 @@ prof_install_hook()
     rb_add_event_hook(prof_event_hook,
           RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
           RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN 
-            | RUBY_EVENT_LINE, Qnil); //  | RUBY_EVENT_SWITCH
+            | RUBY_EVENT_LINE, Qnil); // RUBY_EVENT_SWITCH
 #else
     rb_add_event_hook(prof_event_hook,
           RUBY_EVENT_CALL | RUBY_EVENT_RETURN |

data/ext/version.h

@@ -1,4 +1,4 @@
-#define RUBY_PROF_VERSION  "0.7.10"
+#define RUBY_PROF_VERSION  "0.8.1"
 #define RUBY_PROF_VERSION_MAJ   0
-#define RUBY_PROF_VERSION_MIN   7
-#define RUBY_PROF_VERSION_MIC   10
+#define RUBY_PROF_VERSION_MIN   8
+#define RUBY_PROF_VERSION_MIC   1

data/lib/ruby-prof.rb

@@ -9,6 +9,7 @@ require "ruby-prof/graph_printer"
 require "ruby-prof/graph_html_printer"
 require "ruby-prof/call_tree_printer"
 require "ruby-prof/symbol_to_proc" # for 1.8's benefit
+#require "ruby-prof/result"
 
 module RubyProf
   # See if the user specified the clock mode via 

data/lib/ruby-prof/flat_printer.rb

@@ -75,5 +75,4 @@ module RubyProf
       end
     end
   end
-end 
-
+end

data/lib/ruby-prof/flat_printer_with_line_numbers.rb

@@ -1,5 +1,5 @@
 require 'ruby-prof/abstract_printer'
-
+require 'pathname'
 module RubyProf
   # Generates flat[link:files/examples/flat_txt.html] profile reports as text. 
   # To use the flat printer with line numbers:
@@ -31,7 +31,6 @@ module RubyProf
       @output << "Total: %0.6f\n" % total_time
       @output << "\n"
       @output << " %self     total     self     wait    child    calls  name\n"
-
       sum = 0    
       methods.each do |method|
         self_percent = (method.self_time / total_time) * 100
@@ -48,14 +47,24 @@ module RubyProf
                       method.wait_time,                    # wait
                       method.children_time,                # children
                       method.called,                       # calls
-                      method_name(method),                 # name
-                      method.source_file,                  # filename
-                      method.line                          # line in said file 
+                      method_name(method),                 # name                      
                   ]
          if method.source_file != 'ruby_runtime'
-           @output << "  %s:%s" % [method.source_file, method.line]
+           @output << "  %s:%s" % [File.expand_path(method.source_file), method.line]
          end
-         @output << "\n"         
+         @output << "\n\tcalled from: "
+         
+         # make sure they're unique
+         method.call_infos.map{|ci| 
+           if ci.parent && ci.parent.target.source_file != 'ruby_runtime'
+              [method_name(ci.parent.target), File.expand_path(ci.parent.target.source_file), ci.parent.target.line]
+           else
+              nil
+           end 
+         }.compact.uniq.each{|args|
+             @output << " %s (%s:%s) " % args             
+         }
+         @output << "\n\n"         
       end
     end
   end

data/test/basic_test.rb

@@ -148,15 +148,15 @@ class BasicTest < Test::Unit::TestCase
 
     # Check times
     assert_in_delta(0.2, methods[0].total_time, 0.02)
-    assert_in_delta(0, methods[0].wait_time, 0.01)
-    assert_in_delta(0, methods[0].self_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
 
     assert_in_delta(0.2, methods[1].total_time, 0.02)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
 
     assert_in_delta(0.2, methods[2].total_time, 0.02)
-    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
     assert_in_delta(0.2, methods[2].self_time, 0.02)
 
     assert_in_delta(0, methods[3].total_time, 0.01)

data/test/prime.rb

@@ -54,5 +54,5 @@ def run_primes
   primes = find_primes(random_array)
   
   # Find the largest primes
-  largest = find_largest(primes)
+  # largest = find_largest(primes)
 end

data/test/printers_test.rb

@@ -1,15 +1,22 @@
 #!/usr/bin/env ruby
 require 'test/unit'
 require 'ruby-prof'
-require './prime'
+require File.dirname(__FILE__) + '/prime'
 
 # --  Tests ----
 class PrintersTest < Test::Unit::TestCase
+  
+  def go
+    run_primes
+  end
+  
   def setup
-    RubyProf::measure_mode = RubyProf::PROCESS_TIME
+    RubyProf::measure_mode = RubyProf::WALL_TIME # WALL_TIME so we can use sleep in our test
     @result = RubyProf.profile do
       run_primes
+      go
     end
+    
   end
     
   def test_printers
@@ -26,10 +33,8 @@ class PrintersTest < Test::Unit::TestCase
     printer.print
     
     printer = RubyProf::CallTreePrinter.new(@result)
-    printer.print(STDOUT)
-    
-    # we should get here
-    assert(true)
+    printer.print(STDOUT)    
+    # we should get here    
   end
 
   def test_flat_string
@@ -41,7 +46,7 @@ class PrintersTest < Test::Unit::TestCase
     output = ''
     
     printer = klass.new(@result)
-    assert_nothing_raised { printer.print(output) }
+    printer.print(output)
     
     assert_match(/Thread ID: -?\d+/i, output)
     assert_match(/Total: \d+\.\d+/i, output)
@@ -53,12 +58,22 @@ class PrintersTest < Test::Unit::TestCase
     output = helper_test_flat_string RubyProf::FlatPrinterWithLineNumbers
     assert_match(/prime.rb/, output)    
     assert_no_match(/ruby_runtime:0/, output)
+    assert_match(/called from/, output)
+    
+    # should combine common parents
+    if RUBY_VERSION < '1.9'
+        assert_equal(3, output.scan(/Object#is_prime/).length)
+	  else
+		  # 1.9
+		  assert_equal(2, output.scan(/Object#is_prime/).length)		
+    end
+	  assert_no_match(/\.\/test\/prime.rb/, output) # don't use relative paths
   end
     
   def test_graph_html_string
     output = ''
     printer = RubyProf::GraphHtmlPrinter.new(@result)
-    assert_nothing_raised { printer.print(output) }
+    printer.print(output)
 
     assert_match( /DTD HTML 4\.01/i, output )
     assert_match( %r{<th>Total Time</th>}i, output )
@@ -68,7 +83,7 @@ class PrintersTest < Test::Unit::TestCase
   def test_graph_string
     output = ''
     printer = RubyProf::GraphPrinter.new(@result)
-    assert_nothing_raised { printer.print(output) }
+    printer.print(output)
 
     assert_match( /Thread ID: -?\d+/i, output )
     assert_match( /Total Time: \d+\.\d+/i, output )
@@ -78,9 +93,38 @@ class PrintersTest < Test::Unit::TestCase
   def test_call_tree_string
     output = ''
     printer = RubyProf::CallTreePrinter.new(@result)
-    assert_nothing_raised { printer.print(output) }
+    printer.print(output)
 
     assert_match(/fn=Object::find_primes/i, output)
-    assert_match(/events: process_time/i, output)
+    assert_match(/events: wall_time/i, output)
+  end
+  
+  def do_nothing
+    start = Time.now
+    while(Time.now == start)
+    end
   end
+  
+  def test_all_with_small_percentiles
+    
+    result = RubyProf.profile do
+      sleep 2
+      do_nothing 
+    end
+    
+    # RubyProf::CallTreePrinter doesn't "do" a min_percent
+    # RubyProf::FlatPrinter only outputs if self time > percent...
+    # RubyProf::FlatPrinterWithLineNumbers same
+    for klass in [ RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter]
+      puts klass
+      printer = klass.new(result)
+      out = ''
+      output = printer.print(out, :min_percent => 0.00000001 )
+      assert_match(/do_nothing/, out)      
+    end
+    
+  end    
+  
+  
+  
 end

data/test/recursive_test.rb

@@ -57,10 +57,10 @@ class RecursiveTest < Test::Unit::TestCase
     method = methods[1]
     assert_equal('Object#simple', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(2, method.children_time, 0.01)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.02)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]

data/test/stack_test.rb

@@ -67,7 +67,7 @@ class StackTest < Test::Unit::TestCase
     method = methods[1]
     assert_equal('StackClass#a', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(8, method.total_time, 0.05)
+    assert_in_delta(8, method.total_time, 0.15)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(8, method.children_time, 0.05)

data/test/thread_test.rb

@@ -45,8 +45,12 @@ class ThreadTest < Test::Unit::TestCase
   end
 
   def test_thread_timings
-    RubyProf.start    
+  	RubyProf.start    
     thread = Thread.new do
+      sleep 0 # force it to hit thread.join, below, first
+      # thus forcing sleep(1), below, to be counted as (wall) self_time
+      # since we currently count time "in some other thread" as self.wait_time
+      # for whatever reason
       sleep(1)
     end
     thread.join
@@ -71,10 +75,10 @@ class ThreadTest < Test::Unit::TestCase
 
     method = methods[1]
     assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(1, method.called)
+    assert_equal(2, method.called)
     assert_in_delta(1, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(1.0, method.wait_time, 0.01)
+    assert_in_delta(1.0, method.self_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(0, method.children_time, 0.01)
 
     assert_equal(1, method.call_infos.length)
@@ -91,7 +95,7 @@ class ThreadTest < Test::Unit::TestCase
     assert_equal('ThreadTest#test_thread_timings', method.full_name)
     # the sub calls to Object#new, when popped,
     # cause the parent frame to be created for method #test_thread_timings, which means a +1 when it's popped in the end
-    # xxxx a test that shows it the other way, too
+    # xxxx a test that shows it the other way, too (never creates parent frame--if that's even possible)
     assert_equal(1, method.called) 
     assert_in_delta(1, method.total_time, 0.01)
     assert_in_delta(0, method.self_time, 0.05)
@@ -107,10 +111,8 @@ class ThreadTest < Test::Unit::TestCase
     assert_equal('Thread#join', method.full_name)
     assert_equal(1, method.called)
     assert_in_delta(1, method.total_time, 0.01)
-    assert_in_delta(1.0, method.self_time, 0.01) 
-    # todo this is a bug since #sleep really isn't using self_time--it's sleep time!
-    # but for our purposes...I guess that's ok for now...sure.
-    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(0, method.self_time, 0.01) 
+    assert_in_delta(1.0, method.wait_time, 0.01)
     assert_in_delta(0, method.children_time, 0.01)
 
     assert_equal(1, method.call_infos.length)
@@ -145,6 +147,17 @@ class ThreadTest < Test::Unit::TestCase
     assert_equal(0, call_info.children.length)
   end
   
+  # useless test
+  def test_thread_back_and_forth
+  	result = RubyProf.profile do
+  		a = Thread.new { 100_000.times { sleep 0 }}
+  		b = Thread.new { 100_000.times { sleep 0 }}
+  		a.join
+  		b.join
+  	end
+  	assert result.threads.values.flatten.sort[-1].total_time < 10 # 10s  	
+  end
+  
   def test_thread
     result = RubyProf.profile do
       begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-prof
 version: !ruby/object:Gem::Version 
-  version: 0.7.10
+  version: 0.8.1
 platform: ruby
 authors: 
 - Shugo Maeda, Charlie Savage, Roger Pack
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-22 00:00:00 -07:00
+date: 2010-02-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,6 +42,7 @@ files:
 - README
 - LICENSE
 - CHANGES
+- bin/go.rb
 - bin/ruby-prof
 - examples/flat.txt
 - examples/graph.html