pline 0.0.3

data/README

@@ -0,0 +1,134 @@
+* About PLine
+PLine is a profiler for Ruby1.9.3 and Ruby1.9.2.
+PLine profiles each line of Ruby method (method written in Ruby) you specified.
+Using PLine, you can profile each line of Ruby method easily.
+
+This README document introduces basic functionality of PLine.
+If you have any questions or comments, please send email to shiba@rvm.jp,
+or use http://github.com/soba1104/PLine/issues.
+
+
+
+* License
+Same as the license of Ruby runtime.
+
+
+
+* Installation
+$gem install pline
+
+Currently, PLine supports Ruby1.9.3 and Ruby1.9.2 only.
+So, if you want to use PLine, please install PLine
+under Ruby1.9.3 or Ruby1.9.2 runtime. 
+
+
+
+* Usage
+############### sample code ###############
+require 'pline'
+
+# Target method of profiling
+def sum(a, b)
+  a + b
+end
+
+# Specify unit of measurement to PLine
+PLine.show_msec()
+
+# Specify profiling to PLine
+PLine.profile(self, :sum, true)
+
+1000000.times{|i| sum(i, i)}
+
+################## result ##################
+ -----------------------------------------
+|     main.sum: tmp/sample.rb(4 - 6)      |
+|-----------------------------------------|
+|  Line  |  Time(msec)  |     Source      |
+|-----------------------------------------|
+|      4 |            0 | def sum(a, b)   |
+|      5 |          625 |   a + b         | < You can know that 
+|      6 |            0 | end             |   'a + b' takes 625 microseconds.
+ -----------------------------------------
+  
+
+
+* Attention
+Currently, PLine is alpha version. So, you must not use PLine in critical mission.
+This section introduces some attentions about PLine.
+
+** Recursive call profiling
+PLine cannot profile recursive call statements correctly.
+Profiling results of recursive call statements may become short.
+
+** Block invocation profiling
+PLine cannot profile exit points of block invocation.
+Profiling results of exit points of block invocation may become significantly short.
+
+------------------------ example ------------------------
+# sample code
+require 'pline'
+
+def foo
+  sum = 0
+  100000.times{|i|
+    sum += i
+    sum += i
+  }
+  sum
+end
+
+PLine.profile(self, :foo, true)
+foo()
+
+# result
+ ----------------------------------------
+|     main.foo: tmp/test2.rb(3 - 10)     |
+|----------------------------------------|
+| Line | Time(usec) |       Source       |
+|----------------------------------------|
+|    3 |          0 | def foo            |
+|    4 |          2 |   sum = 0          |
+|    5 |          2 |   100000.times{|i| |
+|    6 |      81190 |     sum += i       |
+|    7 |          3 |     sum += i       | <= this
+|    8 |          0 |   }                |
+|    9 |          1 |   sum              |
+|   10 |          0 | end                |
+ ----------------------------------------
+---------------------------------------------------------
+
+** Using together with other profiler
+PLine rewrites RUBY_EVENT_LINE event to RUBY_EVENT_END event.
+So, when you use PLine, above events become incompatible.
+You should not use PLine together with other profilers which use above events.
+
+
+
+* PLine APIs
+This section introduces PLine APIs.
+
+** A API of specifying profiling
+- PLine.profile(object, method_id, singleton_p = false)
+Specify profiling to PLine.
+When singleton_p argument(third argument) is false, PLine searches object#method_id (instance method).
+Otherwise, PLine searches object.method_id (singleton_method).
+
+** APIs of specifying output
+- PLine.output=(io)
+Specify output io object.
+Default output of PLine is STDERR.
+
+- PLine.show_sec()
+Specify sec as the unit of measurement.
+
+- PLine.show_msec()
+Specify millisec as the unit of measurement.
+
+- PLine.show_usec()
+Specify microsec as the unit of measurement.
+Microsec is the default unit of measurement.
+
+- PLine.show_nsec()
+Specify nanosec as the unit of measurement.
+

data/ext/pline/depend

