airbnb-ruby-prof 0.0.1

data/ext/ruby_prof/extconf.rb

@@ -0,0 +1,67 @@
+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
+
+# For the love of bitfields...
+$CFLAGS += ' -std=c99'
+
+# 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")

data/ext/ruby_prof/rp_call_info.c

@@ -0,0 +1,374 @@
+/* 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 "ruby_prof.h"
+
+#define INITIAL_CALL_INFOS_SIZE 2
+
+VALUE cCallInfo;
+
+
+// Forward declarations
+st_table * call_info_table_create();
+
+
+static prof_call_info_t *
+prof_call_info_allocate(size_t len)
+{
+    prof_call_info_t *result =
+        (prof_call_info_t*) ruby_xmalloc(
+            sizeof(prof_call_info_t) + len * sizeof(prof_measure_value_t));
+    result->measures_len = len;
+    return result;
+}
+
+/* =======  prof_call_info_t   ========*/
+prof_call_info_t *
+prof_call_info_create(prof_method_t* method, prof_call_info_t* parent, size_t measurements_len)
+{
+    prof_call_info_t *result = prof_call_info_allocate(measurements_len);
+    result->object = Qnil;
+    result->target = method;
+    result->parent = parent;
+    result->call_infos = call_info_table_create();
+    result->children = Qnil;
+
+    result->called = 0;
+
+    result->recursive = 0;
+    result->depth = 0;
+    result->line = 0;
+
+    for(size_t i = 0; i < measurements_len; i++) {
+        result->measure_values[i].total = 0.0;
+        result->measure_values[i].self = 0.0;
+        result->measure_values[i].wait = 0.0;
+    }
+
+    return result;
+}
+static void
+prof_call_info_ruby_gc_free(prof_call_info_t *call_info)
+{
+	/* 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;
+}
+
+static void
+prof_call_info_free(prof_call_info_t *call_info)
+{
+	prof_call_info_ruby_gc_free(call_info);
+	st_free_table(call_info->call_infos);
+	xfree(call_info);
+}
+
+static void
+prof_call_info_mark(prof_call_info_t *call_info)
+{
+	if (call_info->object)
+		rb_gc_mark(call_info->object);
+
+	if (call_info->children)
+		rb_gc_mark(call_info->children);
+
+	/* We don't mark the call info child table since that will be done
+	   via the appropriate method */
+}
+
+VALUE
+prof_call_info_wrap(prof_call_info_t *call_info)
+{
+  if (call_info->object == Qnil)
+  {
+    call_info->object = Data_Wrap_Struct(cCallInfo, prof_call_info_mark, prof_call_info_ruby_gc_free, call_info);
+  }
+  return call_info->object;
+}
+
+static 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_table(&type_method_hash);
+}
+
+size_t
+call_info_table_insert(st_table *table, const prof_method_key_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, const prof_method_key_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   ========*/
+
+/* Document-class: RubyProf::CallInfo
+RubyProf::CallInfo is a helper class used by RubyProf::MethodInfo
+to keep track of which child methods were called and how long
+they took to execute. */
+
+
+/* call-seq:
+   called -> MethodInfo
+
+Returns the target method. */
+static VALUE
+prof_call_info_target(VALUE self)
+{
+    /* Target is a pointer to a method_info - so we have to be careful
+       about the GC.  We will wrap the method_info but provide no
+       free method so the underlying object is not freed twice! */
+
+    prof_call_info_t *result = prof_get_call_info(self);
+    return prof_method_wrap(result->target);
+}
+
+/* call-seq:
+   called -> int
+
+Returns the total amount of times this method was called. */
+static VALUE
+prof_call_info_called(VALUE self)
+{
+    prof_call_info_t *result = prof_get_call_info(self);
+    return INT2NUM(result->called);
+}
+
+/* call-seq:
+   called=n -> n
+
+Sets the call count to n. */
+static VALUE
+prof_call_info_set_called(VALUE self, VALUE called)
+{
+    prof_call_info_t *result = prof_get_call_info(self);
+    result->called = NUM2INT(called);
+    return called;
+}
+
+/* call-seq:
+   recursive? -> boolean
+
+   Returns the true if this call info is a recursive invocation */
+static VALUE
+prof_call_info_recursive(VALUE self)
+{
+  prof_call_info_t *result = prof_get_call_info(self);
+  return result->recursive ? Qtrue : Qfalse;
+}
+
+/* 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:
+   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 rb_int_new(result->line);
+}
+
+/* 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 *result = prof_get_call_info(self);
+    if (result->parent)
+      return prof_call_info_wrap(result->parent);
+    else
+      return Qnil;
+}
+
+/* call-seq:
+   parent=new_parent -> new_parent
+
+Changes the parent of self to new_parent and returns it.*/
+static VALUE
+prof_call_info_set_parent(VALUE self, VALUE new_parent)
+{
+    prof_call_info_t *result = prof_get_call_info(self);
+    if (new_parent == Qnil)
+      result->parent = NULL;
+    else
+      result->parent = prof_get_call_info(new_parent);
+    return prof_call_info_parent(self);
+}
+
+static int
+prof_call_info_collect_children(st_data_t key, st_data_t value, st_data_t result)
+{
+    prof_call_info_t *call_info = (prof_call_info_t *) value;
+    VALUE arr = (VALUE) result;
+    rb_ary_push(arr, prof_call_info_wrap(call_info));
+    return ST_CONTINUE;
+}
+
+/* call-seq:
+   children -> hash
+
+Returns an array of call info objects of methods that this method
+called (ie, children).*/
+static VALUE
+prof_call_info_children(VALUE self)
+{
+    prof_call_info_t *call_info = prof_get_call_info(self);
+    if (call_info->children == Qnil)
+    {
+      call_info->children = rb_ary_new();
+      st_foreach(call_info->call_infos, prof_call_info_collect_children, call_info->children);
+    }
+    return call_info->children;
+}
+
+/* =======  Call Infos   ========*/
+prof_call_infos_t*
+prof_call_infos_create()
+{
+   prof_call_infos_t *result = ALLOC(prof_call_infos_t);
+   result->start = ALLOC_N(prof_call_info_t*, INITIAL_CALL_INFOS_SIZE);
+   result->end = result->start + INITIAL_CALL_INFOS_SIZE;
+   result->ptr = result->start;
+   result->object = Qnil;
+   return result;
+}
+
+void
+prof_call_infos_mark(prof_call_infos_t *call_infos)
+{
+    prof_call_info_t **call_info;
+
+	if (call_infos->object)
+		rb_gc_mark(call_infos->object);
+
+    for(call_info=call_infos->start; call_info<call_infos->ptr; call_info++)
+    {
+		prof_call_info_mark(*call_info);
+    }
+}
+
+void
+prof_call_infos_free(prof_call_infos_t *call_infos)
+{
+    prof_call_info_t **call_info;
+
+    for(call_info=call_infos->start; call_info<call_infos->ptr; call_info++)
+    {
+		prof_call_info_free(*call_info);
+    }
+}
+
+void
+prof_add_call_info(prof_call_infos_t *call_infos, prof_call_info_t *call_info)
+{
+  if (call_infos->ptr == call_infos->end)
+  {
+    size_t len = call_infos->ptr - call_infos->start;
+    size_t new_capacity = (call_infos->end - call_infos->start) * 2;
+    REALLOC_N(call_infos->start, prof_call_info_t*, new_capacity);
+    call_infos->ptr = call_infos->start + len;
+    call_infos->end = call_infos->start + new_capacity;
+  }
+  *call_infos->ptr = call_info;
+  call_infos->ptr++;
+}
+
+VALUE
+prof_call_infos_wrap(prof_call_infos_t *call_infos)
+{
+  if (call_infos->object == Qnil)
+  {
+    prof_call_info_t **i;
+    call_infos->object = rb_ary_new();
+    for(i=call_infos->start; i<call_infos->ptr; i++)
+    {
+      VALUE call_info = prof_call_info_wrap(*i);
+      rb_ary_push(call_infos->object, call_info);
+    }
+  }
+  return call_infos->object;
+}
+
+VALUE
+prof_call_info_measure_values(VALUE self)
+{
+    prof_call_info_t *call_info = prof_get_call_info(self);
+
+    VALUE ary = rb_ary_new2(call_info->measures_len);
+    for(size_t i = 0; i < call_info->measures_len; i++) {
+        VALUE sub_ary = rb_ary_new2(3);
+
+        rb_ary_store(sub_ary, 0, DBL2NUM(call_info->measure_values[i].total));
+        rb_ary_store(sub_ary, 1, DBL2NUM(call_info->measure_values[i].self));
+        rb_ary_store(sub_ary, 2, DBL2NUM(call_info->measure_values[i].wait));
+
+        rb_ary_store(ary, i, sub_ary);
+    }
+
+    return ary;
+}
+
+
+void rp_init_call_info()
+{
+    /* CallInfo */
+    cCallInfo = rb_define_class_under(mProf, "CallInfo", rb_cObject);
+    rb_undef_method(CLASS_OF(cCallInfo), "new");
+    rb_define_method(cCallInfo, "parent", prof_call_info_parent, 0);
+    rb_define_method(cCallInfo, "parent=", prof_call_info_set_parent, 1);
+    rb_define_method(cCallInfo, "children", prof_call_info_children, 0);
+    rb_define_method(cCallInfo, "target", prof_call_info_target, 0);
+    rb_define_method(cCallInfo, "called", prof_call_info_called, 0);
+    rb_define_method(cCallInfo, "called=", prof_call_info_set_called, 1);
+
+    rb_define_method(cCallInfo, "recursive?", prof_call_info_recursive, 0);
+    rb_define_method(cCallInfo, "depth", prof_call_info_depth, 0);
+    rb_define_method(cCallInfo, "line", prof_call_info_line, 0);
+    rb_define_method(cCallInfo, "measure_values", prof_call_info_measure_values, 0);
+}

data/ext/ruby_prof/rp_call_info.h

@@ -0,0 +1,59 @@
+/* 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 */
+
+#ifndef __RP_CALL_INFO_H__
+#define __RP_CALL_INFO_H__
+
+#include "rp_measure.h"
+#include "rp_method.h"
+
+extern VALUE cCallInfo;
+
+typedef struct prof_measure_value_t
+{
+    double total;
+    double self;
+    double wait;
+} prof_measure_value_t;
+
+/* Callers and callee information for a method. */
+typedef struct prof_call_info_t
+{
+    prof_method_t *target; /* Use target instead of method to avoid conflict with Ruby method */
+    struct prof_call_info_t *parent;
+    st_table *call_infos;
+
+    VALUE object;
+    VALUE children;
+
+    int called;
+
+    unsigned int recursive : 1;
+    unsigned int depth : 15;
+    unsigned int line : 16;
+
+    size_t measures_len;
+    prof_measure_value_t measure_values[];
+} prof_call_info_t;
+
+/* Array of call_info objects */
+typedef struct prof_call_infos_t
+{
+    prof_call_info_t **start;
+    prof_call_info_t **end;
+    prof_call_info_t **ptr;
+    VALUE object;
+} prof_call_infos_t;
+
+
+void rp_init_call_info(void);
+prof_call_infos_t* prof_call_infos_create();
+void prof_call_infos_mark(prof_call_infos_t *call_infos);
+void prof_call_infos_free(prof_call_infos_t *call_infos);
+void prof_add_call_info(prof_call_infos_t *call_infos, prof_call_info_t *call_info);
+VALUE prof_call_infos_wrap(prof_call_infos_t *call_infos);
+prof_call_info_t * prof_call_info_create(prof_method_t* method, prof_call_info_t* parent, size_t measurements_len);
+prof_call_info_t * call_info_table_lookup(st_table *table, const prof_method_key_t *key);
+size_t call_info_table_insert(st_table *table, const prof_method_key_t *key, prof_call_info_t *val);
+
+#endif //__RP_CALL_INFO_H__