ruby-prof 0.5.0-mswin32 → 0.5.1-mswin32

data/CHANGES

@@ -1,33 +1,61 @@
-0.5.0 (?)
+0.5.1 (2007-07-18)
+========================
+
+ruby-prof 0.5.1 is a bug fix and performance release.
+
+Performance
+--------
+* Significantly reduced the number of thread lookups by
+  caching the last executed thread.
+
+Fixes
+-------
+* Properly escape method names in HTML reports
+* Fix use of -m and --min-percent command line switches
+* Default source file information to ruby_runtime#0 for c calls
+* Moved rails_plugin to top level so it is more obvious
+* Updated rails_plugin to write reports to the current
+  Rails log directory
+* Added additional tests
+
+
+0.5.0 (2007-07-09)
 ========================
 
 Features
 --------
-* Added support for 64 bit systems (patch from Diego 'Flameeyes' Petten�)
+* Added support for timing multi-threaded applications
+* Added support for 64 bit systems (patch from Diego 'Flameeyes' Petten)
 * Added suport for outputting data in the format used by
   KCacheGrind (patch from Carl Shimer)
 * Add filename and line numbers to call tree information (patch from Carl Shimer)
 * Added Visual Studio 2005 project file.
+* Added replace-progname switch, als rcov.
+* Added better support for recursive methods
+* Added better support for profiling Rails applications
 
 Fixes
 -------
-* Fixes a bug when the type of an attached object (singleton) is inherited
-  from T_OBJECT as opposed to being a T_OBJECT (identified by Francis Cianfrocca)
-
+* Fixes bug when the type of an attached object (singleton) is inherited
+  from T_OBJECT as opposed to being a T_OBJECT (identified by Francis Cianfrocca)
+* ruby-prof now works in IRB.
+* Fix sort order in reports.
+* Fixed rdoc compile error.
+* Fix tabs in erb template for graph html report on windows.
 
 0.4.1 (2006-06-26)
 ========================
 
 Features
 --------
-* Added a RubyProf.running? method to indicate whether a profile is in progress.
+* Added a RubyProf.running? method to indicate whether a profile is in progress.
 * Added tgz and zip archives to release
 
 Fixes
 -------
-* Duplicate method names are now allowed
-* The documentation has been updated to show the correct API usage is RubyProf.stop not RubyProf.end
-
+* Duplicate method names are now allowed
+* The documentation has been updated to show the correct API usage is RubyProf.stop not RubyProf.end
+
 
 0.4.0 (2006-06-16)
 ========================

data/README

@@ -61,7 +61,7 @@ particular segments of code.
   # Print a flat profile to text
   printer = RubyProf::TextPrinter.new(result)
   printer.print(STDOUT, 0)
-	
+  
 Alternatively, you can use a block to tell ruby-prof what
 to profile:
 
@@ -83,7 +83,7 @@ to profile:
 
 The third way of using ruby-prof is by requiring unprof.rb:
 
-	require 'unprof'
+  require 'unprof'
 
 This will start profiling immediately and will output the results
 using a flat profile report.
@@ -195,11 +195,11 @@ You may also specify the measure_mode by using the RUBY_PROF_MEASURE_MODE
 environment variable:
 
 * export RUBY_PROF_MEASURE_MODE=process
-*	export RUBY_PROF_MEASURE_MODE=wall
+* export RUBY_PROF_MEASURE_MODE=wall
 * export RUBY_PROF_MEASURE_MODE=cpu
 * export RUBY_PROF_MEASURE_MODE=allocations
   
-Note that these values have changed since ruby-prof-0.3.0.	
+Note that these values have changed since ruby-prof-0.3.0.  
 
 On Linux, process time is measured using the clock method provided 
 by the C runtime library. Note that the clock method does not
@@ -214,6 +214,12 @@ provided by the C runtime library.  Note though, these values are
 wall times on Windows and not process times like on Linux.
 Wall time is measured using the GetLocalTime API.
 
+If you use wall time, the results will be affected by other
+processes running on your computer, network delays, disk access,
+etc.  As result, for the best results, try to make sure your
+computer is only performing your profiling run and is 
+otherwise quiescent.
+
 On both platforms, cpu time is measured using the RDTSC assembly
 function provided by the Pentium and PowerPC platforms. CPU time
 is dependent on the cpu's frequency.  On Linux, ruby-prof attempts 
