pline 0.0.3

data/ext/pline/ruby_source/1.9.3/vm_insnhelper.h

@@ -0,0 +1,220 @@
+/**********************************************************************
+
+  insnhelper.h - helper macros to implement each instructions
+
+  $Author$
+  created at: 04/01/01 15:50:34 JST
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_INSNHELPER_H
+#define RUBY_INSNHELPER_H
+
+/**
+ * VM Debug Level
+ *
+ * debug level:
+ *  0: no debug output
+ *  1: show instruction name
+ *  2: show stack frame when control stack frame is changed
+ *  3: show stack status
+ *  4: show register
+ *  5:
+ * 10: gc check
+ */
+
+#ifndef VMDEBUG
+#define VMDEBUG 0
+#endif
+
+#if 0
+#undef  VMDEBUG
+#define VMDEBUG 3
+#endif
+
+enum {
+  BOP_PLUS,
+  BOP_MINUS,
+  BOP_MULT,
+  BOP_DIV,
+  BOP_MOD,
+  BOP_EQ,
+  BOP_EQQ,
+  BOP_LT,
+  BOP_LE,
+  BOP_LTLT,
+  BOP_AREF,
+  BOP_ASET,
+  BOP_LENGTH,
+  BOP_SIZE,
+  BOP_SUCC,
+  BOP_GT,
+  BOP_GE,
+  BOP_NOT,
+  BOP_NEQ,
+
+  BOP_LAST_
+};
+
+extern char ruby_vm_redefined_flag[BOP_LAST_];
+extern VALUE ruby_vm_const_missing_count;
+
+
+/**********************************************************/
+/* deal with stack                                        */
+/**********************************************************/
+
+#define PUSH(x) (SET_SV(x), INC_SP(1))
+#define TOPN(n) (*(GET_SP()-(n)-1))
+#define POPN(n) (DEC_SP(n))
+#define POP()   (DEC_SP(1))
+#define STACK_ADDR_FROM_TOP(n) (GET_SP()-(n))
+
+#define GET_TOS()  (tos)	/* dummy */
+
+/**********************************************************/
+/* deal with registers                                    */
+/**********************************************************/
+
+#define REG_CFP (reg_cfp)
+#define REG_PC  (REG_CFP->pc)
+#define REG_SP  (REG_CFP->sp)
+#define REG_LFP (REG_CFP->lfp)
+#define REG_DFP (REG_CFP->dfp)
+
+#define RESTORE_REGS() do { \
+  REG_CFP = th->cfp; \
+} while (0)
+
+#define REG_A   reg_a
+#define REG_B   reg_b
+
+#ifdef COLLECT_USAGE_ANALYSIS
+#define USAGE_ANALYSIS_REGISTER_HELPER(a, b, v) \
+  (USAGE_ANALYSIS_REGISTER((a), (b)), (v))
+#else
+#define USAGE_ANALYSIS_REGISTER_HELPER(a, b, v) (v)
+#endif
+
+/* PC */
+#define GET_PC()           (USAGE_ANALYSIS_REGISTER_HELPER(0, 0, REG_PC))
+#define SET_PC(x)          (REG_PC = (USAGE_ANALYSIS_REGISTER_HELPER(0, 1, (x))))
+#define GET_CURRENT_INSN() (*GET_PC())
+#define GET_OPERAND(n)     (GET_PC()[(n)])
+#define ADD_PC(n)          (SET_PC(REG_PC + (n)))
+
+#define GET_PC_COUNT()     (REG_PC - GET_ISEQ()->iseq_encoded)
+#define JUMP(dst)          (REG_PC += (dst))
+
+/* FP */
+#define GET_CFP()  (USAGE_ANALYSIS_REGISTER_HELPER(2, 0, REG_CFP))
+#define GET_LFP()  (USAGE_ANALYSIS_REGISTER_HELPER(3, 0, REG_LFP))
+#define SET_LFP(x) (REG_LFP = (USAGE_ANALYSIS_REGISTER_HELPER(3, 1, (x))))
+#define GET_DFP()  (USAGE_ANALYSIS_REGISTER_HELPER(4, 0, REG_DFP))
+#define SET_DFP(x) (REG_DFP = (USAGE_ANALYSIS_REGISTER_HELPER(4, 1, (x))))
+
+/* SP */
+#define GET_SP()   (USAGE_ANALYSIS_REGISTER_HELPER(1, 0, REG_SP))
+#define SET_SP(x)  (REG_SP  = (USAGE_ANALYSIS_REGISTER_HELPER(1, 1, (x))))
+#define INC_SP(x)  (REG_SP += (USAGE_ANALYSIS_REGISTER_HELPER(1, 1, (x))))
+#define DEC_SP(x)  (REG_SP -= (USAGE_ANALYSIS_REGISTER_HELPER(1, 1, (x))))
+#define SET_SV(x)  (*GET_SP() = (x))
+  /* set current stack value as x */
+
+#define GET_SP_COUNT() (REG_SP - th->stack)
+
+/* instruction sequence C struct */
+#define GET_ISEQ() (GET_CFP()->iseq)
+
+/**********************************************************/
+/* deal with variables                                    */
+/**********************************************************/
+
+#define GET_PREV_DFP(dfp)                ((VALUE *)((dfp)[0] & ~0x03))
+
+#define GET_GLOBAL(entry)       rb_gvar_get((struct rb_global_entry*)(entry))
+#define SET_GLOBAL(entry, val)  rb_gvar_set((struct rb_global_entry*)(entry), (val))
+
+#define GET_CONST_INLINE_CACHE(dst) ((IC) * (GET_PC() + (dst) + 2))
+
+/**********************************************************/
+/* deal with values                                       */
+/**********************************************************/
+
+#define GET_SELF() (USAGE_ANALYSIS_REGISTER_HELPER(5, 0, GET_CFP()->self))
+
+/**********************************************************/
+/* deal with control flow 2: method/iterator              */
+/**********************************************************/
+
+#define COPY_CREF(c1, c2) do {  \
+  NODE *__tmp_c2 = (c2); \
+  (c1)->nd_clss = __tmp_c2->nd_clss; \
+  (c1)->nd_visi = __tmp_c2->nd_visi;\
+  (c1)->nd_next = __tmp_c2->nd_next; \
+  if (__tmp_c2->flags & NODE_FL_CREF_PUSHED_BY_EVAL) { \
+      (c1)->flags |= NODE_FL_CREF_PUSHED_BY_EVAL; \
+  } \
+} while (0)
+
+#define CALL_METHOD(num, blockptr, flag, id, me, recv) do { \
+    VALUE v = vm_call_method(th, GET_CFP(), (num), (blockptr), (flag), (id), (me), (recv)); \
+    if (v == Qundef) { \
+	RESTORE_REGS(); \
+	NEXT_INSN(); \
+    } \
+    else { \
+	val = v; \
+    } \
+} while (0)
+
+#define GET_BLOCK_PTR() \
+  ((rb_block_t *)(GC_GUARDED_PTR_REF(GET_LFP()[0] & \
+				     ((GET_LFP()[0] & 0x02) - 0x02))))
+
+/**********************************************************/
+/* deal with control flow 3: exception                    */
+/**********************************************************/
+
+
+/**********************************************************/
+/* others                                                 */
+/**********************************************************/
+
+/* optimize insn */
+#define FIXNUM_2_P(a, b) ((a) & (b) & 1)
+#define BASIC_OP_UNREDEFINED_P(op) (LIKELY(ruby_vm_redefined_flag[(op)] == 0))
+#define HEAP_CLASS_OF(obj) RBASIC(obj)->klass
+
+#ifndef USE_IC_FOR_SPECIALIZED_METHOD
+#define USE_IC_FOR_SPECIALIZED_METHOD 1
+#endif
+
+#if USE_IC_FOR_SPECIALIZED_METHOD
+
+#define CALL_SIMPLE_METHOD(num, id, recv) do { \
+    VALUE klass = CLASS_OF(recv); \
+    CALL_METHOD((num), 0, 0, (id), vm_method_search((id), klass, ic), (recv)); \
+} while (0)
+
+#else
+
+#define CALL_SIMPLE_METHOD(num, id, recv) do { \
+    VALUE klass = CLASS_OF(recv); \
+    CALL_METHOD((num), 0, 0, (id), rb_method_entry(klass, (id)), (recv)); \
+} while (0)
+
+#endif
+
+static VALUE ruby_vm_global_state_version = 1;
+
+#define GET_VM_STATE_VERSION() (ruby_vm_global_state_version)
+#define INC_VM_STATE_VERSION() do { \
+    ruby_vm_global_state_version = (ruby_vm_global_state_version + 1); \
+    if (ruby_vm_global_state_version == 0) vm_clear_all_cache(); \
+} while (0)
+static void vm_clear_all_cache(void);
+
+#endif /* RUBY_INSNHELPER_H */