@@ -0,0 +1,55 @@
+HEADERS = \
+  $(arch_hdrdir)/ruby/config.h			\
+  $(hdrdir)/ruby/defines.h			\
+  $(hdrdir)/ruby/intern.h			\
+  $(hdrdir)/ruby/missing.h			\
+  $(hdrdir)/ruby/ruby.h				\
+  $(hdrdir)/ruby/st.h				\
+  $(srcdir)/ruby_source/1.9.3/eval_intern.h	\
+  $(srcdir)/ruby_source/1.9.3/iseq.h		\
+  $(srcdir)/ruby_source/1.9.3/method.h		\
+  $(srcdir)/ruby_source/1.9.3/node.h		\
+  $(srcdir)/ruby_source/1.9.3/thread_pthread.h	\
+  $(srcdir)/ruby_source/1.9.3/thread_win32.h	\
+  $(srcdir)/ruby_source/1.9.3/vm_core.h		\
+  $(srcdir)/ruby_source/1.9.3/vm_exec.h		\
+  $(srcdir)/ruby_source/1.9.3/vm_insnhelper.c	\
+  $(srcdir)/ruby_source/1.9.3/vm_insnhelper.h	\
+  $(srcdir)/ruby_source/1.9.3/vm_opts.h		\
+  $(srcdir)/ruby_source/1.9.3/insns_info.inc	\
+  $(srcdir)/ruby_source/1.9.3/insns.inc		\
+  $(srcdir)/ruby_source/1.9.3/constant.h	\
+  $(srcdir)/ruby_source/1.9.3/atomic.h		\
+  $(srcdir)/ruby_source/1.9.3/internal.h	\
+  $(srcdir)/ruby_source/1.9.3/manual_update.h	\
+  $(srcdir)/ruby_source/1.9.2/debug.h		\
+  $(srcdir)/ruby_source/1.9.2/gc.h		\
+  $(srcdir)/ruby_source/1.9.2/id.h		\
+  $(srcdir)/ruby_source/1.9.2/eval_intern.h	\
+  $(srcdir)/ruby_source/1.9.2/iseq.h		\
+  $(srcdir)/ruby_source/1.9.2/method.h		\
+  $(srcdir)/ruby_source/1.9.2/node.h		\
+  $(srcdir)/ruby_source/1.9.2/thread_pthread.h	\
+  $(srcdir)/ruby_source/1.9.2/thread_win32.h	\
+  $(srcdir)/ruby_source/1.9.2/vm_core.h		\
+  $(srcdir)/ruby_source/1.9.2/vm_exec.h		\
+  $(srcdir)/ruby_source/1.9.2/vm_insnhelper.c	\
+  $(srcdir)/ruby_source/1.9.2/vm_insnhelper.h	\
+  $(srcdir)/ruby_source/1.9.2/vm_opts.h		\
+  $(srcdir)/ruby_source/1.9.2/insns_info.inc	\
+  $(srcdir)/ruby_source/1.9.2/insns.inc		\
+  $(srcdir)/ruby_source/1.9.2/manual_update.h	\
+  $(srcdir)/extconf.h
+
+$(srcdir)/pline.c:				\
+  $(srcdir)/pline.c.rb
+	$(RUBY) -- $(srcdir)/pline.c.rb > $@
+
+$(srcdir)/pline.o:				\
+  $(HEADERS)                                    \
+  $(srcdir)/profiler.c                          \
+  $(srcdir)/sinfo.c                             \
+  $(srcdir)/minfo.c                             \
+  $(srcdir)/iseq.c                              \
+  $(srcdir)/pline.c
+

data/ext/pline/extconf.rb

@@ -0,0 +1,14 @@
+# coding=utf-8
+
+require 'mkmf'
+require 'rbconfig'
+extend RbConfig
+
+$defs.push '-DCABI_OPERANDS' if enable_config 'cabi-operands', true
+$defs.push '-DCABI_PASS_CFP' if enable_config 'cabi-pass-cfp', true
+
+$INCFLAGS << ' -I$(srcdir)/ruby_source'
+$objs = %w'$(srcdir)/pline.o'
+create_header
+create_makefile 'pline'
+

data/ext/pline/iseq.c