@@ -221,31 +227,62 @@ to read this value from "/proc/cpuinfo."  On Windows, you must
 specify the clock frequency.  This can be done using the
 RUBY_PROF_CPU_FREQUENCY environment variable:
 
-	export RUBY_PROF_CPU_FREQUENCY=<value>
-	
+  export RUBY_PROF_CPU_FREQUENCY=<value>
+  
 You can also directly set the cpu frequency by calling:
 
-	RubyProf.cpu_frequency = <value> 
+  RubyProf.cpu_frequency = <value> 
 
 
 == Recursive Calls
 
 Recursive calls occur when method A calls method A and cycles
 occur when method A calls method B calls method C calls method A.
-ruby-prof can detect recursive calls any cycle calls, but does not
-currently report these in its output.
+ruby-prof detects both direct recursive calls and cycles.  Both
+are indicated in reports by a dash and number following a method
+name.  For example, here is a flat profile from the test method
+RecursiveTest#test_recursive:
+
+
+%self     total     self     wait    child    calls  name
+100.00      2.00     2.00     0.00     0.00        2  Kernel#sleep
+  0.00      2.00     0.00     0.00     2.00        0  RecursiveTest#test_cycle
+  0.00      0.00     0.00     0.00     0.00        2  Fixnum#==
+  0.00      0.00     0.00     0.00     0.00        2  Fixnum#-
+  0.00      1.00     0.00     0.00     1.00        1  Object#sub_cycle-1
+  0.00      2.00     0.00     0.00     2.00        1  Object#sub_cycle
+  0.00      2.00     0.00     0.00     2.00        1  Object#cycle
+  0.00      1.00     0.00     0.00     1.00        1  Object#cycle-1
+
+Notice the presence of Object#cycle and Object#cycle-1.  The -1 means
+the method was either recursively called (directly or indirectly).
 
 However, the self time values for recursive calls should always 
 be accurate.  It is also believed that the total times are
 accurate, but these should be carefully analyzed to verify their veracity.
 
+== Multi-threaded Applications
+
+Unfortunately, Ruby does not provide an internal api
+for detecting thread context switches.  As a result, the
+timings ruby-prof reports for each thread may be slightly
+inaccurate.  In particular, this will happen for newly 
+spanned threads that immediately go to sleep.  For instance,
+if you use Ruby's timeout library to wait for 2 seconds,
+the 2 seconds will be assigned to the foreground thread
+and not the newly created background thread.  These errors
+can largely be avoided if the background thread performs an
+operation before going to sleeep. 
+
+
 == Performance
 
 Significant effort has been put into reducing ruby-prof's overhead
 as much as possible.  Our tests show that the overhead associated
 with profiling code varies considerably with the code being
-profiled.  On the low end overhead is around 10% while on the
-high end its can around 80%.
+profiled.  Most programs will run approximately twice as slow
+while highly recursive programs (like the fibonacci series test)
+will run three times slower.
 
 == Windows Binary
 

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/rdoctask'
 SO_NAME = "ruby_prof.so"
 
 # ------- Default Package ----------