data/ext/pline/ruby_source/1.9.3/vm_opts.h

@@ -0,0 +1,51 @@
+/*-*-c-*-*/
+/**********************************************************************
+
+  vm_opts.h - VM optimize option
+
+  $Author$
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+
+#ifndef RUBY_VM_OPTS_H
+#define RUBY_VM_OPTS_H
+
+/* Compile options.
+ * You can change these options at runtime by VM::CompileOption.
+ * Following definitions are default values.
+ */
+
+#define OPT_TRACE_INSTRUCTION        1
+#define OPT_TAILCALL_OPTIMIZATION    0
+#define OPT_PEEPHOLE_OPTIMIZATION    1
+#define OPT_SPECIALISED_INSTRUCTION  1
+#define OPT_INLINE_CONST_CACHE       1
+
+
+/* Build Options.
+ * You can't change these options at runtime.
+ */
+
+/* C compiler depend */
+#define OPT_DIRECT_THREADED_CODE     1
+#define OPT_TOKEN_THREADED_CODE      0
+#define OPT_CALL_THREADED_CODE       0
+
+/* VM running option */
+#define OPT_CHECKED_RUN              1
+#define OPT_INLINE_METHOD_CACHE      1
+#define OPT_BLOCKINLINING            0
+
+/* architecture independent, affects generated code */
+#define OPT_OPERANDS_UNIFICATION     0
+#define OPT_INSTRUCTIONS_UNIFICATION 0
+#define OPT_UNIFY_ALL_COMBINATION    0
+#define OPT_STACK_CACHING            0
+
+/* misc */
+#define SUPPORT_JOKE                 0
+
+#endif /* RUBY_VM_OPTS_H */

