llrb 0.0.1

data/ext/llrb/parser.c

@@ -0,0 +1,191 @@
+/*
+ * parser.c: Constructs Control Flow Graph from encoded YARV instructions in ISeq.
+ */
+
+#include <stdio.h>
+#include "cfg.h"
+#include "cruby.h"
+
+static VALUE rb_eParseError;
+
+// Return sorted unique Ruby array of Basic Block start positions. Example: [0, 2, 8].
+//
+// It's constructed in the following rule.
+//   Rule 1: 0 is always included
+//   Rule 2: TS_OFFSET numers for are branch and jump instructions are included
+//   Rule 3: Positions immediately after jump instructions (jump, branchnil, branchif, branchunless, opt_case_dispatch, leave) are included
+static VALUE
+llrb_basic_block_starts(const struct rb_iseq_constant_body *body)
+{
+  // TODO: No need to check leave? leave is always in the end?
+
+  // Rule 1
+  VALUE starts = rb_ary_new_capa(1); // Maybe GCed. Freeing this causes Bus Error...
+  rb_ary_push(starts, INT2FIX(0));
+
+  for (unsigned int i = 0; i < body->iseq_size;) {
+    int insn = rb_vm_insn_addr2insn((void *)body->iseq_encoded[i]);
+
+    // Rule 2
+    switch (insn) {
+      case YARVINSN_branchif:
+      case YARVINSN_branchunless:
+      case YARVINSN_branchnil:
+      case YARVINSN_jump: {
+        VALUE op = body->iseq_encoded[i+1];
+        rb_ary_push(starts, INT2FIX(i+insn_len(insn)+op));
+        break;
+      }
+      //case YARVINSN_opt_case_dispatch:
+    }
+
+    // Rule 3
+    switch (insn) {
+      case YARVINSN_branchif:
+      case YARVINSN_branchunless:
+      case YARVINSN_branchnil:
+      case YARVINSN_jump:
+      case YARVINSN_throw:
+        if (i+insn_len(insn) < body->iseq_size) {
+          rb_ary_push(starts, INT2FIX(i+insn_len(insn)));
+        }
+        break;
+      //case YARVINSN_opt_case_dispatch:
+    }
+
+    i += insn_len(insn);
+  }
+  starts = rb_ary_sort_bang(starts);
+  rb_funcall(starts, rb_intern("uniq!"), 0);
+  return starts;
+}
+
+static unsigned int
+llrb_find_block_end(const struct rb_iseq_constant_body *body, unsigned int start, VALUE starts)
+{
+  unsigned int i = start;
+  while (i < body->iseq_size) {
+    int insn = rb_vm_insn_addr2insn((void *)body->iseq_encoded[i]);
+    unsigned int next_i = i + insn_len(insn);
+
+    // If next insn or end of iseq is found, it's not a block end.
+    if (RTEST(rb_ary_includes(starts, INT2FIX(next_i)))
+        || next_i == body->iseq_size) {
+      break;
+    }
+    i = next_i;
+  }
+  return i;
+}
+
+static void
+llrb_create_basic_blocks(const struct rb_iseq_constant_body *body, struct llrb_cfg *cfg)
+{
+  VALUE starts = llrb_basic_block_starts(body);
+  cfg->size = RARRAY_LEN(starts);
+  cfg->blocks = (struct llrb_basic_block *)xmalloc(cfg->size * sizeof(struct llrb_basic_block)); // freed in llrb_destruct_cfg
+
+  for (unsigned int i = 0; i < RARRAY_LEN(starts); i++) {
+    unsigned int start = (unsigned int)FIX2INT(RARRAY_AREF(starts, i));
+    cfg->blocks[i] = (struct llrb_basic_block){
+      .start = start,
+      .end = llrb_find_block_end(body, start, starts),
+      .incoming_size = 0,
+      .incoming_starts = 0,
+      .traversed = false,
+    };
+  }
+  RB_GC_GUARD(starts);
+}
+
+static void
+llrb_push_incoming_start(struct llrb_basic_block *block, unsigned int start)
+{
+  block->incoming_size++;
+  if (block->incoming_size == 1) {
+    block->incoming_starts = (unsigned int *)xmalloc(sizeof(unsigned int)); // freed in llrb_destruct_cfg
+  } else {
+    block->incoming_starts = (unsigned int *)xrealloc(
+        block->incoming_starts, block->incoming_size * sizeof(unsigned int)); // freed in llrb_destruct_cfg
+  }
+  block->incoming_starts[block->incoming_size-1] = start;
+}
+
+static struct llrb_basic_block *
+llrb_find_block(struct llrb_cfg *cfg, unsigned int start)
+{
+  for (unsigned int i = 0; i < cfg->size; i++) {
+    struct llrb_basic_block *block = cfg->blocks + i;
+    if (block->start == start) return block;
+  }
+  rb_raise(rb_eParseError, "BasicBlock (start = %d) was not found in llrb_find_block", start);
+}
+
+static void
+llrb_set_incoming_blocks_by(const struct rb_iseq_constant_body *body, struct llrb_cfg *cfg, struct llrb_basic_block *block)
+{
+  if (block->traversed) return;
+  block->traversed = true;
+
+  struct llrb_basic_block *next_block = 0;
+  struct llrb_basic_block *last_block = cfg->blocks + (cfg->size-1);
+  if (block < last_block) next_block = block + 1;
+
+  // TODO: No need to check leave? leave is always in the end?
+  int end_insn = rb_vm_insn_addr2insn((void *)body->iseq_encoded[block->end]);
+  switch (end_insn) {
+    case YARVINSN_branchnil:
+    case YARVINSN_branchif:
+    case YARVINSN_branchunless: {
+      VALUE offset = (rb_num_t)body->iseq_encoded[block->end+1];
+      struct llrb_basic_block *dest_block = llrb_find_block(cfg, block->end + insn_len(end_insn) + offset);
+      llrb_push_incoming_start(dest_block, block->start);
+      llrb_set_incoming_blocks_by(body, cfg, dest_block);
+
+      if (next_block) {
+        llrb_push_incoming_start(next_block, block->start);
+        llrb_set_incoming_blocks_by(body, cfg, next_block);
+      }
+      break;
+    }
+    case YARVINSN_jump: {
+      VALUE offset = (rb_num_t)body->iseq_encoded[block->end+1];
+      struct llrb_basic_block *dest_block = llrb_find_block(cfg, block->end + insn_len(end_insn) + offset);
+      llrb_push_incoming_start(dest_block, block->start);
+      llrb_set_incoming_blocks_by(body, cfg, dest_block);
+      break;
+    }
+    case YARVINSN_throw: // TODO: should be modified when catch table is implemented
+      break; // no next block
+    //case YARVINSN_opt_case_dispatch: // TODO: MUST be modified when opt_case_dispatch is implemented
+    default: {
+      if (next_block) {
+        llrb_push_incoming_start(next_block, block->start);
+        llrb_set_incoming_blocks_by(body, cfg, next_block);
+      }
+      break;
+    }
+  }
+}
+
+// To prevent from creating incoming block from unreachable basic block, this does not loop cfg's basic blocks
+// but traverse insns instead. This may be unnecessary after catch table is implemented...
+static void
+llrb_set_incoming_blocks(const struct rb_iseq_constant_body *body, struct llrb_cfg *cfg)
+{
+  llrb_set_incoming_blocks_by(body, cfg, cfg->blocks);
+}
+
+void
+llrb_parse_iseq(const struct rb_iseq_constant_body *body, struct llrb_cfg *cfg)
+{
+  llrb_create_basic_blocks(body, cfg);
+  llrb_set_incoming_blocks(body, cfg);
+  if (0) llrb_dump_cfg(body, cfg);
+}
+
+void
+Init_parser(VALUE rb_mJIT)
+{
+  rb_eParseError = rb_define_class_under(rb_mJIT, "ParseError", rb_eStandardError);
+}