@@ -0,0 +1,124 @@
+static rb_iseq_t *iseq_find(VALUE obj, VALUE mid, VALUE singleton_p)
+{
+  rb_method_entry_t *me;
+  rb_method_definition_t *def;
+  VALUE km;
+  int class;
+  const char *msg = NULL;
+  VALUE name;
+  const char *sep = RTEST(singleton_p) ? "." : "#";
+
+  if (RTEST(singleton_p)) {
+    class = 1;
+    km = rb_class_of(obj);
+  } else {
+    VALUE c = rb_obj_class(obj);
+    if (c == rb_cClass) {
+      class = 1;
+    } else if (c == rb_cModule) {
+      class = 0;
+    } else {
+      rb_raise(rb_eArgError, "expected class or module");
+    }
+    km = obj;
+  }
+
+  me = search_method(km, SYM2ID(mid));
+  if (!me) {
+    if (class) {
+      name = rb_class_path(km);
+    } else {
+      name = rb_mod_name(km);
+    }
+    rb_raise(rb_eArgError, "method not found (%s%s%s)",
+             RSTRING_PTR(name), sep, rb_id2name(SYM2ID(mid)));
+  }
+
+  def = me->def;
+  switch (def->type) {
+    case VM_METHOD_TYPE_ISEQ:
+      return def->body.iseq;
+    case VM_METHOD_TYPE_CFUNC:
+      msg = "PLine cannot handle C method";
+      break;
+    case VM_METHOD_TYPE_ATTRSET:
+      msg = "PLine cannot handle attr_writer";
+      break;
+    case VM_METHOD_TYPE_IVAR:
+      msg = "PLine cannot handle attr_reader";
+      break;
+    case VM_METHOD_TYPE_BMETHOD:
+      msg = "Currently, PLine cannot handle method defined by define_method";
+      break;
+    case VM_METHOD_TYPE_ZSUPER:
+      msg = "Unsupported method type zsuper";
+      break;
+    case VM_METHOD_TYPE_UNDEF:
+      msg = "Unsupported method type undef";
+      break;
+    case VM_METHOD_TYPE_NOTIMPLEMENTED:
+      msg = "Unsupported method type notimplemented";
+      break;
+    case VM_METHOD_TYPE_OPTIMIZED:
+      msg = "Unsupported method type optimized";
+      break;
+    case VM_METHOD_TYPE_MISSING:
+      msg = "Unsupported method type missing";
+      break;
+    default:
+      msg = NULL;
+  }
+
+  if (!msg) {
+    rb_bug("pline_find_iseq: should not be reached(1)");
+  }
+
+  if (class) {
+    name = rb_class_path(km);
+  } else {
+    name = rb_mod_name(km);
+  }
+  rb_raise(rb_eArgError, "%s (%s%s%s)",
+           msg, RSTRING_PTR(name), sep, rb_id2name(SYM2ID(mid)));
+}
+
+static void iseq_inject(rb_iseq_t *iseq)
+{
+  int idx, len = iseq->iseq_size;
+  VALUE *seq = iseq->iseq;
+  VALUE *enc = iseq->iseq_encoded;
+
+  for (idx = 0; idx < len; idx += insn_len(seq[idx])) {
+    VALUE insn = seq[idx];
+    VALUE *op0 = &seq[idx] + 1;
+    VALUE *op1 = &enc[idx] + 1;
+    rb_num_t nf;
+    rb_iseq_t *child = NULL;
+
+    switch(insn) {
+    case BIN(trace):
+      nf = op0[0];
+      if (nf == RUBY_EVENT_LINE || nf == RUBY_EVENT_RETURN) {
+        op0[0] = RUBY_EVENT_END;
+        op1[0] = RUBY_EVENT_END;
+      }
+      break;
+    case BIN(putiseq):
+      child = (rb_iseq_t *)op0[0];
+      break;
+    case BIN(defineclass):
+      child = (rb_iseq_t *)op0[1];
+      break;
+    case BIN(send):
+      child = (rb_iseq_t *)op0[2];
+      break;
+    case BIN(invokesuper):
+      child = (rb_iseq_t *)op0[1];
+      break;
+    }
+    if (child) {
+      iseq_inject(child);
+    }
+  }
+}
+

data/ext/pline/minfo.c

