ruby-prof 0.18.0 → 1.0.0

data/Rakefile

@@ -40,7 +40,7 @@ Rake::ExtensionTask.new do |ext|
   ext.ext_dir = "ext/#{SO_NAME}"
   ext.lib_dir = "lib/#{RUBY_VERSION}"
   ext.cross_compile = true
-  ext.cross_platform = ['x86-mswin32-60', 'x86-mingw32-60']
+  ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
 end
 
 # Rake task to build the default package
@@ -80,12 +80,9 @@ RDoc::Task.new("rdoc") do |rdoc|
   rdoc.options << '--main' << 'README.rdoc'
   rdoc.rdoc_files.include('bin/*',
                           'doc/*.rdoc',
-                          'examples/flat.txt',
-                          'examples/graph.txt',
-                          'examples/graph.html',
                           'lib/**/*.rb',
-                          'ext/ruby_prof/ruby_prof.c',
-                          'ext/ruby_prof/measure_*.h',
+                          'ext/ruby_prof/*.c',
+                          'ext/ruby_prof/*.h',
                           'README.rdoc',
                           'LICENSE')
 end

data/bin/ruby-prof

@@ -1,18 +1,5 @@
 #! /usr/bin/env ruby
 
-# == Synopsis
-#
-# Profiles a Ruby program.
-#
-# == Usage
-#
-# ruby_prof [options] <script.rb> [--] [script-options]"
-#
-# Various options:
-#        run "$ ruby-prof --help" to see them
-#
-# See also the readme "reports" section for the various outputs
-
 # First require ruby-prof
 require 'rubygems'
 require 'ruby-prof'
@@ -22,7 +9,68 @@ require 'ostruct'
 require 'optparse'
 
 module RubyProf
+  # == Synopsis
+  #
+  # Profiles a Ruby program.
+  #
+  # == Usage
+  #
+  # ruby_prof [options] <script.rb> [--] [script-options]
+  #
+  # Options:
+  #  -p, --printer=printer          Select a printer:
+  #                                   flat - Prints a flat profile as text (default).
+  #                                   graph - Prints a graph profile as text.
+  #                                   graph_html - Prints a graph profile as html.
+  #                                   call_tree - format for KCacheGrind
+  #                                   call_stack - prints a HTML visualization of the call tree
+  #                                   dot - Prints a graph profile as a dot file
+  #                                   multi - Creates several reports in output directory
+  #
+  #  -m, --min_percent=min_percent  The minimum percent a method must take before
+  #                                 being included in output reports. This option is not supported for call tree reports.
+  #
+  #  -f, --file=path                Output results to a file instead of standard out.
+  #
+  #  --mode=measure_mode            Select what ruby-prof should measure:
+  #                                   wall - Wall time (default)
+  #                                   process - Process time
+  #                                   allocations - Object allocations
+  #                                   memory - Allocated memory
+  #
+  #  -s, --sort=sort_mode           Select how ruby-prof results should be sorted:
+  #                                   total - Total time
+  #                                   self - Self time
+  #                                   wait - Wait time
+  #                                   child - Child time
+  #
+  #  --replace-progname             Replace $0 when loading the .rb files.
+  #
+  #  --specialized-instruction      Turn on specified instruction.
+  #
+  #  -v                             Show version, set $VERBOSE to true, profile script if option given
+  #
+  #  -d                             Set $DEBUG to true
+  #
+  #  -R, --require-noprof lib       Require a specific library (not profiled)
+  #
+  #  -E, --eval-noprof code         Execute the ruby statements (not profiled)
+  #
+  #  -x, --exclude regexp           Exclude methods by regexp (see method elimination)
+  #
+  #  -X, --exclude-file file        Exclude methods by regexp listed in file (see method elimination)
+  #
+  #  --exclude-common-cycles        Make common iterators like Integer#times appear inlined
+  #
+  #  --exclude-common-callbacks     Make common callbacks invocations like Integer#times appear inlined so you can see call origins in graph
+  #
+  #  -h, --help                     Show help message
+  #
+  #  --version                      Show version
+  #
+  #
   class Cmd
