ruby-prof 0.16.2 → 1.1.0

data/bin/ruby-prof-check-trace

@@ -1,45 +1,45 @@
-#!/usr/bin/env ruby
-
-stacks = Hash.new{|h,k| h[k] = Hash.new{|h,k| h[k] = []}}
-i = 0
-File.open(ARGV[0]).each_line do |l|
-  i += 1
-  unless l =~ /^(\d+):(\d+): *\d+ms *([^ ]+) *(.*): *(\d+) *(.+)$/
-    next if l =~/^ *$/
-    puts "line doesn't match: #{l}"
-    next
-  end
-  details = $1.to_i, $2.to_i, $3, $4, $5.to_i, $6
-  thread, fiber, event, file, line, method = *details
-  # puts method
-  stack = stacks[thread][fiber]
-  case event
-  when 'call', 'c-call'
-    stack << method
-  when 'return', 'c-return'
-    last_method = stack.pop
-    if last_method != method
-      puts "LINE #{i}: return event without call: #{method}"
-      puts "STACK: #{stack.inspect}"
-      if stack.find(method)
-        puts "fixing stack"
-        while (popped = stack.pop) && (popped != method)
-          puts "popped #{popped}"
-        end
-      else
-        raise "stack unfixable"
-      end
-      # stack << last_method
-    end
-  when 'line'
-    last_method = stack[-1]
-    if last_method != method
-      unless stack.find(method)
-        raise "LINE #{i}: line event without call: #{method}"
-      end
-    end
-  else
-    puts "unkown event"
-  end
-end
-puts stacks.inspect
+#!/usr/bin/env ruby
+
+stacks = Hash.new{|h,k| h[k] = Hash.new{|h,k| h[k] = []}}
+i = 0
+File.open(ARGV[0]).each_line do |l|
+  i += 1
+  unless l =~ /^(\d+):(\d+): *\d+ms *([^ ]+) *(.*): *(\d+) *(.+)$/
+    next if l =~/^ *$/
+    puts "line doesn't match: #{l}"
+    next
+  end
+  details = $1.to_i, $2.to_i, $3, $4, $5.to_i, $6
+  thread, fiber, event, file, line, method = *details
+  # puts method
+  stack = stacks[thread][fiber]
+  case event
+  when 'call', 'c-call'
+    stack << method
+  when 'return', 'c-return'
+    last_method = stack.pop
+    if last_method != method
+      puts "LINE #{i}: return event without call: #{method}"
+      puts "STACK: #{stack.inspect}"
+      if stack.find(method)
+        puts "fixing stack"
+        while (popped = stack.pop) && (popped != method)
+          puts "popped #{popped}"
+        end
+      else
+        raise "stack unfixable"
+      end
+      # stack << last_method
+    end
+  when 'line'
+    last_method = stack[-1]
+    if last_method != method
+      unless stack.find(method)
+        raise "LINE #{i}: line event without call: #{method}"
+      end
+    end
+  else
+    puts "unkown event"
+  end
+end
+puts stacks.inspect

data/ext/ruby_prof/extconf.rb

@@ -1,64 +1,36 @@
-require "mkmf"
-
-if RUBY_ENGINE != "ruby"
-  STDERR.puts("\n\n***** This gem is MRI-specific. It does not support #{RUBY_ENGINE}. *****\n\n")
-  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")
-  exit(1)
-end
-
-# standard ruby methods
-have_func("rb_gc_stat")
-have_func("rb_gc_count")
-
-# 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")
-
-def add_define(name, value = nil)
-  if value
-    $defs.push("-D#{name}=#{value}")
-  else
-    $defs.push("-D#{name}")
-  end
-end
-
-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
-
-create_makefile("ruby_prof")
+require "mkmf"
+
+if RUBY_ENGINE != "ruby"
+  STDERR.puts("\n\n***** This gem is MRI-specific. It does not support #{RUBY_ENGINE}. *****\n\n")
+  exit(1)
+end
+
+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'
+
+# And since we are using C99
+CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+
+def add_define(name, value = nil)
+  if value
+    $defs.push("-D#{name}=#{value}")
+  else
+    $defs.push("-D#{name}")
+  end
+end
+
+def windows?
+  RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+end
+
+add_define("RUBY_PROF_RUBY_VERSION", RUBY_VERSION.split('.')[0..2].inject(0){|v,d| v*100+d.to_i})
+
+# 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,279 @@
+/* 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 allocation object been accessed by Ruby?  If
+       yes clean it up so to avoid a segmentation fault. */
+    if (allocation->object != Qnil)
+    {
+        RDATA(allocation->object)->dmark = NULL;
+        RDATA(allocation->object)->dfree = NULL;
+        RDATA(allocation->object)->data = 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);
+}
+
+VALUE
+prof_allocation_wrap(prof_allocation_t *allocation)
+{
+    if (allocation->object == Qnil)
+    {
+        allocation->object = Data_Wrap_Struct(cRpAllocation, prof_allocation_mark , prof_allocation_ruby_gc_free, 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);
+}