@@ -0,0 +1,167 @@
+typedef struct pline_method_info {
+  VALUE obj;
+  VALUE mid;
+  VALUE spath;
+  VALUE sline;
+  VALUE eline;
+  VALUE singleton_p;
+} pline_method_info_t;
+
+static void minfo_mark(void *ptr)
+{
+  pline_method_info_t *m = ptr;
+
+  if (!m) return;
+  rb_gc_mark(m->obj);
+  rb_gc_mark(m->mid);
+  rb_gc_mark(m->spath);
+  rb_gc_mark(m->sline);
+  rb_gc_mark(m->eline);
+  rb_gc_mark(m->singleton_p);
+}
+
+static void minfo_free(void *p)
+{
+  if (p) xfree(p);
+}
+
+static const rb_data_type_t minfo_data_type = {
+  "pline_method_info",
+  {minfo_mark, minfo_free, NULL,},
+};
+
+static VALUE minfo_s_alloc(VALUE klass)
+{
+  VALUE obj;
+  pline_method_info_t *m;
+
+  obj = TypedData_Make_Struct(klass, pline_method_info_t, &minfo_data_type, m);
+  m->spath = Qnil;
+  m->sline = Qnil;
+  m->eline = Qnil;
+
+  return obj;
+}
+
+static void minfo_source_information_error(void)
+{
+  rb_raise(rb_eArgError, "unexpected source information");
+}
+
+static void check_line_information(VALUE line)
+{
+  if (rb_class_of(line) != rb_cFixnum || FIX2LONG(line) < 0) {
+    minfo_source_information_error();
+  }
+}
+
+static VALUE minfo_spath_from_iseq(VALUE iseqval)
+{
+  rb_iseq_t *iseq = DATA_PTR(iseqval);
+  VALUE spath = iseq->filename;
+  VALUE valid = rb_funcall(rb_cFile, rb_intern("exist?"), 1, spath);
+
+  if (!RTEST(valid)) {
+    minfo_source_information_error();
+  }
+
+  return spath;
+}
+
+static VALUE minfo_sline_from_iseq(VALUE iseqval)
+{
+  rb_iseq_t *iseq = DATA_PTR(iseqval);
+  VALUE sline = iseq->line_no;
+
+  check_line_information(sline);
+
+  return sline;
+}
+
+static VALUE minfo_eline_from_iseq(VALUE iseqval)
+{
+  rb_iseq_t *iseq = DATA_PTR(iseqval);
+  VALUE eline = iseq->line_no;
+  unsigned int i;
+
+  check_line_information(eline);
+
+  for (i = 0; i < iseq->insn_info_size; i++) {
+    VALUE l = LONG2FIX(iseq->insn_info_table[i].line_no);
+    if (l > eline) {
+      eline = l;
+    }
+  }
+
+  return eline;
+}
+
+static VALUE minfo_m_init(VALUE self, VALUE iseq, VALUE obj, VALUE mid, VALUE singleton_p)
+{
+  pline_method_info_t *m = DATA_PTR(self);
+  VALUE spath, sline, eline;
+
+  if (rb_obj_class(mid) != rb_cSymbol ||
+      rb_obj_class(iseq) != rb_cISeq) {
+    rb_raise(rb_eArgError, "invalid arguments");
+  }
+
+  m->obj = obj;
+  m->mid = mid;
+  m->spath = minfo_spath_from_iseq(iseq);
+  m->sline = minfo_sline_from_iseq(iseq);
+  m->eline = minfo_eline_from_iseq(iseq);
+  m->singleton_p = singleton_p;
+
+  return Qnil;
+}
+
+static VALUE minfo_m_obj(VALUE self)
+{
+  pline_method_info_t *m = DATA_PTR(self);
+  return m->obj;
+}
+
+static VALUE minfo_m_mid(VALUE self)
+{
+  pline_method_info_t *m = DATA_PTR(self);
+  return m->mid;
+}
+
+static VALUE minfo_m_spath(VALUE self)
+{
+  pline_method_info_t *m = DATA_PTR(self);
+  return m->spath;
+}
+
+static VALUE minfo_m_sline(VALUE self)
+{
+  pline_method_info_t *m = DATA_PTR(self);
+  return m->sline;
+}
+
+static VALUE minfo_m_eline(VALUE self)
+{
+  pline_method_info_t *m = DATA_PTR(self);
+  return m->eline;
+}
+
+static VALUE minfo_m_singleton_p(VALUE self)
+{
+  pline_method_info_t *m = DATA_PTR(self);
+  return RTEST(m->singleton_p) ? Qtrue : Qfalse;
+}
+
+static void pline_minfo_init(void)
+{
+  cMethodInfo = rb_define_class_under(mPLine, "MethodInfo", rb_cObject);
+  rb_define_method(cMethodInfo, "obj", minfo_m_obj, 0);
+  rb_define_method(cMethodInfo, "mid", minfo_m_mid, 0);
+  rb_define_method(cMethodInfo, "spath", minfo_m_spath, 0);
+  rb_define_method(cMethodInfo, "sline", minfo_m_sline, 0);
+  rb_define_method(cMethodInfo, "eline", minfo_m_eline, 0);
+  rb_define_method(cMethodInfo, "singleton?", minfo_m_singleton_p, 0);
+  rb_define_method(cMethodInfo, "initialize", minfo_m_init, 4);
+  rb_define_alloc_func(cMethodInfo, minfo_s_alloc);
+}
+