ruby-prof 0.11.2 → 0.11.3

data/README.rdoc

@@ -15,7 +15,7 @@ ruby-prof is a fast code profiler for Ruby.  Its features include:
 
 == Requirements
 
-ruby-prof requires Ruby 1.8.7 or 1.9.1 and higher.
+ruby-prof requires Ruby 1.8.7 or 1.9.2 and higher.
 
 If you are running Linux or Unix you'll need a C compiler so the extension
 can be compiled when it is installed.

data/Rakefile

@@ -5,6 +5,7 @@ require "rake/extensiontask"
 require "rake/testtask"
 require "rdoc/task"
 require "date"
+require 'rake/clean'
 
 # To release a version of ruby-prof:
 #   * Update version.h
@@ -78,6 +79,10 @@ end
 
 task :default => :package
 
+for file in Dir['**/*.so']
+  CLEAN.include file
+end
+
 desc 'Run the ruby-prof test suite'
 Rake::TestTask.new do |t|
   t.libs += %w(lib ext test)

data/bin/ruby-prof

@@ -17,13 +17,13 @@ require 'ostruct'
 require 'optparse'
 require File.expand_path('../../lib/ruby-prof', __FILE__)
 
-options = OpenStruct.new
-options.measure_mode = RubyProf::PROCESS_TIME
-options.printer = RubyProf::FlatPrinter
-options.min_percent = 0
-options.file = nil
-options.replace_prog_name = false
-options.specialized_instruction = false
+rubyprof_options = OpenStruct.new
+rubyprof_options.measure_mode = RubyProf::PROCESS_TIME
+rubyprof_options.printer = RubyProf::FlatPrinter
+rubyprof_options.min_percent = 0
+rubyprof_options.file = nil
+rubyprof_options.replace_prog_name = false
+rubyprof_options.specialized_instruction = false
 
 opts = OptionParser.new do |opts|
   opts.banner = "ruby_prof #{RubyProf::VERSION}\n" +
@@ -47,19 +47,19 @@ opts = OptionParser.new do |opts|
           
     case printer
       when :flat
-        options.printer = RubyProf::FlatPrinter
+        rubyprof_options.printer = RubyProf::FlatPrinter
       when :flat_with_line_numbers
-        options.printer = RubyProf::FlatPrinterWithLineNumbers
+        rubyprof_options.printer = RubyProf::FlatPrinterWithLineNumbers
       when :graph
-        options.printer = RubyProf::GraphPrinter
+        rubyprof_options.printer = RubyProf::GraphPrinter
       when :graph_html
-        options.printer = RubyProf::GraphHtmlPrinter
+        rubyprof_options.printer = RubyProf::GraphHtmlPrinter
       when :call_tree
-        options.printer = RubyProf::CallTreePrinter
+        rubyprof_options.printer = RubyProf::CallTreePrinter
       when :call_stack
-        options.printer = RubyProf::CallStackPrinter
+        rubyprof_options.printer = RubyProf::CallStackPrinter
       when :dot
-        options.printer = RubyProf::DotPrinter
+        rubyprof_options.printer = RubyProf::DotPrinter
     end
   end
     
@@ -67,13 +67,13 @@ opts = OptionParser.new do |opts|
           'The minimum percent a method must take before ',
           '  being included in output reports.',
                                         '  this option is not supported for call tree.') do |min_percent|
-    options.min_percent = min_percent
+    rubyprof_options.min_percent = min_percent
   end
 
   opts.on('-f path', '--file=path',
         'Output results to a file instead of standard out.') do |file|
