ruby-prof 1.0.0

data/bin/ruby-prof-check-trace

@@ -0,0 +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

data/ext/ruby_prof/extconf.rb

@@ -0,0 +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 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,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);
+}

data/ext/ruby_prof/rp_allocation.h

@@ -0,0 +1,31 @@
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef _RP_ALLOCATION_
+#define _RP_ALLOCATION_
+
+#include "ruby_prof.h"
+#include "rp_method.h"
+
+typedef struct
+{
+    st_data_t key;                    /* Key in hash table */
+    unsigned int klass_flags;         /* Information about the type of class */
+    VALUE klass;                      /* Klass that was created */
+    VALUE klass_name;                 /* Name of the class that was created */
+    VALUE source_file;                /* Line number where allocation happens */
+    int source_line;                  /* Line number where allocation happens */
+    int count;                        /* Number of allocations */
+    size_t memory;                    /* Amount of allocated memory */
+    VALUE object;                     /* Cache to wrapped object */
+} prof_allocation_t;
+
+void rp_init_allocation(void);
+void prof_allocation_free(prof_allocation_t* allocation);
+void prof_allocation_mark(void *data);
+VALUE prof_allocation_wrap(prof_allocation_t* allocation);
+prof_allocation_t* prof_allocation_get(VALUE self);
+prof_allocation_t* prof_allocate_increment(prof_method_t *method, rb_trace_arg_t *trace_arg);
+
+
+#endif //_RP_ALLOCATION_

data/ext/ruby_prof/rp_call_info.c