data/ext/llrb/profiler.c

@@ -0,0 +1,336 @@
+#include <stdbool.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <pthread.h>
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "cruby.h"
+
+#define LLRB_PROFILE_INTERVAL_USEC 1000
+#define LLRB_COMPILE_INTERVAL_TIMES 200
+#define LLRB_ENABLE_DEBUG 0
+
+struct llrb_sample {
+  size_t total_calls; // Total count of stack-top occurrence
+  bool compiled;
+  const rb_callable_method_entry_t *cme;
+};
+
+static struct {
+  bool running;
+  size_t profile_times;
+  st_table *sample_by_iseq; // { iseq => llrb_sample }
+} llrb_profiler;
+
+static VALUE gc_hook;
+
+void
+llrb_dump_iseq(const rb_iseq_t *iseq)
+{
+  if (!iseq) return;
+
+  st_data_t val;
+  st_lookup(llrb_profiler.sample_by_iseq, (st_data_t)iseq, &val);
+
+  struct llrb_sample *sample = (struct llrb_sample *)val;
+  if (!sample) return;
+  const rb_callable_method_entry_t *cme = sample->cme;
+
+  fprintf(stderr, "%3ld: ", sample->total_calls);
+  fprintf(stderr, "[size=%3d] ", iseq->body->iseq_size);
+  switch (iseq->body->type) {
+    case ISEQ_TYPE_METHOD:
+      fprintf(stderr,"ISEQ_TYPE_METHOD:");
+      break;
+    case ISEQ_TYPE_CLASS:
+      fprintf(stderr,"ISEQ_TYPE_CLASS:");
+      break;
+    case ISEQ_TYPE_BLOCK:
+      fprintf(stderr,"ISEQ_TYPE_BLOCK:");
+      break;
+    case ISEQ_TYPE_EVAL:
+      fprintf(stderr,"ISEQ_TYPE_EVAL:");
+      break;
+    case ISEQ_TYPE_MAIN:
+      fprintf(stderr,"ISEQ_TYPE_MAIN:");
+      break;
+    case ISEQ_TYPE_TOP:
+      fprintf(stderr,"ISEQ_TYPE_TOP:");
+      break;
+    case ISEQ_TYPE_RESCUE:
+      fprintf(stderr,"ISEQ_TYPE_RESCUE:");
+      break;
+    case ISEQ_TYPE_ENSURE:
+      fprintf(stderr,"ISEQ_TYPE_ENSURE:");
+      break;
+    case ISEQ_TYPE_DEFINED_GUARD:
+      fprintf(stderr,"ISEQ_TYPE_DEFINED_GUARD:");
+      break;
+    default:
+      fprintf(stderr,"default:");
+      break;
+  }
+
+  if (cme && cme->def->type == VM_METHOD_TYPE_ISEQ) {
+    VALUE name = rb_profile_frame_full_label((VALUE)cme);
+    fprintf(stderr, " %s", RSTRING_PTR(name));
+  }
+}
+
+static struct llrb_sample *
+llrb_sample_for(const rb_iseq_t *iseq, const rb_control_frame_t *cfp)
+{
+  st_data_t key = (st_data_t)iseq, val = 0;
+  struct llrb_sample *sample;
+
+  if (st_lookup(llrb_profiler.sample_by_iseq, key, &val)) {
+    sample = (struct llrb_sample *)val;
+  } else {
+    sample = ALLOC_N(struct llrb_sample, 1); // Not freed
+    *sample = (struct llrb_sample){
+      .total_calls = 0,
+      .compiled = false,
+      .cme = rb_vm_frame_method_entry(cfp),
+    };
+    val = (st_data_t)sample;
+    st_insert(llrb_profiler.sample_by_iseq, key, val);
+  }
+
+  return sample;
+}
+
+// Profile only stack top.
+static void
+llrb_profile_frame()
+{
+  rb_thread_t *th = GET_THREAD();
+  rb_control_frame_t *cfp = th->cfp;
+
+  if (cfp->iseq) {
+    struct llrb_sample *sample = llrb_sample_for(cfp->iseq, cfp);
+    sample->total_calls++;
+  }
+  cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+
+  llrb_profiler.profile_times++;
+}
+
+struct llrb_compile_target {
+  const rb_iseq_t *iseq;
+  struct llrb_sample* sample;
+};
+
+static int
+llrb_search_compile_target_i(st_data_t key, st_data_t val, st_data_t arg)
+{
+  struct llrb_compile_target *target = (struct llrb_compile_target *)arg;
+  const rb_iseq_t *iseq = (const rb_iseq_t *)key;
+  struct llrb_sample *sample = (struct llrb_sample *)val;
+
+  if (sample->compiled) return ST_CONTINUE;
+
+  switch (iseq->body->type) {
+    case ISEQ_TYPE_METHOD:
+    case ISEQ_TYPE_BLOCK:
+    case ISEQ_TYPE_MAIN:
+      if (!target->iseq && !target->sample) {
+        target->iseq = iseq;
+        target->sample = sample;
+      }
+      if (sample->total_calls > target->sample->total_calls) {
+        target->iseq = iseq;
+        target->sample = sample;
+      }
+      break;
+    default:
+      break;
+  }
+
+  return ST_CONTINUE;
+}
+
+// Return METHOD or BLOCK iseq which is called the most
+static const rb_iseq_t *
+llrb_search_compile_target()
+{
+  struct llrb_compile_target target = (struct llrb_compile_target){
+    .sample = 0,
+    .iseq = 0,
+  };
+  st_foreach(llrb_profiler.sample_by_iseq, llrb_search_compile_target_i, (st_data_t)&target);
+
+  if (target.sample) {
+    target.sample->compiled = true;
+  }
+  return target.iseq;
+}
+
+static VALUE
+llrb_compile_error_handler(RB_UNUSED_VAR(VALUE nil), VALUE e)
+{
+  fprintf(stderr, "%s\n", RSTRING_PTR(rb_inspect(e)));
+  return Qnil;
+}
+
+// Compile iseq with compile error suppressed.
+static VALUE
+llrb_safe_compile_iseq(const rb_iseq_t *iseq)
+{
+  extern VALUE llrb_compile_iseq_to_method(const rb_iseq_t *iseq);
+  return rb_rescue(llrb_compile_iseq_to_method, (VALUE)iseq,
+      llrb_compile_error_handler, Qnil);
+}
+
+static void
+llrb_job_handler(void *data)
+{
+  static int in_job_handler = 0;
+  if (in_job_handler) return;
+  if (!llrb_profiler.running) return;
+
+  in_job_handler++;
+  llrb_profile_frame();
+
+  if (llrb_profiler.profile_times % LLRB_COMPILE_INTERVAL_TIMES == 0) {
+    const rb_iseq_t *iseq = llrb_search_compile_target();
+    if (iseq) {
+      if (LLRB_ENABLE_DEBUG) {
+        llrb_dump_iseq(iseq);
+        fprintf(stderr, " => ");
+      }
+
+      VALUE result = llrb_safe_compile_iseq(iseq);
+      if (LLRB_ENABLE_DEBUG) {
+        switch (result) {
+          case Qtrue:
+            fprintf(stderr, "success!");
+            break;
+          case Qfalse:
+            fprintf(stderr, "not compiled");
+            break;
+          case Qnil:
+            fprintf(stderr, "COMPILE ERROR");
+            break;
+          default:
+            fprintf(stderr, "???");
+            break;
+        }
+        fprintf(stderr, "\n");
+      }
+    }
+  }
+  in_job_handler--;
+}
+
+static void
+llrb_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
+{
+  if (GET_VM()->running && !rb_during_gc()) {
+    rb_postponed_job_register_one(0, llrb_job_handler, 0);
+  }
+}
+
+static VALUE
+rb_jit_start(RB_UNUSED_VAR(VALUE self))
+{
+  struct sigaction sa;
+  struct itimerval timer;
+
+  if (llrb_profiler.running) return Qfalse;
+  if (!llrb_profiler.sample_by_iseq) {
+    llrb_profiler.sample_by_iseq = st_init_numtable();
+  }
+
+  sa.sa_sigaction = llrb_signal_handler;
+  sa.sa_flags = SA_RESTART | SA_SIGINFO;
+  sigemptyset(&sa.sa_mask);
+  sigaction(SIGPROF, &sa, NULL);
+
+  timer.it_interval.tv_sec = 0;
+  timer.it_interval.tv_usec = LLRB_PROFILE_INTERVAL_USEC;
+  timer.it_value = timer.it_interval;
+  setitimer(ITIMER_PROF, &timer, 0);
+
+  llrb_profiler.running = true;
+  return Qtrue;
+}
+
+static VALUE
+rb_jit_stop(RB_UNUSED_VAR(VALUE self))
+{
+  struct sigaction sa;
+  struct itimerval timer;
+
+  if (!llrb_profiler.running) return Qfalse;
+  llrb_profiler.running = false;
+
+	memset(&timer, 0, sizeof(timer));
+	setitimer(ITIMER_PROF, &timer, 0);
+
+	sa.sa_handler = SIG_IGN;
+	sa.sa_flags = SA_RESTART;
+	sigemptyset(&sa.sa_mask);
+	sigaction(SIGPROF, &sa, NULL);
+
+  return Qtrue;
+}
+
+static int
+llrb_gc_mark_i(st_data_t key, st_data_t val, st_data_t arg)
+{
+  VALUE frame = (VALUE)key;
+  rb_gc_mark(frame);
+  return ST_CONTINUE;
+}
+
+static void
+llrb_gc_mark(void *data)
+{
+  if (llrb_profiler.sample_by_iseq) {
+    st_foreach(llrb_profiler.sample_by_iseq, llrb_gc_mark_i, 0);
+  }
+}
+
+static void
+llrb_atfork_prepare(void)
+{
+  struct itimerval timer;
+  if (llrb_profiler.running) {
+    memset(&timer, 0, sizeof(timer));
+    setitimer(ITIMER_PROF, &timer, 0);
+  }
+}
+
+static void
+llrb_atfork_parent(void)
+{
+  struct itimerval timer;
+  if (llrb_profiler.running) {
+    timer.it_interval.tv_sec = 0;
+    timer.it_interval.tv_usec = LLRB_PROFILE_INTERVAL_USEC;
+    timer.it_value = timer.it_interval;
+    setitimer(ITIMER_PROF, &timer, 0);
+  }
+}
+
+static void
+llrb_atfork_child(void)
+{
+  rb_jit_stop(Qnil);
+}
+
+void
+Init_profiler(VALUE rb_mJIT)
+{
+  rb_define_singleton_method(rb_mJIT, "start_internal", RUBY_METHOD_FUNC(rb_jit_start), 0);
+  rb_define_singleton_method(rb_mJIT, "stop", RUBY_METHOD_FUNC(rb_jit_stop), 0);
+
+  llrb_profiler.running = false;
+  llrb_profiler.profile_times = 0;
+  llrb_profiler.sample_by_iseq = 0;
+
+  gc_hook = Data_Wrap_Struct(rb_cObject, llrb_gc_mark, NULL, &llrb_profiler);
+  rb_global_variable(&gc_hook);
+
+  pthread_atfork(llrb_atfork_prepare, llrb_atfork_parent, llrb_atfork_child);
+}