-    options.file = file
-    options.old_wd = Dir.pwd
+    rubyprof_options.file = file
+    rubyprof_options.old_wd = Dir.pwd
   end
     
   opts.on('--mode=measure_mode',
@@ -89,19 +89,19 @@ opts = OptionParser.new do |opts|
       
       case measure_mode
       when :process
-        options.measure_mode = RubyProf::PROCESS_TIME     
+        rubyprof_options.measure_mode = RubyProf::PROCESS_TIME     
       when :wall
-        options.measure_mode = RubyProf::WALL_TIME      
+        rubyprof_options.measure_mode = RubyProf::WALL_TIME      
       when :cpu
-        options.measure_mode = RubyProf::CPU_TIME
+        rubyprof_options.measure_mode = RubyProf::CPU_TIME
       when :allocations
-        options.measure_mode = RubyProf::ALLOCATIONS
+        rubyprof_options.measure_mode = RubyProf::ALLOCATIONS
       when :memory
-        options.measure_mode = RubyProf::MEMORY
+        rubyprof_options.measure_mode = RubyProf::MEMORY
       when :gc_runs
-        options.measure_mode = RubyProf::GC_RUNS
+        rubyprof_options.measure_mode = RubyProf::GC_RUNS
       when :gc_time
-        options.measure_mode = RubyProf::GC_TIME
+        rubyprof_options.measure_mode = RubyProf::GC_TIME
       end
   end
 
@@ -112,7 +112,7 @@ opts = OptionParser.new do |opts|
       '  wait - Wait time',
       '  child - Child time') do |sort_mode|
 
-      options.sort_method = case sort_mode
+      rubyprof_options.sort_method = case sort_mode
         when :total
           :total_time
         when :self
@@ -125,12 +125,12 @@ opts = OptionParser.new do |opts|
   end
 
   opts.on("--replace-progname", "Replace $0 when loading the .rb files.") do
-          options.replace_prog_name = true
+          rubyprof_options.replace_prog_name = true
   end
 
   if defined?(VM)
     opts.on("--specialized-instruction", "Turn on specified instruction.") do
-            options.specialized_instruction = true
+            rubyprof_options.specialized_instruction = true
     end
   end
     
@@ -154,38 +154,38 @@ opts = OptionParser.new do |opts|
   end
 
   opts.on('-R lib', '--require-noprof lib', 'require a specific library (not profiled)') do |lib|
-      options.pre_libs ||= []
-      options.pre_libs << lib
+      rubyprof_options.pre_libs ||= []
+      rubyprof_options.pre_libs << lib
   end
 
   opts.on('-E code', '--eval-noprof code', 'execute the ruby statements (not profiled)') do |code|
-      options.pre_exec ||= []
-      options.pre_exec << code
+      rubyprof_options.pre_exec ||= []
+      rubyprof_options.pre_exec << code
   end
 
   opts.on('-r lib', '--require lib', 'require a specific library') do |lib|
-      options.libs ||= []
-      options.libs << lib
+      rubyprof_options.libs ||= []
+      rubyprof_options.libs << lib
   end
 
   opts.on('-e code', '--eval', 'execute the ruby statements') do |code|
-      options.exec ||= []
-      options.exec << code
+      rubyprof_options.exec ||= []
+      rubyprof_options.exec << code
   end
 
   opts.on('-x regexp', '--exclude regexp', 'exclude methods by regexp (see method elimination)') do|meth|
-    options.eliminate_methods ||= []
-    options.eliminate_methods << Regexp.new(meth)
+    rubyprof_options.eliminate_methods ||= []
+    rubyprof_options.eliminate_methods << Regexp.new(meth)
   end
 
   opts.on('-X file', '--exclude-file file', 'exclude methods by regexp listed in file (see method elimination)') do|file|
-    options.eliminate_methods_files ||= []
-    options.eliminate_methods_files << file
+    rubyprof_options.eliminate_methods_files ||= []
+    rubyprof_options.eliminate_methods_files << file
   end
 
   opts.on('--exclude-common-cycles', 'make common iterators like Integer#times appear inlined') do|meth|
