cast_off 0.2.0

data/ext/cast_off/ruby_source/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/cast_off/ruby_source/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/lib/cast_off.rb

@@ -0,0 +1,15 @@
+require 'cast_off.so'
+require 'cast_off/util'
+require 'cast_off/suggestion'
+require 'cast_off/compile/dependency'
+require 'cast_off/compile/method_information'
+require 'cast_off/compile/configuration'
+require 'cast_off/compile/code_manager'
+require 'cast_off/compile'
+
+module CastOff
+  extend CastOff::Util
+  extend CastOff::Compiler
+end
+CastOff.clear_settings()
+

data/lib/cast_off/compile.rb

@@ -0,0 +1,629 @@
+# coding=utf-8
+
+module CastOff
+  module Compiler
+    include CastOff::Util
+
+    DefaultSuggestionIO = Object.new
+    DefaultSuggestionIO.extend(CastOff::Util)
+    def DefaultSuggestionIO.puts(*msg)
+      vlog(msg)
+    end
+    @@suggestion_io = DefaultSuggestionIO
+    def set_suggestion_io(io)
+      @@suggestion_io = io
+    end
+
+    def verbose(b)
+      CastOff::Util.set_verbose_mode(b)
+    end
+
+    def clear()
+      CodeManager.clear()
+    end
+
+    @@blacklist = [
+    ]
+
+    @@autoload_proc = nil
+    def autoload()
+      return false if autocompile_running?
+      if autoload_running?
+        @@autoload_proc.call()
+        return true 
+      end
+      return true if load()
+
+      compiled = nil
+      @@autoload_proc = lambda {
+        compiled = CodeManager.load_autocompiled() unless compiled
+        return false unless compiled
+        fin = __load(compiled)
+        hook_class_definition_end(nil) if fin
+        fin
+      }
+      hook_class_definition_end(@@autoload_proc)
+      true
+    end
+
+    def load(force = false)
+      return @@autoload_proc.call() if autoload_running? && !force
+      compiled = CodeManager.load_autocompiled()
+      return false unless compiled
+      __load(compiled)
+    end
+
+    @@compilation_threshold = 100
+    def compilation_threshold=(num)
+      raise(ArgumentError.new("first argument should be Integer")) unless num.is_a?(Integer)
+      raise(ArgumentError.new("threshold should be more than 0")) unless num >= 0
+      @@compilation_threshold = num
+    end
+
+    @@autocompile_proc = nil
+    @@compile_auto_incremental = true
+    def autocompile()
+      return false if autoload_running?
+      return true if autocompile_running?
+      class_table = {}
+      bind_table = {}
+      location_table = {}
+      cinfo_table = {}
+      compiled = []
+      @@autocompile_proc = lambda {|event, file, line, mid, bind, klass, cinfo|
+        return unless file
+        return if line < 0
+        return if event != 'call'
+        return if file =~ /\(/
+
+        # TODO should handle singleton class
+
+        # trace method invocation count
+        method_table = class_table[klass]
+        unless method_table
+          method_table = Hash.new(0) 
+          class_table[klass] = method_table
+        end
+        count = (method_table[mid] += 1)
+        if count == 1
+          bind_table[[klass, mid]] = bind
+          location_table[[klass, mid]] = [File.expand_path(file), line]
+        end
+        if cinfo
+          table = (cinfo_table[[klass, mid]] ||= {})
+          table[cinfo] = true
+        end
+        if count == @@compilation_threshold && @@compile_auto_incremental
+          compiled << __autocompile(klass, mid, bind_table, location_table, compiled.size)
+        end
+      }
+      hook_method_invocation(@@autocompile_proc)
+      at_exit do
+        hook_method_invocation(nil) # clear trace
+        unless @@compile_auto_incremental
+          targets = []
+          class_table.each do |klass, method_table|
+            method_table.each do |mid, count|
+              next unless count >= @@compilation_threshold
+              targets << [klass, mid, count]
+            end
+          end
+          targets = sort_targets(targets, cinfo_table)
+          targets.each_with_index do |(klass, mid, count), index|
+            dlog("#{count}: #{klass} #{mid}")
+            compiled << __autocompile(klass, mid, bind_table, location_table, index)
+          end
+        end
+        compiled.compact!
+        CodeManager.dump_auto_compiled(compiled)
+      end
+      true
+    end
+
+    def compile_instance_methods(klass, bind = nil, skip = [])
+      raise ArgumentError.new("first argument should be Class") unless klass.instance_of?(Class)
+      raise ArgumentError.new("second argument should be Binding") unless !bind || bind.instance_of?(Binding)
+      logger = self
+      klass.class_eval do
+        instance_methods(false).each_with_index do |mid, idx|
+          next if skip.include?(mid)
+          args = [klass, mid, bind]
+          begin
+            CastOff.compile(*args.compact())
+            logger.vlog("#{idx}: compile #{mid}")
+          rescue UnsupportedError => e
+            logger.vlog("#{idx}: failed to compile #{self}##{mid} (#{e.message})")
+          end
+        end
+      end
+    end
+
+    @@original_instance_method_iseq = {}
+    def delete_original_instance_method_iseq(target, mid)
+      t = override_target(target, mid)
+      @@original_instance_method_iseq.delete([t, mid])
+    end
+
+    def compile(target, mid, bind_or_typemap = nil, typemap = nil)
+      case target
+      when Class, Module
+        # ok
+      else
+        raise(ArgumentError.new("first argument should be Class or Module"))
+      end
+      mid, bind, typemap = parse_arguments(mid, bind_or_typemap, typemap)
+      t = override_target(target, mid)
+      iseq = @@original_instance_method_iseq[[t, mid]] || get_iseq(target, mid, false)
+      manager, configuration, suggestion = compile_iseq(iseq, mid, typemap, false, bind)
+      manager.compilation_target_is_a(t, mid, false)
+      set_direct_call(target, mid, target.instance_of?(Class) ? :class : :module, manager, configuration)
+      load_binary(manager, configuration, suggestion, iseq, bind)
+      t = override_target(target, mid)
+      dlog("override target of #{target}##{mid} is #{t}")
+      __send__("register_method_#{manager.signiture}", t)
+      @@original_instance_method_iseq[[t, mid]] = iseq
+      @@manager_table[manager.signiture] = manager
+      true
+    end
+
+    @@original_singleton_method_iseq = {}
+    def delete_original_singleton_method_iseq(obj, mid)
+      @@original_singleton_method_iseq.delete([obj, mid])
+    end
+
+    def compile_singleton_method(obj, mid, bind_or_typemap = nil, typemap = nil)
+      mid, bind, typemap = parse_arguments(mid, bind_or_typemap, typemap)
+      iseq = @@original_singleton_method_iseq[[obj, mid]] || get_iseq(obj, mid, true)
+      manager, configuration, suggestion = compile_iseq(iseq, mid, typemap, false, bind)
+      manager.compilation_target_is_a(obj, mid, true)
+      set_direct_call(obj, mid, :singleton, manager, configuration)
+      load_binary(manager, configuration, suggestion, iseq, bind)
+      __send__("register_singleton_method_#{manager.signiture}", obj)
+      @@original_singleton_method_iseq[[obj, mid]] = iseq
+      @@manager_table[manager.signiture] = manager
+      true
+    end
+
+    @@loaded_binary = {}
+    def execute(typemap = nil, &block)
+      raise(ArgumentError.new('no block given')) unless block
+      iseq = get_iseq_from_block(block)
+      key = iseq.__id__
+      if !@@loaded_binary[key]
+        bind = block.binding
+        manager, configuration, suggestion = compile_iseq(iseq, nil, typemap, false, bind)
+        load_binary(manager, configuration, suggestion, iseq, bind)
+        @@loaded_binary[key] = manager.signiture
+      end
+      sign = @@loaded_binary[key]
+      recv = get_caller()
+      __send__(sign, recv)
+    end
+
+    private
+
+    def execute_no_hook()
+      bug() unless block_given?
+      begin
+        hook_m = hook_method_invocation(nil)
+        hook_c = hook_class_definition_end(nil)
+        yield
+      ensure
+        if hook_m
+          bug() unless autocompile_running?
+          hook_method_invocation(@@autocompile_proc)
+        end
+        if hook_c
+          bug() unless autoload_running?
+          hook_class_definition_end(@@autoload_proc)
+        end
+      end
+    end
+
+    def compile_iseq(iseq, mid, typemap, is_proc, bind)
+      filepath, line_no = *iseq.to_a.slice(7, 2)
+      raise(UnsupportedError.new(<<-EOS)) unless filepath && File.exist?(filepath)
+
+Currently, CastOff cannot compile method which source file is not exist.
+#{filepath.nil? ? 'nil' : filepath} is not exist.
+      EOS
+      manager = CodeManager.new(filepath, line_no)
+      suggestion = Suggestion.new(iseq, @@suggestion_io)
+      configuration = nil
+      manager.do_atomically() do
+        execute_no_hook() do
+          configuration = __compile(iseq, manager, typemap || {}, mid, is_proc, bind, suggestion)
+        end
+      end
+      bug() unless configuration.instance_of?(Configuration)
+      [manager, configuration, suggestion]
+    end
+
+    def parse_arguments(mid, bind_or_typemap, typemap)
+      case mid
+      when Symbol
+        # nothing to do
+      when String
+        mid = mid.intern
+      else
+        raise(ArgumentError.new('method name should be Symbol or String'))
+      end
+      case bind_or_typemap
+      when Binding
+        bind = bind_or_typemap
+      when Hash
+        raise(ArgumentError.new("Invalid arugments")) if typemap
+        bind = nil
+        typemap = bind_or_typemap
+      when NilClass
+        # nothing to do
+        bind = nil
+      else
+        raise(ArgumentError.new("third argument should be Binding or Hash"))
+      end
+      [mid, bind, typemap]
+    end
+
+    def union_base_configuration(conf, manager)
+      if CastOff.use_base_configuration?
+        u = manager.load_base_configuration()
+        unless u
+          bind = conf.bind
+          u = Configuration.new({}, bind ? bind.bind : nil)
+          manager.save_base_configuration(u)
+        end
+        conf.union(u)
+      end
+    end
+
+    @@manager_table = {}
+    def re_compile(signiture, sampling_table)
+      manager = @@manager_table[signiture]
+      return false unless manager
+      bug() unless manager.instance_of?(CodeManager)
+      reciever_result, return_value_result = parse_sampling_table(sampling_table)
+      update_p = update_base_configuration(manager, reciever_result, return_value_result)
+      compilation_target = manager.compilation_target
+      bug() unless compilation_target
+      target = compilation_target.target_object
+      mid = compilation_target.method_id
+      singleton = compilation_target.singleton_method?
+      vlog("re-compile(#{target}#{singleton ? '.' : '#'}#{mid}): update_p = #{update_p}, reciever_result = #{reciever_result}, return_value_result = #{return_value_result}")
+      return false unless update_p
+      ann = manager.load_annotation() || {}
+      bug() unless ann.instance_of?(Hash)
+      manager.version_up()
+      begin
+        __send__(singleton ? 'compile_singleton_method' : 'compile', target, mid, ann)
+      rescue => e
+        vlog("re-compilation failed: #{target}#{singleton ? '.' : '#'}#{mid}")
+      end
+      true
+    end
+
+    class ReCompilation < StandardError; end
+
+    def __compile(iseq, manager, annotation, mid, is_proc, bind, suggestion)
+      if reuse_compiled_binary? && !manager.target_file_updated?
+        # already compiled
+        if CastOff.development? || !CastOff.skip_configuration_check? || manager.last_configuration_enabled_development?
+          conf = Configuration.new(annotation, bind)
+          union_base_configuration(conf, manager)
+          last_conf = manager.load_last_configuration()
+          if last_conf && conf == last_conf
+            dlog("reuse compiled binary")
+            return last_conf
+          end
+        else
+          dlog("reuse compiled binary")
+          last_conf = manager.load_last_configuration()
+          if last_conf
+            return last_conf
+          end
+          conf = Configuration.new(annotation, bind)
+          union_base_configuration(conf, manager)
+        end
+      else
+        conf = Configuration.new(annotation, bind)
+        union_base_configuration(conf, manager)
+      end
+      vlog("use configuration #{conf}")
+
+      require 'cast_off/compile/namespace/uuid'
+      require 'cast_off/compile/namespace/namespace'
+      require 'cast_off/compile/instruction'
+      require 'cast_off/compile/iseq'
+      require 'cast_off/compile/ir/simple_ir'
+      require 'cast_off/compile/ir/operand'
+      require 'cast_off/compile/ir/sub_ir'
+      require 'cast_off/compile/ir/jump_ir'
+      require 'cast_off/compile/ir/param_ir'
+      require 'cast_off/compile/ir/call_ir'
+      require 'cast_off/compile/ir/return_ir'
+      require 'cast_off/compile/ir/guard_ir'
+      require 'cast_off/compile/translator'
+      require 'cast_off/compile/cfg'
+      require 'cast_off/compile/basicblock'
+      require 'cast_off/compile/stack'
+      require 'cast_off/compile/information'
+      conf.validate()
+      bug() unless conf
+      dep = Dependency.new()
+      block_inlining = true
+      while true
+        begin
+          translator = Translator.new(iseq, conf, mid, is_proc, block_inlining, suggestion, dep, manager)
+          c_source = translator.to_c()
+          break
+        rescue ReCompilation
+          bug() unless block_inlining
+          block_inlining = false # FIXME get re-compilation type from exception object
+          dlog("failed to inline block...")
+        end
+      end
+      conf.use_method_frame(!block_inlining)
+      bug() unless c_source
+      translator.suggest()
+      manager.compile_c_source(c_source, conf, dep)
+      manager.save_annotation(annotation)
+      manager.dump_development_mark(conf)
+      conf
+    end
+
+    def __load(compiled)
+      begin
+        compiled.dup.each do |entry|
+          klass, mid, singleton, file, line, bind = entry
+          if @@blacklist.include?(mid)
+            compiled.delete(entry)
+            next
+          end
+          bind = bind.bind if bind
+          entry.pop # release BindingWrapper
+          if singleton
+            iseq = @@original_singleton_method_iseq[[klass, mid]] || get_iseq(klass, mid, true)
+          else
+            t = override_target(klass, mid)
+            iseq = @@original_instance_method_iseq[[t, mid]] || get_iseq(klass, mid, false)
+          end
+          f, l = *iseq.to_a.slice(7, 2)
+          if f == file && l == line
+            begin
+              if singleton
+                CastOff.compile_singleton_method(klass, mid, bind)
+              else
+                CastOff.compile(klass, mid, bind)
+              end
+              vlog("load #{klass}##{mid}")
+            rescue UnsupportedError
+              vlog("unsupported #{klass}##{mid}")
+            end
+          else
+            dlog("iseq.filepath = #{f}, file = #{file}\niseq.line = #{l}, line = #{line}")
+          end
+          compiled.delete(entry)
+        end
+        if compiled.empty?
+          vlog("---------- load finish ----------")
+          true
+        else
+          false
+        end
+      rescue => e
+        vlog("catch exception #{e.class}: #{e}\n#{e.backtrace.join("\n")}")
+        false
+      end
+    end
+
+    def autocompile_running?
+      !!@@autocompile_proc
+    end
+
+    def autoload_running?
+      !!@@autoload_proc
+    end
+
+    def __autocompile(klass, mid, bind_table, location_table, index)
+      return nil unless klass.instance_of?(Class) || klass.instance_of?(Module) # FIXME
+      return nil if klass.name =~ /CastOff/ # ここで弾いておかないと、__compile の require で __load が走る。
+                                            # Namespace のほうはあらかじめ require しておくことで回避。
+                                            # Namespace 以外は CastOff を含むので問題無し。
+      if klass.instance_methods(false).include?(mid) || klass.private_instance_methods(false).include?(mid)
+        singleton = false
+      else
+        return nil unless klass.singleton_methods(false).include?(mid)
+        singleton = true
+      end
+      begin
+        bind = bind_table[[klass, mid]]
+        if singleton
+          CastOff.compile_singleton_method(klass, mid, bind)
+        else
+          CastOff.compile(klass, mid, bind)
+        end
+        location = location_table[[klass, mid]]
+        begin
+          Marshal.dump(klass)
+        rescue TypeError => e
+          vlog("failed to marshal dump #{klass}: #{e.message}")
+          return nil
+        end
+        vlog("#{index}: compile #{klass}#{singleton ? '.' : '#'}#{mid}")
+        [klass, mid, singleton] + location + [Configuration::BindingWrapper.new(bind)] # klass, mid, file, line, binding
+      rescue UnsupportedError => e
+        vlog("#{index}: failed to compile #{klass}#{singleton ? '.' : '#'}#{mid} (#{e.message})")
+        nil
+      end
+    end
+
+    def __sort_targets(entry, targets, cinfo_table)
+      result = []
+      unless cinfo_table[entry]
+        result << entry
+        dlog("<< #{entry}: nil")
+        return result # FIXME
+      end
+
+      targets.each do |te|
+        bug() if entry == te
+        next unless cinfo_table[te]
+        next unless cinfo_table[te].keys.include?(entry) # entry calls te
+        next if cinfo_table[entry].keys.include?(te) # cycle
+        targets.delete(te)
+        result += __sort_targets(te, targets, cinfo_table)
+      end
+      dlog("<< #{entry}: #{cinfo_table[entry].keys}")
+      result << entry
+      result
+    end
+
+    def sort_targets(targets, cinfo_table)
+      result = []
+      counts = {}
+      targets = targets.sort{|v0, v1| v1.last <=> v0.last}
+      targets.each{|klass, mid, count| counts[[klass, mid]] = count}
+      targets = targets.map{|klass, mid, count| [klass, mid]}
+      until targets.empty?
+        entry = targets.shift
+        result += __sort_targets(entry, targets, cinfo_table)
+      end
+      result.map!{|entry| entry + [counts[entry]]}
+      bug() unless result.size == counts.size
+      result
+    end
+
+    def parse_sampling_table(sampling_table)
+      reciever_result = {}
+      return_value_result = {}
+      sampling_table.each do |(key0, val0)|
+        case key0
+        when Symbol
+          bug() unless val0.is_a?(Hash)
+          reciever_result[key0] = val0.keys
+        when Class
+          bug() unless val0.is_a?(Hash)
+          newval = {}
+          val0.each do |(key1, val1)|
+            bug() unless key1.is_a?(Symbol)
+            bug() unless val1.is_a?(Hash)
+            newval[key1] = val1.keys
+          end
+          return_value_result[key0] = newval
+        else
+          bug("#{key0}, #{key0.class}")
+        end
+      end
+      bug() unless (reciever_result.keys & return_value_result.keys).empty?
+      [reciever_result, return_value_result]
+    end
+
+    def update_configuration(configuration, reciever_result, return_value_result)
+      update_p  = false
+      update_p |= configuration.update_variable_configuration(reciever_result)
+      update_p |= configuration.update_return_value_configuration(return_value_result)
+      update_p
+    end
+
+    def update_base_configuration(manager, reciever_result, return_value_result)
+      base_configuration = manager.load_base_configuration()
+      unless base_configuration
+        last = manager.load_last_configuration()
+        bind = last ? (last.bind ? last.bind.bind : nil) : nil
+               base_configuration = Configuration.new({}, bind)
+      end
+      bug() unless base_configuration.instance_of?(Configuration)
+      update_p = update_configuration(base_configuration, reciever_result, return_value_result)
+      return false unless update_p
+      manager.save_base_configuration(base_configuration)
+      true
+    end
+
+    def set_sampling_table(suggestion, manager, configuration)
+      if CastOff.development?
+        h = Hash.new()
+        __send__("register_sampling_table_#{manager.signiture}", h)
+        suggestion.add_handler do
+          reciever_result, return_value_result = parse_sampling_table(h)
+          update_base_configuration(manager, reciever_result, return_value_result)
+          if reciever_result.size > 0
+            msg = "These are unresolved local variables sampling results."
+            ary = []
+            reciever_result.each do |key0, val0|
+              bug() unless key0.is_a?(Symbol)
+              bug() unless val0.is_a?(Array)
+              val0.each do |t|
+                ary << [key0.to_s, t.to_s]
+              end
+            end
+            suggestion.add_suggestion(msg, ["<Variable>", "<SamplingResultClass>"], ary)
+          end
+          if return_value_result.size > 0
+            msg = "These are unresolved method return values sampling results."
+            ary = []
+            return_value_result.each do |key0, val0|
+              bug() unless key0.is_a?(Class)
+              bug() unless val0.is_a?(Hash)
+              val0.each do |(mid, types)|
+                types.each{|t| ary << ["#{key0}##{mid}", t.to_s]}
+              end
+            end
+            suggestion.add_suggestion(msg, ["<Method>", "<SamplingResultClass>"], ary)
+          end
+
+          bug() unless configuration
+          s0 = configuration.to_s
+          update_p = update_configuration(configuration, reciever_result, return_value_result)
+          s1 = configuration.to_s
+          configuration.compact()
+          s2 = configuration.to_s
+          if update_p
+            bug() if s0 == s1
+          else
+            bug() if s0 != s1
+          end
+          if update_p
+            suggestion.add_suggestion("You specify following type map to CastOff", ["Your Annotation"], [[s0]], false)
+            suggestion.add_suggestion("CastOff suggests you to use following type map", ["CastOff Suggestion"], [[s2]], false)
+          end
+        end
+      end
+    end
+
+    def set_direct_call(obj, mid, type, manager, configuration)
+      bug() unless configuration
+      return if configuration.use_method_frame?
+      CastOff.should_be_call_directly(obj, mid, type)
+    end
+
+    def hook_method_override(manager, configuration, function_pointer_initializer)
+      bug() unless configuration
+      return unless configuration.alert_override?
+      dep = manager.load_dependency()
+      dep.check(configuration)
+      dep.hook(function_pointer_initializer)
+    end
+
+    def load_binary(manager, configuration, suggestion, iseq, bind)
+      execute_no_hook() do
+        so = manager.compiled_binary
+        sign = manager.signiture
+        bug("#{so} is not exist") unless File.exist?(so)
+        load_compiled_file(so)
+        function_pointer_initializer = "initialize_fptr_#{sign}".intern
+        hook_method_override(manager, configuration, function_pointer_initializer)
+        __send__("register_iseq_#{sign}", iseq)
+        __send__("register_ifunc_#{sign}")
+        set_sampling_table(suggestion, manager, configuration)
+        suggestion.dump_at_exit()
+        __send__(function_pointer_initializer)
+        __send__("prefetch_constants_#{sign}", bind) if bind
+      end
+    end
+
+    def capture_instruction()
+      a = [] # setlocal
+      a[0] = a # getlocal, setn, pop, leave
+    end
+  end
+end
+