data/ext/pline/sinfo.c

@@ -0,0 +1,311 @@
+static st_table *scoring_sinfo_table;
+static st_table *preline_sinfo_table;
+
+typedef unsigned long long int pline_time_t;
+
+/* pline_sinfo_container */
+typedef struct pline_sinfo_container {
+  st_table *sinfo_table;
+} pline_sinfo_container_t;
+static ID sinfo_container_id;
+
+static int sinfo_container_mark_i(st_data_t key, st_data_t value, st_data_t arg)
+{
+  VALUE sinfo = (VALUE)value;
+  rb_gc_mark(sinfo);
+  return ST_CONTINUE;
+}
+
+static void sinfo_container_mark(void *p)
+{
+  pline_sinfo_container_t *s = p;
+
+  if (!s) return;
+  st_foreach(s->sinfo_table, sinfo_container_mark_i, 0);
+}
+
+static void sinfo_container_free(void *p)
+{
+  pline_sinfo_container_t *s = p;
+
+  if (!s) return;
+
+  st_free_table(s->sinfo_table);
+  xfree(s);
+}
+
+static const rb_data_type_t sinfo_container_data_type = {
+  "pline_sinfo_container",
+  {sinfo_container_mark, sinfo_container_free, NULL,},
+};
+
+static VALUE sinfo_container_s_alloc(VALUE klass)
+{
+  VALUE obj;
+  pline_sinfo_container_t *s;
+
+  obj = TypedData_Make_Struct(klass, pline_sinfo_container_t, &sinfo_container_data_type, s);
+  s->sinfo_table = st_init_strtable();
+
+  return obj;
+}
+
+static st_table* sinfo_container_process_sinfo_table(void)
+{
+  VALUE scon, thval = rb_thread_current();
+  pline_sinfo_container_t *s;
+
+  scon = rb_thread_local_aref(thval, sinfo_container_id);
+  if (!RTEST(scon)) {
+    scon = rb_funcall(cSourceInfoContainer, rb_intern("new"), 0);
+    rb_thread_local_aset(thval, sinfo_container_id, scon);
+  }
+  s = DATA_PTR(scon);
+
+  return s->sinfo_table;
+}
+
+/* pline_src_info */
+
+typedef union pline_line_info {
+  pline_time_t score;
+  pline_time_t start;
+  long prev;
+} pline_line_info_t;
+
+typedef struct pline_src_info {
+  pline_line_info_t *lines;
+  long size;
+} pline_src_info_t;
+
+static void sinfo_mark(void *p)
+{
+  pline_src_info_t *s = p;
+
+  if (!s) return;
+}
+
+static void sinfo_free(void *p)
+{
+  pline_src_info_t *s = p;
+
+  if (!s) return;
+
+  if (s->lines) {
+    xfree(s->lines);
+  }
+  xfree(s);
+}
+
+static const rb_data_type_t sinfo_data_type = {
+  "pline_src_info",
+  {sinfo_mark, sinfo_free, NULL,},
+};
+
+static VALUE sinfo_s_alloc(VALUE klass)
+{
+  VALUE obj;
+  pline_src_info_t *s;
+
+  obj = TypedData_Make_Struct(klass, pline_src_info_t, &sinfo_data_type, s);
+  s->lines = NULL;
+  s->size = 0;
+
+  return obj;
+}
+
+static VALUE sinfo_m_lines(VALUE self)
+{
+  pline_src_info_t *s = DATA_PTR(self);
+  VALUE lines = rb_ary_new2(s->size);
+  int i;
+
+  for (i = 0; i < s->size; i++) {
+    rb_ary_push(lines, LL2NUM(s->lines[i].score));
+  }
+
+  return lines;
+}
+
+static VALUE sinfo_find(st_table *sinfo_table, const char *s)
+{
+  VALUE sinfo;
+
+  if (st_lookup(sinfo_table, (st_data_t)s, (st_data_t*)&sinfo)) {
+    return sinfo;
+  } else {
+    return Qnil;
+  }
+}
+
+static void sinfo_allocate_lines(pline_src_info_t *sinfo, long line)
+{
+  if (sinfo->lines) {
+    REALLOC_N(sinfo->lines, pline_line_info_t, line);
+  } else {
+    sinfo->lines = ALLOC_N(pline_line_info_t, line);
+  }
+}
+
+/* for scoring */
+static VALUE sinfo_find_scoring_sinfo_force(const char *s)
+{
+  VALUE sinfo = sinfo_find(scoring_sinfo_table, s);
+
+  if (!RTEST(sinfo)) {
+    sinfo = rb_funcall(cSourceInfo, rb_intern("new"), 0);
+    rb_gc_register_mark_object(sinfo);
+    st_insert(scoring_sinfo_table, (st_data_t)s, (st_data_t)sinfo);
+  }
+
+  return sinfo;
+}
+
+static void sinfo_expand_scoring_sinfo(pline_src_info_t *sinfo, long line)
+{
+  long i;
+
+  if (sinfo->size < line) {
+    sinfo_allocate_lines(sinfo, line);
+    for (i = sinfo->size; i < line; i++) {
+      sinfo->lines[i].score = 0;
+    }
+    sinfo->size = line;
+  }
+}
+
+static VALUE sinfo_s_find(VALUE self, VALUE path)
+{
+  VALUE sinfo;
+
+  if (TYPE(path) != T_STRING) {
+    rb_raise(rb_eArgError, "invalid argument");
+  }
+
+  return sinfo_find(scoring_sinfo_table, RSTRING_PTR(path));
+}
+
+/* for processing */
+static VALUE sinfo_find_process_sinfo_force(const char *s)
+{
+  st_table *process_sinfo_table = sinfo_container_process_sinfo_table();
+  VALUE sinfo = sinfo_find(process_sinfo_table, s);
+
+  if (!RTEST(sinfo)) {
+    sinfo = rb_funcall(cSourceInfo, rb_intern("new"), 0);
+    st_insert(process_sinfo_table, (st_data_t)s, (st_data_t)sinfo);
+  }
+
+  return sinfo;
+}
+
+static void sinfo_expand_process_sinfo(pline_src_info_t *sinfo, long line)
+{
+  long i;
+
+  if (sinfo->size < line) {
+    sinfo_allocate_lines(sinfo, line);
+    for (i = sinfo->size; i < line; i++) {
+      sinfo->lines[i].start = NOVALUE;
+    }
+    sinfo->size = line;
+  }
+}
+
+/* for previous line search */
+static VALUE sinfo_find_preline_sinfo_force(const char *s)
+{
+  VALUE sinfo = sinfo_find(preline_sinfo_table, s);
+
+  if (!RTEST(sinfo)) {
+    sinfo = rb_funcall(cSourceInfo, rb_intern("new"), 0);
+    rb_gc_register_mark_object(sinfo);
+    st_insert(preline_sinfo_table, (st_data_t)s, (st_data_t)sinfo);
+  }
+
+  return sinfo;
+}
+
+static void sinfo_expand_preline_sinfo(pline_src_info_t *sinfo, long line)
+{
+  long i;
+
+  if (sinfo->size < line) {
+    sinfo_allocate_lines(sinfo, line);
+    for (i = sinfo->size; i < line; i++) {
+      sinfo->lines[i].prev = -1;
+    }
+    sinfo->size = line;
+  }
+}
+
+static pline_time_t sinfo_measure_time(void)
+{
+  pline_time_t t;
+
+#ifdef _WIN32
+  FILETIME ft;
+
+  GetSystemTimeAsFileTime(&ft);
+  t = (((pline_time_t)ft.dwHighDateTime << 32) | (pline_time_t)ft.dwLowDateTime) * 100;
+#else
+  struct timespec ts;
+
+  clock_gettime(CLOCK_REALTIME, &ts);
+  t = ((pline_time_t)ts.tv_sec)*1000*1000*1000 + ((pline_time_t)ts.tv_nsec);
+#endif
+
+  return t;
+}
+
+/* measurement using sinfo */
+static void sinfo_measure(const char *srcfile, long line)
+{
+  VALUE scoring_v = sinfo_find_scoring_sinfo_force(srcfile);
+  VALUE process_v = sinfo_find_process_sinfo_force(srcfile);
+  VALUE preline_v = sinfo_find_preline_sinfo_force(srcfile);
+  pline_src_info_t *scoring_sinfo = DATA_PTR(scoring_v);
+  pline_src_info_t *process_sinfo = DATA_PTR(process_v);
+  pline_src_info_t *preline_sinfo = DATA_PTR(preline_v);
+  long i, cidx, pidx;
+  pline_time_t t;
+
+  sinfo_expand_scoring_sinfo(scoring_sinfo, line);
+  sinfo_expand_process_sinfo(process_sinfo, line);
+  sinfo_expand_preline_sinfo(preline_sinfo, line);
+
+  cidx = line2idx(line);
+  pidx = preline_sinfo->lines[cidx].prev;
+  if (pidx < 0) {
+    for (i = cidx - 1; i >= 0; i--) {
+      if (has_value(process_sinfo->lines[i].start)) {
+        pidx = preline_sinfo->lines[cidx].prev = i;
+        break;
+      }
+    }
+  }
+
+  t = sinfo_measure_time();
+  process_sinfo->lines[cidx].start = t;
+  if (pidx >= 0) {
+    if (has_value(process_sinfo->lines[pidx].start)) {
+      pline_time_t s = process_sinfo->lines[pidx].start;
+      scoring_sinfo->lines[pidx].score += (t - s);
+      process_sinfo->lines[pidx].start = NOVALUE;
+    }
+  }
+}
+
+static void pline_sinfo_init(void)
+{
+  cSourceInfo = rb_define_class_under(mPLine, "SourceInfo", rb_cObject);
+  rb_define_singleton_method(cSourceInfo, "find", sinfo_s_find, 1);
+  rb_define_method(cSourceInfo, "lines", sinfo_m_lines, 0);
+  rb_define_alloc_func(cSourceInfo, sinfo_s_alloc);
+  cSourceInfoContainer = rb_define_class_under(cSourceInfo, "SourceInfoContainer", rb_cObject);
+  rb_define_alloc_func(cSourceInfoContainer, sinfo_container_s_alloc);
+  sinfo_container_id = rb_intern("__pline_sinfo_container");
+  scoring_sinfo_table = st_init_strtable();
+  preline_sinfo_table = st_init_strtable();
+}
+