-    options.eliminate_methods ||= []
-    options.eliminate_methods += %w{
+    rubyprof_options.eliminate_methods ||= []
+    rubyprof_options.eliminate_methods += %w{
       Integer#times
       Integer#upto
       Integer#downto
@@ -218,8 +218,8 @@ opts = OptionParser.new do |opts|
   end
 
   opts.on('--exclude-common-callbacks', 'make common callbacks invocations like Integer#times appear inlined so you can see call origins in graph') do|meth|
-    options.eliminate_methods ||= []
-    options.eliminate_methods += %w{
+    rubyprof_options.eliminate_methods ||= []
+    rubyprof_options.eliminate_methods += %w{
       Method#call
       Proc#call
       ActiveSupport::Callbacks::ClassMethods#__run_callback
@@ -238,7 +238,7 @@ rescue OptionParser::InvalidOption, OptionParser::InvalidArgument,
 end
 
 # Make sure the user specified at least one file
-if ARGV.length < 1 and not options.exec
+if ARGV.length < 1 and not rubyprof_options.exec
   puts opts
   puts ""
   puts "Must specify a script to run"
@@ -255,18 +255,18 @@ at_exit {
   result = RubyProf.stop
 
   # Eliminate unwanted methods from call graph
-  result.eliminate_methods! options.eliminate_methods if options.eliminate_methods
-  options.eliminate_methods_files.each{|f| result.eliminate_methods!(f)} if options.eliminate_methods_files
+  result.eliminate_methods! rubyprof_options.eliminate_methods if rubyprof_options.eliminate_methods
+  rubyprof_options.eliminate_methods_files.each{|f| result.eliminate_methods!(f)} if rubyprof_options.eliminate_methods_files
 
   # Create a printer
-  printer = options.printer.new(result)
-  printer_options = {:min_percent => options.min_percent, :sort_method => options.sort_method}
+  printer = rubyprof_options.printer.new(result)
+  printer_options = {:min_percent => rubyprof_options.min_percent, :sort_method => rubyprof_options.sort_method}
 
   # Get output
-  if options.file
+  if rubyprof_options.file
     # write it relative to the dir they *started* in, as it's a bit surprising to write it in the dir they end up in.
-    Dir.chdir(options.old_wd) do
-      File.open(options.file, 'w') do |file|
+    Dir.chdir(rubyprof_options.old_wd) do
+      File.open(rubyprof_options.file, 'w') do |file|
         printer.print(file, printer_options)
       end
     end
@@ -277,33 +277,33 @@ at_exit {
 }
 
 # Now set measure mode
-RubyProf.measure_mode = options.measure_mode
+RubyProf.measure_mode = rubyprof_options.measure_mode
 
 # Set VM compile option
 if defined?(VM)
   VM::InstructionSequence.compile_option = {
     :trace_instruction => true,
-    :specialized_instruction => options.specialized_instruction
+    :specialized_instruction => rubyprof_options.specialized_instruction
   }
 end
 
 # Get the script we will execute
 script = ARGV.shift
-if options.replace_prog_name
+if rubyprof_options.replace_prog_name
   $0 = File.expand_path(script)
 end
 
-if options.pre_libs
-  options.pre_libs.each { |l| require l }
+if rubyprof_options.pre_libs
+  rubyprof_options.pre_libs.each { |l| require l }
 end
 
-if options.pre_exec
-  options.pre_exec.each { |c| eval c }
+if rubyprof_options.pre_exec
+  rubyprof_options.pre_exec.each { |c| eval c }
 end
 
 # do not pollute profiling report with OpenStruct#libs
-ol = options.libs
-oe = options.exec
+ol = rubyprof_options.libs
+oe = rubyprof_options.exec
 
 # Start profiling
 RubyProf.start 

data/ext/ruby_prof/rp_stack.c

@@ -6,16 +6,16 @@
 #define INITIAL_STACK_SIZE 8
 
 void
-frame_pause(prof_frame_t *frame, double current_measurement)
+prof_frame_pause(prof_frame_t *frame, double current_measurement)
 {
-    if (frame && frame_is_unpaused(frame))
+    if (frame && prof_frame_is_unpaused(frame))
         frame->pause_time = current_measurement;
 }
 
 void
-frame_unpause(prof_frame_t *frame, double current_measurement)
+prof_frame_unpause(prof_frame_t *frame, double current_measurement)
 {
-    if (frame && frame_is_paused(frame)) {
+    if (frame && prof_frame_is_paused(frame)) {
         frame->dead_time += (current_measurement - frame->pause_time);
         frame->pause_time = -1;
     }
@@ -25,7 +25,7 @@ frame_unpause(prof_frame_t *frame, double current_measurement)
 /* Creates a stack of prof_frame_t to keep track
    of timings for active methods. */
 prof_stack_t *
-stack_create()
+prof_stack_create()
 {
     prof_stack_t *stack = ALLOC(prof_stack_t);
     stack->start = ALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
@@ -36,14 +36,14 @@ stack_create()
 }
 
 void
-stack_free(prof_stack_t *stack)
+prof_stack_free(prof_stack_t *stack)
 {
     xfree(stack->start);
     xfree(stack);
 }
 
 prof_frame_t *
-stack_push(prof_stack_t *stack)
+prof_stack_push(prof_stack_t *stack)
 {
   prof_frame_t* result = NULL;
 
@@ -74,7 +74,7 @@ stack_push(prof_stack_t *stack)
 }
 
 prof_frame_t *
-stack_pop(prof_stack_t *stack)
+prof_stack_pop(prof_stack_t *stack)
 {
     if (stack->ptr == stack->start)
       return NULL;
@@ -83,7 +83,7 @@ stack_pop(prof_stack_t *stack)
 }
 
 prof_frame_t *
-stack_peek(prof_stack_t *stack)
+prof_stack_peek(prof_stack_t *stack)
 {
     if (stack->ptr == stack->start)
       return NULL;

data/ext/ruby_prof/rp_stack.h

@@ -28,10 +28,10 @@ typedef struct
     unsigned int line;
 } prof_frame_t;
 
-#define frame_is_paused(f) (f->pause_time >= 0)
-#define frame_is_unpaused(f) (f->pause_time < 0)
-void frame_pause(prof_frame_t*, double current_measurement);
-void frame_unpause(prof_frame_t*, double current_measurement);
+#define prof_frame_is_paused(f) (f->pause_time >= 0)
+#define prof_frame_is_unpaused(f) (f->pause_time < 0)
+void prof_frame_pause(prof_frame_t*, double current_measurement);
+void prof_frame_unpause(prof_frame_t*, double current_measurement);
 
 
 /* Current stack of active methods.*/
@@ -42,10 +42,10 @@ typedef struct
     prof_frame_t *ptr;
 } prof_stack_t;
 
-prof_stack_t * stack_create();
-void stack_free(prof_stack_t *stack);
-prof_frame_t * stack_push(prof_stack_t *stack);
-prof_frame_t * stack_pop(prof_stack_t *stack);
-prof_frame_t * stack_peek(prof_stack_t *stack);
+prof_stack_t * prof_stack_create();
+void prof_stack_free(prof_stack_t *stack);
+prof_frame_t * prof_stack_push(prof_stack_t *stack);
+prof_frame_t * prof_stack_pop(prof_stack_t *stack);
+prof_frame_t * prof_stack_peek(prof_stack_t *stack);
 
 #endif //__RP_STACK__

data/ext/ruby_prof/rp_thread.c

@@ -10,7 +10,7 @@ thread_data_t*
 thread_data_create()
 {
     thread_data_t* result = ALLOC(thread_data_t);
-    result->stack = stack_create();
+    result->stack = prof_stack_create();
     result->method_table = method_table_create();
 	result->top = NULL;
 	result->object = Qnil;
@@ -44,7 +44,7 @@ thread_data_free(thread_data_t* thread_data)
 	thread_data_ruby_gc_free(thread_data);
     thread_data->top = NULL;
     method_table_free(thread_data->method_table);
-    stack_free(thread_data->stack);
+    prof_stack_free(thread_data->stack);
 
     thread_data->thread_id = Qnil;
 
@@ -157,7 +157,7 @@ switch_thread(void* prof, VALUE thread_id)
     thread_data_t *thread_data = threads_table_lookup(profile, thread_id);
 
     /* Get current frame for this thread */
-    prof_frame_t *frame = stack_peek(thread_data->stack);
+    prof_frame_t *frame = prof_stack_peek(thread_data->stack);
 
     /* Update the time this thread waited for another thread */
     if (frame)
@@ -170,7 +170,7 @@ switch_thread(void* prof, VALUE thread_id)
        and reset this thread's last context switch to 0.*/
     if (profile->last_thread_data)
     {
-       prof_frame_t *last_frame = stack_peek(profile->last_thread_data->stack);
+       prof_frame_t *last_frame = prof_stack_peek(profile->last_thread_data->stack);
        if (last_frame)
          last_frame->switch_time = measurement;
     }

data/ext/ruby_prof/ruby_prof.c

@@ -139,7 +139,7 @@ pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
   _Bool frame_paused;
 #endif
 
-  frame = stack_pop(thread_data->stack); // only time it's called
+  frame = prof_stack_pop(thread_data->stack); // only time it's called
 
   /* Frame can be null.  This can happen if RubProf.start is called from
      a method that exits.  And it can happen if an exception is raised
@@ -149,8 +149,8 @@ pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
       return NULL;
 
   /* Calculate the total time this method took */
-  frame_paused = frame_is_paused(frame);
-  frame_unpause(frame, measurement);
+  frame_paused = prof_frame_is_paused(frame);
+  prof_frame_unpause(frame, measurement);
   total_time = measurement - frame->start_time - frame->dead_time;
   self_time = total_time - frame->child_time - frame->wait_time;
 
@@ -161,7 +161,7 @@ pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
   call_info->self_time += self_time;
   call_info->wait_time += frame->wait_time;
 
-  parent_frame = stack_peek(thread_data->stack);
+  parent_frame = prof_stack_peek(thread_data->stack);
   if (parent_frame)
   {
       parent_frame->child_time += total_time;
@@ -169,7 +169,7 @@ pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
 
       // Repause parent if currently paused
       if (frame_paused)
-          frame_pause(parent_frame, measurement);
+          prof_frame_pause(parent_frame, measurement);
 
       call_info->line = parent_frame->line;
   }
@@ -298,7 +298,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
       thread_data = profile->last_thread_data;
 
     /* Get the current frame for the current thread. */
-    frame = stack_peek(thread_data->stack);
+    frame = prof_stack_peek(thread_data->stack);
 
     switch (event) {
     case RUBY_EVENT_LINE:
@@ -350,11 +350,11 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
           // Unpause the parent frame. If currently paused then:
           // 1) The child frame will begin paused.
           // 2) The parent will inherit the child's dead time.
-          frame_unpause(frame, measurement);
+          prof_frame_unpause(frame, measurement);
         }
 
         /* Push a new frame onto the stack for a new c-call or ruby call (into a method) */
-        frame = stack_push(thread_data->stack);
+        frame = prof_stack_push(thread_data->stack);
         frame->call_info = call_info;
 		frame->call_info->depth = frame->depth;
         frame->start_time = measurement;
@@ -522,8 +522,8 @@ static int pause_thread(st_data_t key, st_data_t value, st_data_t data)
     thread_data_t* thread_data = (thread_data_t *) value;
     prof_profile_t* profile = (prof_profile_t*) data;
 
-    prof_frame_t* frame = stack_peek(thread_data->stack);
-    frame_pause(frame, profile->measurement_at_pause_resume);
+    prof_frame_t* frame = prof_stack_peek(thread_data->stack);
+    prof_frame_pause(frame, profile->measurement_at_pause_resume);
 
     return ST_CONTINUE;
 }
@@ -533,8 +533,8 @@ static int unpause_thread(st_data_t key, st_data_t value, st_data_t data)
     thread_data_t* thread_data = (thread_data_t *) value;
     prof_profile_t* profile = (prof_profile_t*) data;
 
-    prof_frame_t* frame = stack_peek(thread_data->stack);
-    frame_unpause(frame, profile->measurement_at_pause_resume);
+    prof_frame_t* frame = prof_stack_peek(thread_data->stack);
+    prof_frame_unpause(frame, profile->measurement_at_pause_resume);
 
     return ST_CONTINUE;
 }

data/ext/ruby_prof/version.h

@@ -1,7 +1,7 @@
 /* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
    Please see the LICENSE file for copyright and distribution information */
 
-#define RUBY_PROF_VERSION  "0.11.2" // for easy parsing from rake files
+#define RUBY_PROF_VERSION  "0.11.3" // as a string, for easy parsing from rake files
 #define RUBY_PROF_VERSION_MAJ   0
 #define RUBY_PROF_VERSION_MIN   11
 #define RUBY_PROF_VERSION_MIC   2

data/lib/ruby-prof/compatibility.rb

@@ -73,14 +73,19 @@ module RubyProf
   end
 
   # call-seq:
-  # exclude_threads= -> void
+  # exclude_threads -> exclude_threads
   #
-  # Specifies what threads ruby-prof should exclude from profiling
+  # Returns threads ruby-prof should exclude from profiling
 
   def self.exclude_threads
     @exclude_threads ||= Array.new
   end
 
+  # call-seq:
+  # exclude_threads= -> void
+  #
+  # Specifies what threads ruby-prof should exclude from profiling
+
   def self.exclude_threads=(value)
     @exclude_threads = value
   end

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

@@ -96,7 +96,7 @@ module RubyProf
       thread.methods.each{|m| grouped[m.klass_name] ||= []; grouped[m.klass_name] << m}
       grouped.each do |cls, methods2|
         # Filter down to just seen methods
-        big_methods, small_methods  = methods2.partition{|m| @seen_methods.include? m}
+        big_methods = methods2.select{|m| @seen_methods.include? m}
         
         if !big_methods.empty?
           puts "subgraph cluster_#{cls.object_id} {"

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

@@ -40,7 +40,6 @@ module RubyProf
     def print(output = STDOUT, options = {})
       @output = output
       setup_options(options)
-      _erbout = @output
       @output << @erb.result(binding)
     end
 

data/lib/ruby-prof/profile.rb

@@ -49,7 +49,7 @@ module RubyProf
     # read regexps from file
     def read_regexps_from_file(file_name)
       matchers = []
-      File.open(matchers).each_line do |l|
+      File.open(file_name).each_line do |l|
         next if (l =~ /^(#.*|\s*)$/) # emtpy lines and lines starting with #
         matchers << Regexp.new(l.strip)
       end

data/lib/ruby-prof/rack.rb

@@ -13,11 +13,6 @@ module Rack
                                                   ::RubyProf::GraphHtmlPrinter => 'graph.html',
                                                   ::RubyProf::CallStackPrinter => 'call_stack.html'}
 
-      @printer_klasses = @options[:printers]  || {::RubyProf::FlatPrinter => 'flat.txt',
-                                                  ::RubyProf::GraphPrinter => 'graph.txt',
-                                                  ::RubyProf::GraphHtmlPrinter => 'graph.html',
-                                                  ::RubyProf::CallStackPrinter => 'call_stack.html'}
-
       @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.css$}, %r{\.js}, %r{\.png}, %r{\.jpeg}]
     end
 

data/test/measure_process_time_test.rb

@@ -5,7 +5,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 class MeasureProcessTimeTest < Test::Unit::TestCase
   def setup
-    # Need to use wall time for this test due to the sleep calls
+    # Need to fix this for linux (windows works since PROCESS_TIME is WALL_TIME anyway)
     RubyProf::measure_mode = RubyProf::PROCESS_TIME
   end
 
@@ -202,4 +202,4 @@ class MeasureProcessTimeTest < Test::Unit::TestCase
     assert_in_delta(0.0, methods[1].wait_time, 0.01)
     assert_in_delta(0.0, methods[1].self_time, 0.01)
   end
-end
+end

data/test/pause_test.rb

@@ -40,18 +40,18 @@ class PauseTest < Test::Unit::TestCase
     assert_equal('Kernel#sleep', methods[2].full_name)
 
     # Check times
-    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0.3, methods[0].total_time, 0.01)
     assert_in_delta(0, methods[0].wait_time, 0.01)
     assert_in_delta(0, methods[0].self_time, 0.01)
 
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0.3, methods[1].total_time, 0.01)
     assert_in_delta(0, methods[1].wait_time, 0.01)
     assert_in_delta(0, methods[1].self_time, 0.01)
 
-    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0.3, methods[2].total_time, 0.01)
     assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.1, methods[2].self_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.01)
 
   end
 