-RUBY_PROF_VERSION = "0.5.0"
+RUBY_PROF_VERSION = "0.5.1"
 
 FILES = FileList[
   'Rakefile',
@@ -117,16 +117,16 @@ Rake::RDocTask.new("rdoc") do |rdoc|
   rdoc.options << "--inline-source" << "--line-numbers"
   # Make the readme file the start page for the generated html
   rdoc.options << '--main' << 'README'
-  rdoc.rdoc_files.include('bin/**/*',
-                          'doc/*.rdoc',
-                          'examples/flat.txt',
-                          'examples/graph.txt',
-                          'examples/graph.html',
-                          'lib/**/*.rb',
-                          'ext/**/ruby_prof.c',
-                          'README',
-                          'LICENSE')
-end
+  rdoc.rdoc_files.include('bin/**/*',
+                          'doc/*.rdoc',
+                          'examples/flat.txt',
+                          'examples/graph.txt',
+                          'examples/graph.html',
+                          'lib/**/*.rb',
+                          'ext/**/ruby_prof.c',
+                          'README',
+                          'LICENSE')
+end
 
 
 # ---------  Publish to RubyForge  ----------------

data/bin/ruby-prof

@@ -15,7 +15,10 @@
 #                                        graph_html - Prints a graph profile as html.
 #                                        call_tree - format for KCacheGrind
 #     -f, --file=path                  Output results to a file instead of standard out.
-#     -m, --measure-mode=measure_mode  Select a measurement mode:
+#     -m, --min_percent=min_percent    The minimum percent a method must take before ',
+#                                      being included in output reports.  Should be an
+#                                      integer between 1 and 100.  0 means all methods are printed.
+#         --mode=measure_mode          Select a measurement mode:
 #                                        process - Use process time (default).
 #                                        wall - Use wall time.
 #                                        cpu - Use the CPU clock counter
@@ -79,16 +82,15 @@ opts = OptionParser.new do |opts|
     options.file = file
   end
     
-  opts.on('-m measure_mode', '--measure-mode=measure_mode',
+  opts.on('--mode=measure_mode',
       [:process, :wall, :cpu, :allocations],
       'Select what ruby-prof should measure:',
       '  process - Process time (default).',
       '  wall - Wall time.',
-      '  cpu - CPU time',
-      '        (only supported on Pentium and PowerPCs).',
-      '  allocations - O3bject allocations (required patched Ruby interpreter).') do |measure_mode|
+      '  cpu - CPU time (Pentium and PowerPCs only).',
+      '  allocations - Object allocations (requires patched Ruby interpreter).') do |measure_mode|
       
-      case measure_mode
+      case mode
       when :process
         options.measure_mode = RubyProf::PROCESS_TIME     
       when :wall
@@ -100,14 +102,15 @@ opts = OptionParser.new do |opts|
       end
   end
         
-        opts.on("--replace-progname", "Replace $0 when loading the .rb files.") do
-                options.replace_prog_name = true
-        end
+  opts.on("--replace-progname", "Replace $0 when loading the .rb files.") do
+          options.replace_prog_name = true
+  end
     
   opts.on_tail("-h", "--help", "Show help message") do
       puts opts
       exit
   end
+  
   opts.on_tail("-v", "--version", "Show version") do
       puts "ruby_prof " + RubyProf::VERSION
       exit
@@ -147,11 +150,11 @@ at_exit {
   # Get output
   if options.file
     File.open(options.file, 'w') do |file|
-      printer.print(file, options.min_percent)
+      printer.print(file, {:min_percent => options.min_percent})
     end
   else
     # Print out results 
-    printer.print(STDOUT, options.min_percent)
+    printer.print(STDOUT, {:min_percent => options.min_percent})
   end
 }
 

data/ext/ruby_prof.c

@@ -57,7 +57,7 @@
 
 /* ================  Constants  =================*/
 #define INITIAL_STACK_SIZE 8
-#define PROF_VERSION "0.5.0"
+#define PROF_VERSION "0.5.1"
 
 
 /* ================  Measurement  =================*/
@@ -159,7 +159,9 @@ static thread_data_t* last_thread_data = NULL;
 static inline long
 get_thread_id(VALUE thread)
 {
-    return NUM2ULONG(rb_obj_id(thread));
+    //return NUM2ULONG(rb_obj_id(thread));
+    // From line 1997 in gc.c
+    return (long)thread;
 }
 
 static VALUE
@@ -572,7 +574,8 @@ the RubyProf::Result object.
 
 /* :nodoc: */
 static prof_method_t *
-prof_method_create(NODE *node, st_data_t key, VALUE klass, ID mid, int depth)
+prof_method_create(st_data_t key, VALUE klass, ID mid, int depth, 
+                   const char* source_file, int line)
 {
     prof_method_t *result = ALLOC(prof_method_t);
     
@@ -590,8 +593,8 @@ prof_method_create(NODE *node, st_data_t key, VALUE klass, ID mid, int depth)
     result->active_frame = 0;
     result->base = result;
         
-    result->source_file = (node ? node->nd_file : 0);
-    result->line =        (node ? nd_line(node) : 0);
+    result->source_file = source_file;
+    result->line = line;
     return result;
 }
 
@@ -706,7 +709,7 @@ static VALUE prof_method_source_file(VALUE self)
     const char* sf = get_prof_method(self)->source_file;
     if(!sf)
     {
-      return Qnil;
+      return rb_str_new2("ruby_runtime");
     }
     else
     {
@@ -917,25 +920,23 @@ threads_table_insert(st_table *table, VALUE thread, thread_data_t *thread_data)
 }
 
 static inline thread_data_t *
-threads_table_lookup(st_table *table, VALUE thread)
+threads_table_lookup(st_table *table, long thread_id)
 {
     thread_data_t* result;
     st_data_t val;
 
     /* Its too slow to key on the real thread id so just typecast thread instead. */
-    if (st_lookup(table, (st_data_t) thread, &val))
+    if (st_lookup(table, (st_data_t) thread_id, &val))
     {
       result = (thread_data_t *) val;
     }
     else
     {
         result = thread_data_create();
-
-        /* Store the real thread id here so it can be shown in the results. */
-        result->thread_id = get_thread_id(thread);
+        result->thread_id = thread_id;
 
         /* Insert the table */
-        threads_table_insert(threads_tbl, thread, result);
+        threads_table_insert(threads_tbl, thread_id, result);
     }
     return result;
 }
@@ -1076,10 +1077,11 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     VALUE thread;
     prof_measure_t now = 0;
     thread_data_t* thread_data = NULL;
+    long thread_id = 0;
     prof_frame_t *frame = NULL;
     
-    
-/*    {
+    /*
+    {
         st_data_t key = 0;
         static unsigned long last_thread_id = 0;
 
@@ -1110,29 +1112,42 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     /* Get current measurement*/
     now = get_measurement();
     
-    /* Get the current thread and thread data. */
+    /* Get the current thread information. */
     thread = rb_thread_current();
-    thread_data = threads_table_lookup(threads_tbl, thread);
+    thread_id = get_thread_id(thread);
     
-    /* Get the frame at the top of the stack.  This may represent
-       the current method (EVENT_LINE, EVENT_RETURN)  or the
-       previous method (EVENT_CALL).*/
-    frame = stack_peek(thread_data->stack);
-    
-    /* Check for a context switch */
-    if (last_thread_data && last_thread_data != thread_data)
+    /* Was there a context switch? */
+    if (!last_thread_data || last_thread_data->thread_id != thread_id)
     {
-      /* Note how long have we been waiting. */
-      prof_measure_t wait_time = now - thread_data->last_switch;
+      prof_measure_t wait_time = 0;
+      
+      /* Get new thread information. */
+      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;
+
+      /* Get the frame at the top of the stack.  This may represent
+         the current method (EVENT_LINE, EVENT_RETURN)  or the
+         previous method (EVENT_CALL).*/
+      frame = stack_peek(thread_data->stack);
+    
       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.*/
-      last_thread_data->last_switch = now;
-      thread_data->last_switch = 0;
+      if (last_thread_data)
+        last_thread_data->last_switch = now;
+        
+      last_thread_data = thread_data;
+    }
+    else
+    {
+      thread_data = last_thread_data;
+      frame = stack_peek(thread_data->stack);
     }
-    last_thread_data = thread_data;
     
     switch (event) {
     case RUBY_EVENT_LINE:
@@ -1156,7 +1171,7 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         int depth = 0;
         st_data_t key = 0;
         prof_method_t *method = NULL;
-        
+
         /* Is this an include for a module?  If so get the actual
            module class since we want to combine all profiling
            results for that module. */
@@ -1170,7 +1185,17 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         
         if (!method)
         {
-          method = prof_method_create(node, key, klass, mid, depth);
+          const char* source_file = (node ? node->nd_file : 0);
+          int line = (node ? nd_line(node) : 0);
+          
+          /* Line numbers are not accurate for c method calls */
+            if (event == RUBY_EVENT_C_CALL)
+            {
+              line = 0;
+              source_file = NULL;
+            }
+            
+          method = prof_method_create(key, klass, mid, depth, source_file, line);
           method_info_table_insert(thread_data->method_info_table, key, method);
         }
         
@@ -1185,7 +1210,17 @@ prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
           
           if (!method)
           {
-            method = prof_method_create(node, key, klass, mid, depth);
+            const char* source_file = (node ? node->nd_file : 0);
+            int line = (node ? nd_line(node) : 0);
+            
+            /* Line numbers are not accurate for c method calls */
+            if (event == RUBY_EVENT_C_CALL)
+            {
+              line = 0;
+              source_file = NULL;
+            }
+              
+            method = prof_method_create(key, klass, mid, depth, source_file, line);
             method->base = base_method;
             method_info_table_insert(thread_data->method_info_table, key, method);
           }