+    # :enddoc:
     attr_accessor :options
 
     def initialize
@@ -56,7 +104,6 @@ module RubyProf
         opts.on('-p printer', '--printer=printer', [:flat, :flat_with_line_numbers, :graph, :graph_html, :call_tree, :call_stack, :dot, :multi],
                 'Select a printer:',
                 '  flat - Prints a flat profile as text (default).',
-                '  flat_with_line_numbers - same as flat, with line numbers.',
                 '  graph - Prints a graph profile as text.',
                 '  graph_html - Prints a graph profile as html.',
                 '  call_tree - format for KCacheGrind',
@@ -65,12 +112,9 @@ module RubyProf
                 '  multi - Creates several reports in output directory'
         ) do |printer|
 
-
           case printer
           when :flat
             options.printer = RubyProf::FlatPrinter
-          when :flat_with_line_numbers
-            options.printer = RubyProf::FlatPrinterWithLineNumbers
           when :graph
             options.printer = RubyProf::GraphPrinter
           when :graph_html
@@ -89,7 +133,7 @@ module RubyProf
         opts.on('-m min_percent', '--min_percent=min_percent', Float,
                 'The minimum percent a method must take before ',
                 '  being included in output reports.',
-                '  this option is not supported for call tree.') do |min_percent|
+                '  This option is not supported for call tree.') do |min_percent|
           options.min_percent = min_percent
         end
 
@@ -100,31 +144,22 @@ module RubyProf
         end
 
         opts.on('--mode=measure_mode',
-                [:process, :wall, :cpu, :allocations, :memory, :gc_runs, :gc_time],
+                [:process, :wall, :allocations, :memory],
                 'Select what ruby-prof should measure:',
                 '  wall - Wall time (default).',
                 '  process - Process time.',
-                '  cpu - CPU time (Pentium and PowerPCs only).',
                 '  allocations - Object allocations (requires patched Ruby interpreter).',
-                '  memory - Allocated memory in KB (requires patched Ruby interpreter).',
-                '  gc_runs - Number of garbage collections (requires patched Ruby interpreter).',
-                '  gc_time - Time spent in garbage collection (requires patched Ruby interpreter).') do |measure_mode|
+                '  memory - Allocated memory in KB (requires patched Ruby interpreter).') do |measure_mode|
 
           case measure_mode
           when :wall
             options.measure_mode = RubyProf::WALL_TIME
           when :process
             options.measure_mode = RubyProf::PROCESS_TIME
-          when :cpu
-            options.measure_mode = RubyProf::CPU_TIME
           when :allocations
             options.measure_mode = RubyProf::ALLOCATIONS
           when :memory
             options.measure_mode = RubyProf::MEMORY
-          when :gc_runs
-            options.measure_mode = RubyProf::GC_RUNS
-          when :gc_time
-            options.measure_mode = RubyProf::GC_TIME
           end
         end
 
@@ -184,7 +219,7 @@ module RubyProf
           options.pre_execs << code
         end
 
-        opts.on('-x regexp', '--exclude regexp', 'exclude methods by regexp (see method elimination)') do|meth|
+        opts.on('-x regexp', '--exclude regexp', 'exclude methods by regexp (see method elimination)') do |meth|
           options.eliminate_methods ||= []
           options.eliminate_methods << Regexp.new(meth)
         end

data/ext/ruby_prof/extconf.rb

@@ -5,34 +5,16 @@ if RUBY_ENGINE != "ruby"
   exit(1)
 end
 
-if RUBY_VERSION < "1.9.3"
-  STDERR.puts("\n\n***** Ruby version #{RUBY_VERSION} is no longer supported. Please upgrade to 1.9.3 or higher. *****\n\n")
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.4.0')
+  STDERR.puts("\n\n***** Ruby version #{RUBY_VERSION} is no longer supported. Please upgrade to 2.3 or higher. *****\n\n")
   exit(1)
 end
 
 # For the love of bitfields...
 $CFLAGS += ' -std=c99'
 