-end
+end

data/test/prime.rb

@@ -51,5 +51,5 @@ def run_primes(length=10, maxnum=1000)
   primes = find_primes(random_array)
 
   # Find the largest primes
-  largest = find_largest(primes)
+  find_largest(primes)
 end

data/test/printers_test.rb

@@ -259,6 +259,8 @@ class PrintersTest < Test::Unit::TestCase
   end
 
   def assert_sorted array
+    array = array.map{|n| n.to_f} # allow for > 10s times to sort right, since lexographically 4.0 > 10.0
     assert_equal array, array.sort.reverse, "Array #{array.inspect} is not sorted"
   end
+
 end

data/test/recursive_test.rb

@@ -214,7 +214,7 @@ class RecursiveTest < Test::Unit::TestCase
     assert_in_delta(5, method.total_time, 0.1)
     assert_in_delta(0, method.self_time, 0.1)
     assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.01)
+    assert_in_delta(5, method.children_time, 0.05)
 
     assert_equal(3, method.call_infos.length)
     call_info = method.call_infos[0]
@@ -256,4 +256,4 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(0, call_info.children.length)
     assert(!call_info.recursive)
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-prof
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.11.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-06 00:00:00.000000000 Z
+date: 2012-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -89,7 +89,6 @@ files:
 - ext/ruby_prof/version.h
 - ext/ruby_prof/vc/ruby_prof.sln
 - ext/ruby_prof/vc/ruby_prof.vcxproj