@@ -0,0 +1,283 @@
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "rp_call_info.h"
+
+#define INITIAL_CALL_INFOS_SIZE 2
+
+VALUE cRpCallnfo;
+
+/* =======  prof_call_info_t   ========*/
+prof_call_info_t *
+prof_call_info_create(prof_method_t *method, prof_method_t *parent, VALUE source_file, int source_line)
+{
+    prof_call_info_t *result = ALLOC(prof_call_info_t);
+    result->method = method;
+    result->parent = parent;
+    result->object = Qnil;
+    result->measurement = prof_measurement_create();
+
+    result->visits = 0;
+
+    result->depth = 0;
+    result->source_line = source_line;
+    result->source_file = source_file;
+
+    return result;
+}
+
+static void
+prof_call_info_ruby_gc_free(void *data)
+{
+    prof_call_info_t *call_info = (prof_call_info_t*)data;
+
+    /* Has this thread object been accessed by Ruby?  If
+	   yes clean it up so to avoid a segmentation fault. */
+	if (call_info->object != Qnil)
+	{
+		RDATA(call_info->object)->data = NULL;
+		RDATA(call_info->object)->dfree = NULL;
+		RDATA(call_info->object)->dmark = NULL;
+    }
+	call_info->object = Qnil;
+}
+
+void
+prof_call_info_free(prof_call_info_t *call_info)
+{
+    prof_call_info_ruby_gc_free(call_info);
+    xfree(call_info);
+}
+
+size_t
+prof_call_info_size(const void *data)
+{
+    return sizeof(prof_call_info_t);
+}
+
+void
+prof_call_info_mark(void *data)
+{
+    prof_call_info_t *call_info = (prof_call_info_t*)data;
+
+    if (call_info->source_file != Qnil)
+        rb_gc_mark(call_info->source_file);
+
+    if (call_info->object != Qnil)
+		rb_gc_mark(call_info->object);
+
+    if (call_info->method && call_info->method->object != Qnil)
+        rb_gc_mark(call_info->method->object);
+
+    if (call_info->parent && call_info->parent->object != Qnil)
+        rb_gc_mark(call_info->parent->object);
+
+    prof_measurement_mark(call_info->measurement);
+}
+
+static const rb_data_type_t call_info_type =
+{
+    .wrap_struct_name = "CallInfo",
+    .function =
+    {
+        .dmark = prof_call_info_mark,
+        .dfree = prof_call_info_ruby_gc_free,
+        .dsize = prof_call_info_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE
+prof_call_info_wrap(prof_call_info_t *call_info)
+{
+    if (call_info->object == Qnil)
+    {
+        call_info->object =  TypedData_Wrap_Struct(cRpCallnfo, &call_info_type, call_info);
+    }
+    return call_info->object;
+}
+
+static VALUE
+prof_call_info_allocate(VALUE klass)
+{
+    prof_call_info_t* call_info = prof_call_info_create(NULL, NULL, Qnil, 0);
+    call_info->object = prof_call_info_wrap(call_info);
+    return call_info->object;
+}
+
+prof_call_info_t *
+prof_get_call_info(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+	prof_call_info_t* result = DATA_PTR(self);
+
+	if (!result)
+	    rb_raise(rb_eRuntimeError, "This RubyProf::CallInfo instance has already been freed, likely because its profile has been freed.");
+
+   return result;
+}
+
+/* =======  Call Info Table   ========*/
+st_table *
+call_info_table_create()
+{
+    return st_init_numtable();
+}
+
+size_t
+call_info_table_insert(st_table *table, st_data_t key, prof_call_info_t *val)
+{
+  return st_insert(table, (st_data_t) key, (st_data_t) val);
+}
+
+prof_call_info_t *
+call_info_table_lookup(st_table *table, st_data_t key)
+{
+    st_data_t val;
+    if (st_lookup(table, (st_data_t) key, &val))
+    {
+      return (prof_call_info_t *) val;
+    }
+    else
+    {
+      return NULL;
+    }
+}
+
+/* =======  RubyProf::CallInfo   ========*/
+
+/* call-seq:
+   parent -> call_info
+
+Returns the call_infos parent call_info object (the method that called this method).*/
+static VALUE
+prof_call_info_parent(VALUE self)
+{
+    prof_call_info_t* call_info = prof_get_call_info(self);
+    if (call_info->parent)
+        return prof_method_wrap(call_info->parent);
+    else
+        return Qnil;
+}
+
+/* call-seq:
+   called -> MethodInfo
+
+Returns the target method. */
+static VALUE
+prof_call_info_target(VALUE self)
+{
+    prof_call_info_t *call_info = prof_get_call_info(self);
+    return prof_method_wrap(call_info->method);
+}
+
+/* call-seq:
+   called -> Measurement
+
+Returns the measurement associated with this call_info. */
+static VALUE
+prof_call_info_measurement(VALUE self)
+{
+    prof_call_info_t* call_info = prof_get_call_info(self);
+    return prof_measurement_wrap(call_info->measurement);
+}
+
+/* call-seq:
+   depth -> int
+
+   returns the depth of this call info in the call graph */
+static VALUE
+prof_call_info_depth(VALUE self)
+{
+  prof_call_info_t *result = prof_get_call_info(self);
+  return rb_int_new(result->depth);
+}
+
+/* call-seq:
+   source_file => string
+
+return the source file of the method
+*/
+static VALUE
+prof_call_info_source_file(VALUE self)
+{
+    prof_call_info_t* result = prof_get_call_info(self);
+    return result->source_file;
+}
+
+/* call-seq:
+   line_no -> int
+
+   returns the line number of the method */
+static VALUE
+prof_call_info_line(VALUE self)
+{
+  prof_call_info_t *result = prof_get_call_info(self);
+  return INT2FIX(result->source_line);
+}
+
+/* :nodoc: */
+static VALUE
+prof_call_info_dump(VALUE self)
+{
+    prof_call_info_t* call_info_data = prof_get_call_info(self);
+    VALUE result = rb_hash_new();
+
+    rb_hash_aset(result, ID2SYM(rb_intern("measurement")), prof_measurement_wrap(call_info_data->measurement));
+
+    rb_hash_aset(result, ID2SYM(rb_intern("depth")), INT2FIX(call_info_data->depth));
+    rb_hash_aset(result, ID2SYM(rb_intern("source_file")), call_info_data->source_file);
+    rb_hash_aset(result, ID2SYM(rb_intern("source_line")), INT2FIX(call_info_data->source_line));
+
+    rb_hash_aset(result, ID2SYM(rb_intern("parent")), prof_call_info_parent(self));
+    rb_hash_aset(result, ID2SYM(rb_intern("target")), prof_call_info_target(self));
+
+    return result;
+}
+
+/* :nodoc: */
+static VALUE
+prof_call_info_load(VALUE self, VALUE data)
+{
+	VALUE target = Qnil;
+	VALUE parent = Qnil;
+	prof_call_info_t* call_info = prof_get_call_info(self);
+    call_info->object = self;
+
+    VALUE measurement = rb_hash_aref(data, ID2SYM(rb_intern("measurement")));
+    call_info->measurement = prof_get_measurement(measurement);
+
+    call_info->depth = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("depth"))));
+    call_info->source_file = rb_hash_aref(data, ID2SYM(rb_intern("source_file")));
+    call_info->source_line = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("source_line"))));
+
+    parent = rb_hash_aref(data, ID2SYM(rb_intern("parent")));
+    if (parent != Qnil)
+        call_info->parent = prof_method_get(parent);
+
+    target = rb_hash_aref(data, ID2SYM(rb_intern("target")));
+    call_info->method = prof_method_get(target);
+
+    return data;
+}
+
+void rp_init_call_info()
+{
+    /* CallInfo */
+    cRpCallnfo = rb_define_class_under(mProf, "CallInfo", rb_cData);
+    rb_undef_method(CLASS_OF(cRpCallnfo), "new");
+    rb_define_alloc_func(cRpCallnfo, prof_call_info_allocate);
+
+    rb_define_method(cRpCallnfo, "parent", prof_call_info_parent, 0);
+    rb_define_method(cRpCallnfo, "target", prof_call_info_target, 0);
+    rb_define_method(cRpCallnfo, "measurement", prof_call_info_measurement, 0);
+
+    rb_define_method(cRpCallnfo, "depth", prof_call_info_depth, 0);
+    rb_define_method(cRpCallnfo, "source_file", prof_call_info_source_file, 0);
+    rb_define_method(cRpCallnfo, "line", prof_call_info_line, 0);
+
+    rb_define_method(cRpCallnfo, "_dump_data", prof_call_info_dump, 0);
+    rb_define_method(cRpCallnfo, "_load_data", prof_call_info_load, 1);
+}