-# standard ruby methods
-have_func("rb_gc_stat")
-have_func("rb_gc_count")
-have_func("rb_remove_event_hook_with_data")
-
-# Alexander Dymo GC patch
-have_func("rb_os_allocated_objects")
-have_func("rb_gc_allocated_size")
-
-# Stefan Kaes GC patches
-have_func("rb_gc_collections")
-have_func("rb_gc_time")
-# for ruby 2.1
-have_func("rb_gc_total_time")
-have_func("rb_gc_total_mallocs")
-have_func("rb_gc_total_malloced_bytes")
-
-# Lloyd Hilaiel's heap info patch
-have_func("rb_heap_total_mem")
-have_func("rb_gc_heap_info")
+# And since we are using C99
+CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
 
 def add_define(name, value = nil)
   if value
@@ -46,23 +28,9 @@ def windows?
   RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
 end
 
-if !windows? && RUBY_PLATFORM !~ /(darwin|openbsd)/
-  $LDFLAGS += " -lrt" # for clock_gettime
-end
 add_define("RUBY_PROF_RUBY_VERSION", RUBY_VERSION.split('.')[0..2].inject(0){|v,d| v*100+d.to_i})
 
-# for ruby 1.9, determine whether threads inherit trace flags (latest 1.9.2 and later should work correctly)
-if RUBY_VERSION > "1.9"
-  require 'set'
-  threads = Set.new
-  set_trace_func lambda { |*args| threads << Thread.current.object_id }
-  Thread.new{1}.join
-  set_trace_func nil
-  if threads.size < 2
-    # if we end up here, ruby does not automatically activate tracing in spawned threads
-    STDERR.puts("Ruby #{RUBY_VERSION} does not activate tracing in spawned threads. Consider upgrading.")
-    exit(1)
-  end
-end
+# This function was added in Ruby 2.5, so once Ruby 2.4 is no longer supported this can be removed
+have_func('rb_tracearg_callee_id', ["ruby.h"])
 
 create_makefile("ruby_prof")

data/ext/ruby_prof/rp_allocation.c