-- ext/ruby_prof/vc/ruby_prof_18.vcxproj
 - lib/ruby-prof.rb
 - lib/unprof.rb
 - lib/ruby-prof/aggregate_call_info.rb
@@ -116,7 +115,6 @@ files:
 - lib/ruby-prof/printers/multi_printer.rb
 - test/aggregate_test.rb
 - test/basic_test.rb
-- test/bug_test.rb
 - test/call_info_visitor_test.rb
 - test/duplicate_names_test.rb
 - test/dynamic_method_test.rb
@@ -124,7 +122,6 @@ files:
 - test/exceptions_test.rb
 - test/exclude_threads_test.rb
 - test/exec_test.rb
-- test/gc_test.rb
 - test/line_number_test.rb
 - test/measure_allocations_test.rb
 - test/measure_cpu_time_test.rb

data/ext/ruby_prof/vc/ruby_prof_18.vcxproj

@@ -1,108 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\rp_call_info.h" />
-    <ClInclude Include="..\rp_measure.h" />
-    <ClInclude Include="..\rp_method.h" />
-    <ClInclude Include="..\rp_stack.h" />
-    <ClInclude Include="..\rp_thread.h" />
-    <ClInclude Include="..\ruby_prof.h" />
-    <ClInclude Include="..\version.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\rp_call_info.c" />
-    <ClCompile Include="..\rp_measure.c" />
-    <ClCompile Include="..\rp_measure_allocations.c" />
-    <ClCompile Include="..\rp_measure_cpu_time.c" />
-    <ClCompile Include="..\rp_measure_gc_runs.c" />
-    <ClCompile Include="..\rp_measure_gc_time.c" />
-    <ClCompile Include="..\rp_measure_memory.c" />
-    <ClCompile Include="..\rp_measure_process_time.c" />
-    <ClCompile Include="..\rp_measure_wall_time.c" />
-    <ClCompile Include="..\rp_method.c" />
-    <ClCompile Include="..\rp_stack.c" />
-    <ClCompile Include="..\rp_thread.c" />
-    <ClCompile Include="..\ruby_prof.c" />
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{7789FC23-D053-4733-9ED1-D6CE099E1237}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>ruby_prof_18</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <OutDir>C:\MinGW\local\src\ruby-prof\lib\1.8</OutDir>
-    <TargetExt>.so</TargetExt>
-    <TargetName>ruby_prof</TargetName>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;RUBY_PROF_18_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>C:\MinGW\local\ruby187vc\lib\ruby\1.8\i386-mswin32_100</AdditionalIncludeDirectories>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>C:\MinGW\local\ruby187vc\lib</AdditionalLibraryDirectories>
-      <AdditionalDependencies>msvcr100-ruby18.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;RUBY_PROF_18_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

data/test/bug_test.rb

@@ -1,6 +0,0 @@
-50000.times do
-  begin
-    raise "error"
-  rescue
-  end
-end

data/test/gc_test.rb

@@ -1,35 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class GcTest < Test::Unit::TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def run_profile
-    RubyProf.profile do
-      RubyProf::C1.hello
-    end
-  end
-
-  def test_gc
-    result = run_profile
-
-    thread = result.threads.first
-    method = thread.methods.first
-    call_info = method.call_infos.first
-
-    result = nil
-
-    1000.times do
-      GC.start
-      Array.new(1000)
-    end
-
-    puts thread.methods
-    puts method.full_name
-  end
-end