@@ -0,0 +1,292 @@
+/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "rp_allocation.h"
+
+VALUE cRpAllocation;
+
+prof_allocation_t*
+allocations_table_lookup(st_table *table, st_data_t key)
+{
+    prof_allocation_t* result = NULL;
+    st_data_t value;
+    if (st_lookup(table, key, &value))
+    {
+        result = (prof_allocation_t*)value;
+    }
+
+    return result;
+}
+
+void
+allocations_table_insert(st_table *table, st_data_t key, prof_allocation_t * allocation)
+{
+    st_insert(table, (st_data_t)key, (st_data_t)allocation);
+}
+
+st_data_t
+allocations_key(VALUE klass, int source_line)
+{
+    return (klass << 4) + source_line;
+}
+
+/* ======   prof_allocation_t  ====== */
+prof_allocation_t*
+prof_allocation_create(void)
+{
+    prof_allocation_t *result = ALLOC(prof_allocation_t);
+    result->count = 0;
+    result->klass = Qnil;
+    result->klass_name = Qnil;
+    result->object = Qnil;
+    result->memory = 0;
+    result->source_line = 0;
+    result->source_file = Qnil;
+    result->key = 0;
+
+    return result;
+}
+
+prof_allocation_t*
+prof_allocate_increment(prof_method_t* method, rb_trace_arg_t* trace_arg)
+{
+    VALUE object = rb_tracearg_object(trace_arg);
+    if (BUILTIN_TYPE(object) == T_IMEMO)
+        return NULL;
+
+    VALUE klass = rb_obj_class(object);
+
+    int source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
+    st_data_t key = allocations_key(klass, source_line);
+
+    prof_allocation_t* allocation = allocations_table_lookup(method->allocations_table, key);
+    if (!allocation)
+    {
+        allocation = prof_allocation_create();
+        allocation->source_line = source_line;
+        allocation->source_file = rb_tracearg_path(trace_arg);
+        allocation->klass_flags = 0;
+        allocation->klass = resolve_klass(klass, &allocation->klass_flags);
+
+        allocation->key = key;
+        allocations_table_insert(method->allocations_table, key, allocation);
+    }
+
+    allocation->count++;
+    allocation->memory += rb_obj_memsize_of(object);
+
+    return allocation;
+}
+
+static void
+prof_allocation_ruby_gc_free(void *data)
+{
+    prof_allocation_t* allocation = (prof_allocation_t*)data;
+
+    /* Has this thread object been accessed by Ruby?  If
+       yes clean it up so to avoid a segmentation fault. */
+    if (allocation->object != Qnil)
+    {
+        RDATA(allocation->object)->data = NULL;
+        RDATA(allocation->object)->dfree = NULL;
+        RDATA(allocation->object)->dmark = NULL;
+    }
+    allocation->object = Qnil;
+}
+
+void
+prof_allocation_free(prof_allocation_t* allocation)
+{
+    prof_allocation_ruby_gc_free(allocation);
+    xfree(allocation);
+}
+
+size_t
+prof_allocation_size(const void* data)
+{
+    return sizeof(prof_allocation_t);
+}
+
+void
+prof_allocation_mark(void *data)
+{
+    prof_allocation_t* allocation = (prof_allocation_t*)data;
+    if (allocation->klass != Qnil)
+        rb_gc_mark(allocation->klass);
+    
+    if (allocation->klass_name != Qnil)
+        rb_gc_mark(allocation->klass_name);
+
+    if (allocation->object != Qnil)
+            rb_gc_mark(allocation->object);
+
+    if (allocation->source_file != Qnil)
+        rb_gc_mark(allocation->source_file);
+}
+
+static const rb_data_type_t allocation_type =
+{
+    .wrap_struct_name = "Allocation",
+    .function =
+    {
+        .dmark = prof_allocation_mark,
+        .dfree = prof_allocation_ruby_gc_free,
+        .dsize = prof_allocation_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE
+prof_allocation_wrap(prof_allocation_t *allocation)
+{
+    if (allocation->object == Qnil)
+    {
+        allocation->object = TypedData_Wrap_Struct(cRpAllocation, &allocation_type, allocation);
+    }
+    return allocation->object;
+}
+
+static VALUE
+prof_allocation_allocate(VALUE klass)
+{
+    prof_allocation_t* allocation = prof_allocation_create();
+    allocation->object = prof_allocation_wrap(allocation);
+    return allocation->object;
+}
+
+prof_allocation_t*
+prof_allocation_get(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+    prof_allocation_t* result = DATA_PTR(self);
+    if (!result)
+        rb_raise(rb_eRuntimeError, "This RubyProf::Allocation instance has already been freed, likely because its profile has been freed.");
+
+    return result;
+}
+
+/* call-seq:
+   klass -> Class
+
+Returns the type of Class being allocated. */
+static VALUE
+prof_allocation_klass_name(VALUE self)
+{
+    prof_allocation_t* allocation = prof_allocation_get(self);
+
+    if (allocation->klass_name == Qnil)
+        allocation->klass_name = resolve_klass_name(allocation->klass, &allocation->klass_flags);
+
+    return allocation->klass_name;
+}
+
+/* call-seq:
+   klass_flags -> integer
+
+Returns the klass flags */
+
+static VALUE
+prof_allocation_klass_flags(VALUE self)
+{
+    prof_allocation_t* allocation = prof_allocation_get(self);
+    return INT2FIX(allocation->klass_flags);
+}
+
+/* call-seq:
+   source_file -> string
+
+Returns the the line number where objects were allocated. */
+static VALUE
+prof_allocation_source_file(VALUE self)
+{
+    prof_allocation_t* allocation = prof_allocation_get(self);
+    return allocation->source_file;
+}
+
+/* call-seq:
+   line -> number
+
+Returns the the line number where objects were allocated. */
+static VALUE
+prof_allocation_source_line(VALUE self)
+{
+    prof_allocation_t* allocation = prof_allocation_get(self);
+    return INT2FIX(allocation->source_line);
+}
+
+/* call-seq:
+   count -> number
+
+Returns the number of times this class has been allocated. */
+static VALUE
+prof_allocation_count(VALUE self)
+{
+    prof_allocation_t* allocation = prof_allocation_get(self);
+    return INT2FIX(allocation->count);
+}
+
+/* call-seq:
+   memory -> number
+
+Returns the amount of memory allocated. */
+static VALUE
+prof_allocation_memory(VALUE self)
+{
+    prof_allocation_t* allocation = prof_allocation_get(self);
+    return ULL2NUM(allocation->memory);
+}
+
+/* :nodoc: */
+static VALUE
+prof_allocation_dump(VALUE self)
+{
+    prof_allocation_t* allocation = DATA_PTR(self);
+
+    VALUE result = rb_hash_new();
+
+    rb_hash_aset(result, ID2SYM(rb_intern("key")), INT2FIX(allocation->key));
+    rb_hash_aset(result, ID2SYM(rb_intern("klass_name")), prof_allocation_klass_name(self));
+    rb_hash_aset(result, ID2SYM(rb_intern("klass_flags")), INT2FIX(allocation->klass_flags));
+    rb_hash_aset(result, ID2SYM(rb_intern("source_file")), allocation->source_file);
+    rb_hash_aset(result, ID2SYM(rb_intern("source_line")), INT2FIX(allocation->source_line));
+    rb_hash_aset(result, ID2SYM(rb_intern("count")), INT2FIX(allocation->count));
+    rb_hash_aset(result, ID2SYM(rb_intern("memory")), LONG2FIX(allocation->memory));
+
+    return result;
+}
+
+/* :nodoc: */
+static VALUE
+prof_allocation_load(VALUE self, VALUE data)
+{
+    prof_allocation_t* allocation = DATA_PTR(self);
+    allocation->object = self;
+
+    allocation->key = FIX2LONG(rb_hash_aref(data, ID2SYM(rb_intern("key"))));
+    allocation->klass_name = rb_hash_aref(data, ID2SYM(rb_intern("klass_name")));
+    allocation->klass_flags = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("klass_flags"))));
+    allocation->source_file = rb_hash_aref(data, ID2SYM(rb_intern("source_file")));
+    allocation->source_line = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("source_line"))));
+    allocation->count = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("count"))));
+    allocation->memory = FIX2LONG(rb_hash_aref(data, ID2SYM(rb_intern("memory"))));
+
+    return data;
+}
+
+void rp_init_allocation(void)
+{
+    cRpAllocation = rb_define_class_under(mProf, "Allocation", rb_cData);
+    rb_undef_method(CLASS_OF(cRpAllocation), "new");
+    rb_define_alloc_func(cRpAllocation, prof_allocation_allocate);
+
+    rb_define_method(cRpAllocation, "klass_name", prof_allocation_klass_name, 0);
+    rb_define_method(cRpAllocation, "klass_flags", prof_allocation_klass_flags, 0);
+    rb_define_method(cRpAllocation, "source_file", prof_allocation_source_file, 0);
+    rb_define_method(cRpAllocation, "line", prof_allocation_source_line, 0);
+    rb_define_method(cRpAllocation, "count", prof_allocation_count, 0);
+    rb_define_method(cRpAllocation, "memory", prof_allocation_memory, 0);
+    rb_define_method(cRpAllocation, "_dump_data", prof_allocation_dump, 0);
+    rb_define_method(cRpAllocation, "_load_data", prof_allocation_load, 1);
+}