cast_off 0.3.1 → 0.3.2

data/cast_off.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name		      = "cast_off"
-  spec.version		      = "0.3.1"
+  spec.version		      = "0.3.2"
   spec.platform		      = Gem::Platform::RUBY
   spec.summary		      = "Performance improvement tool for Ruby1.9.3"
   spec.description	      = <<-EOS

data/ext/cast_off/cast_off.c.rb

@@ -811,9 +811,14 @@ static VALUE cast_off_class_wrapper_each_method_search_target(VALUE self, VALUE
       rb_yield(module);
     } else if (TYPE(klass) == T_CLASS) {
       if (FL_TEST(klass, FL_SINGLETON)) {
-        rb_bug("cast_off_class_wrapper_each_method_search_target: should not be reached(2)");
+        VALUE __klass = rb_iv_get(klass, "__attached__");
+        if (rb_class_of(__klass) != klass) {
+          rb_bug("cast_off_class_wrapper_each_method_search_target: should not be reached(2)");
+        }
+        rb_yield(rb_funcall(rb_cCastOffClassWrapper, rb_intern("new"), 2, __klass, Qfalse));
+      } else {
+        rb_yield(klass);
       }
-      rb_yield(klass);
     } else {
       rb_bug("cast_off_class_wrapper_each_method_search_target: should not be reached(3)");
     }
@@ -1239,27 +1244,14 @@ static VALUE caller_info(rb_thread_t *th)
 
 static void cast_off_method_invocation_handler(rb_event_flag_t event, VALUE proc, VALUE self, ID id, VALUE klass)
 {
-  VALUE thval = rb_thread_current();
-  rb_thread_t *th = DATA_PTR(thval);
-  const char *srcfile = rb_sourcefile();
-  VALUE filename = srcfile ? rb_str_new2(srcfile) : Qnil;
+  const char *srcfile;
+  VALUE filename, need_binding;
   VALUE argv[6];
-  int line = rb_sourceline();
-  static VALUE ev = 0;
-
-  if (!ev) {
-    ev = rb_str_new2("call");
-    rb_gc_register_mark_object(ev);
-  }
+  int line;
 
   if (klass == 0) {
     rb_frame_method_id_and_class(&id, &klass);
   }
-
-  if (id == ID_ALLOCATOR) {
-    return;
-  }
-
   if (klass) {
     if (TYPE(klass) == T_ICLASS) {
       klass = RBASIC(klass)->klass;
@@ -1267,16 +1259,36 @@ static void cast_off_method_invocation_handler(rb_event_flag_t event, VALUE proc
       klass = rb_iv_get(klass, "__attached__");
     }
   }
+  if (!klass) return;
 
-  argv[0] = ev;
-  argv[1] = filename;
-  argv[2] = INT2FIX(line);
-  argv[3] = id ? ID2SYM(id) : Qnil;
-  argv[4] = (self && srcfile) ? rb_binding_new() : Qnil;
-  argv[5] = klass ? klass : Qnil;
-  argv[6] = caller_info(th);
+  if (id == ID_ALLOCATOR) {
+    return;
+  }
+  if (!id) return;
+
+  srcfile = rb_sourcefile();
+  if (!srcfile) return;
+  filename = rb_str_new2(srcfile);
 
-  rb_proc_call_with_block(proc, 7, argv, Qnil);
+  line = rb_sourceline();
+  if (line < 0) return;
+
+  argv[0] = filename;
+  argv[1] = INT2FIX(line);
+  argv[2] = ID2SYM(id);
+  argv[3] = Qnil;
+  argv[4] = klass;
+  /* argv[5] = caller_info(th); */
+
+  /* rb_proc_call_with_block(proc, 6, argv, Qnil); */
+  need_binding = rb_proc_call_with_block(proc, 5, argv, Qnil);
+  if (RTEST(need_binding)) {
+    argv[3] = (self && srcfile) ? rb_binding_new() : Qnil;
+    need_binding = rb_proc_call_with_block(proc, 5, argv, Qnil);
+  }
+  if (RTEST(need_binding)) {
+    rb_bug("cast_off_method_invocation_handler: should not be reached");
+  }
 
   return;
 }
@@ -1363,6 +1375,30 @@ VALUE cast_off_singleton_method_added_p(VALUE dummy)
   rb_bug("cast_off_singleton_method_added_p: should not be reached(1)");
 }
 
+static ID id_include, id_extend;
+VALUE cast_off_extend_p(VALUE dummy)
+{
+  VALUE thval = rb_thread_current();
+  rb_thread_t *th = DATA_PTR(thval);
+  rb_control_frame_t *cfp;
+  ID mid;
+
+  cfp = th->cfp; /* this method frame */
+  cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); /* method_added or singleton_method_added frame */
+  if (!cfp->me) {
+    rb_bug("cast_off_extend_p: should not be reached(0)");
+  }
+  mid = cfp->me->called_id;
+  if (mid == id_include) {
+    return Qfalse;
+  }
+  if (mid == id_extend) {
+    return Qtrue;
+  }
+  /* TODO 別名に対応 */
+  rb_bug("cast_off_extend_p: should not be reached(1)");
+}
+
 /* for deoptimization */
 rb_iseq_t *cast_off_Fixnum_times_iseq;
 rb_iseq_t *cast_off_Array_each_iseq;
@@ -1470,10 +1506,13 @@ void Init_cast_off(void)
 
   id_method_added = rb_intern("method_added");
   id_singleton_method_added = rb_intern("singleton_method_added");
+  id_include = rb_intern("include");
+  id_extend = rb_intern("extend");
   id_initialize_copy = rb_intern("initialize_copy");
   id_clone = rb_intern("clone");
   rb_define_singleton_method(rb_cCastOffDependency, "ignore_overridden?", cast_off_ignore_overridden_p, 2);
   rb_define_singleton_method(rb_cCastOffDependency, "singleton_method_added?", cast_off_singleton_method_added_p, 0);
+  rb_define_singleton_method(rb_cCastOffDependency, "extend?", cast_off_extend_p, 0);
 
   rb_define_singleton_method(rb_mCastOffCompiler, "destroy_last_finish", cast_off_destroy_last_finish, 0);
   rb_funcall(rb_mCastOffCompiler, rb_intern("module_eval"), 1, rb_str_new2("def self.vm_exec(); destroy_last_finish() end"));

data/ext/cast_off/generated_c_include/unbox_api.h.rb

@@ -14,15 +14,52 @@ __END__
 #else
 #define CFIX2RFIX(b) LONG2FIX((b))
 #endif
+static inline VALUE CDOUBLE2RINT(double f)
+{
+  if (f > 0.0) f = floor(f);
+  if (f < 0.0) f = ceil(f);
+  return FIXABLE(f) ? LONG2FIX((double)f) : rb_dbl2big(f);
+}
+
 %# arg size, [type0, type1, ...]
-%[['float_float',
+%[['float',
+%  {'-' => 'uminus'},
+%  0,
+%  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
+%  {},
+%  {'VALUE' => 'DBL2NUM', 'double' => ''}],
+% ['float',
+%  {'' => 'to_f'},
+%  0,
+%  {'VALUE' => ''},
+%  {},
+%  {'VALUE' => '', 'double' => 'RFLOAT_VALUE'}],
+% ['float',
+%  {'' => 'to_i'},
+%  0,
+%  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
+%  {},
+%  {'VALUE' => 'CDOUBLE2RINT'}],
+% ['fixnum',
+%  {'-' => 'uminus'},
+%  0,
+%  {'VALUE' => 'FIX2LONG', 'long' => ''},
+%  {},
+%  {'VALUE' => 'CFIX2RFIX', 'long' => ''}],
+% ['fixnum',
+%  {'(double)' => 'to_f'},
+%  0,
+%  {'VALUE' => 'FIX2LONG', 'long' => ''},
+%  {},
+%  {'VALUE' => 'DBL2NUM', 'double' => ''}],
+% ['float_float',
 %  {'+' => 'plus', '-' => 'minus', '*' => 'mult', '/' => 'div'},
 %  1,
 %  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
 %  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
 %  {'VALUE' => 'DBL2NUM', 'double' => ''}],
 % ['float_float',
-%  {'>' => 'gt', '>=' => 'ge', '<' => 'lt', '<=' => 'le'},
+%  {'>' => 'gt', '>=' => 'ge', '<' => 'lt', '<=' => 'le', '==' => 'eq', '==' => 'eqq'},
 %  1,
 %  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
 %  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
@@ -39,12 +76,24 @@ __END__
 %  {'VALUE' => '(double)FIX2LONG', 'long' => ''},
 %  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
 %  {'VALUE' => 'DBL2NUM', 'double' => ''}],
+% ['fixnum_float',
+%  {'>' => 'gt', '>=' => 'ge', '<' => 'lt', '<=' => 'le', '==' => 'eq', '==' => 'eqq'},
+%  1,
+%  {'VALUE' => '(double)FIX2LONG', 'long' => ''},
+%  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
+%  {'VALUE' => 'CBOOL2RBOOL'}],
 % ['float_fixnum',
 %  {'+' => 'plus', '-' => 'minus', '*' => 'mult', '/' => 'div'},
 %  1,
 %  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
 %  {'VALUE' => '(double)FIX2LONG', 'long' => ''},
-%  {'VALUE' => 'DBL2NUM', 'double' => ''}]].each do |(function_name, h, argc, reciever_converter, arguments_converter, return_value_converter)|
+%  {'VALUE' => 'DBL2NUM', 'double' => ''}],
+% ['float_fixnum',
+%  {'>' => 'gt', '>=' => 'ge', '<' => 'lt', '<=' => 'le', '==' => 'eq', '==' => 'eqq'},
+%  1,
+%  {'VALUE' => 'RFLOAT_VALUE', 'double' => ''},
+%  {'VALUE' => '(double)FIX2LONG', 'long' => ''},
+%  {'VALUE' => 'CBOOL2RBOOL'}]].each do |(function_name, h, argc, reciever_converter, arguments_converter, return_value_converter)|
 %  arguments_decls = arguments_converter.keys
 %  reciever_decls  = reciever_converter.keys
 %  return_value_decls  = return_value_converter.keys
@@ -68,7 +117,12 @@ __END__
 static inline <%= return_value %>
 cast_off_inline_<%= function_name %>_<%= name %>_<%= suffix %>(<%= parameter.join(', ') %>)
 {
+%      if argc > 0
   return <%= return_value_converter[return_value] %>(<%= statement.join(" #{operator} ") %>);
+%      else
+%        raise unless statement.size == 1
+  return <%= return_value_converter[return_value] %>(<%= operator %>(<%= statement.first %>));
+%      end
 }
 %    end
 %  end

data/lib/cast_off/compile/cfg.rb

@@ -101,7 +101,7 @@ module CastOff::Compiler
     end
 
     def all_pointer()
-      ptrs = all_pointer_definition().map{|ir| ir.result_variable}.uniq()
+      ptrs = all_ir.map{|ir| ir.variables}.flatten.select{|v| v.is_a?(Pointer)}.uniq()
       bug() if ptrs.find{|p| not p.is_a?(Pointer)}
       ptrs.freeze()
     end
@@ -131,6 +131,9 @@ module CastOff::Compiler
         aliveblock.pre.reject!{|b| deadblocks.include?(b)}
         bug() if aliveblock.next.find{|b| deadblocks.include?(b)}
       end
+      deadblocks.each do |b|
+        b.iseq.delete_labels(b.labels)
+      end
       @blocks = achieved
       @blocks.sort! {|a, b| a.number <=> b.number}
       bug() if @blocks.find{|b| b.pre.empty? && !b.entry_point?}
@@ -239,60 +242,23 @@ module CastOff::Compiler
 
     ### unboxing begin ###
     def unboxing()
-      # 1: mark value which can not unbox
-      # 1: mark value which can unbox
       irs = all_ir()
       irs.each{|ir| ir.unboxing_prelude()}
-      bug() if irs.map{|ir| ir.values }.flatten.find{|v| v.box_unbox_undefined? }
-
-      # 2: propergate value which can not unbox
-      change = true
-      while change
-        change = false
-        @blocks.each do |b|
-          defs = b.information.dup
-          b.irs.each do |ir|
-            change |= ir.propergate_value_which_can_not_unbox(defs)
-            defs.step(ir)
-          end
-        end
-      end
-      bug() if irs.find{|ir| ir.instance_of?(SubIR) && ir.dst.can_not_unbox? != ir.src.can_not_unbox?}
-
-      # 3: propergate value which can unbox
-      change = true
-      while change
-        change = false
-        @blocks.each do |b|
-          defs = b.information.dup
-          b.irs.each do |ir|
-            change |= ir.propergate_unbox_value(defs)
-            defs.step(ir)
-          end
-        end
-      end
-
-      bug() if irs.map{|ir| ir.values }.flatten.find{|v| v.unboxed? && (v.dynamic? || v.types.size != 1)}
-      irs.each do |ir|
-        ir.values.each do |v|
-          next unless v.unboxed?
-        end
-      end
 
-      irs.map{|ir| ir.values}.flatten.each{|v| v.box() unless v.unboxed?}
-      irs.map{|ir| ir.values}.flatten.each{|v| bug() if !v.boxed? && !v.unboxed?}
       change = true
       while change
         change = false
         @blocks.each do |b|
           defs = b.information.dup
           b.irs.each do |ir|
-            change |= ir.propergate_box_value(defs)
+            change |= ir.propergate_boxed_value(defs)
             defs.step(ir)
           end
         end
       end
+      bug() if irs.map{|ir| ir.values }.flatten.find{|v| v.unboxed? && !v.can_unbox?}
 
+      # validation
       @blocks.each do |b|
         defs = b.information.dup
         b.irs.each do |ir|

data/lib/cast_off/compile/configuration.rb

@@ -16,7 +16,9 @@ module Compiler
     class InvalidConfigurationError < StandardError; end
 
     attr_reader :return_value_configuration
+    attr_reader :ignore_configuration_of_return_values
     attr_reader :variable_configuration
+    attr_reader :ignore_configuration_of_variables
     attr_reader :method_information_usage
     attr_reader :option_table_configuration
     attr_reader :bind
@@ -194,13 +196,16 @@ o = Object
           ary.each{|t| bug(t) unless t.is_a?(ClassWrapper)}
         end
       end
+      @ignore_configuration_of_return_values = {}
       @variable_configuration.values.each do |ary|
         ary.each{|t| bug(t) unless t.is_a?(ClassWrapper)}
       end
+      @ignore_configuration_of_variables = {}
       @method_information_usage = []
       @option_table_configuration = {}
       @use_method_frame = false
       OPTION_TABLE.each{|(cvar, val)| @option_table_configuration[cvar] = self.class.class_variable_get(cvar)}
+      prefetch_constant(false) unless @bind
     end
 
     def use_method_frame(bool)
@@ -248,6 +253,12 @@ o = Object
         end
         @variable_configuration[sym] = (dst | src)
       end
+      conf.ignore_configuration_of_variables.each do |(k, v)|
+        bug() unless k.instance_of?(Symbol)
+        bug() unless v == true
+        @ignore_configuration_of_variables[k] = true
+      end
+      __ignore_configuration_of_variables(:union)
 
       conf.return_value_configuration.each do |(cw0, src0)|
         bug() unless src0.instance_of?(Hash)
@@ -264,6 +275,13 @@ o = Object
           dst0[sym] = (dst1 | src1)
         end
       end
+      conf.ignore_configuration_of_return_values.each do |(k, mids)|
+        bug() if mids.find{|m| !m.instance_of?(Symbol)}
+        @ignore_configuration_of_return_values[k] ||= []
+        @ignore_configuration_of_return_values[k] |= mids
+      end
+      __ignore_configuration_of_return_values(:union)
+
       return if @bind
       return unless conf.bind
       bug() unless conf.bind.instance_of?(BindingWrapper)
@@ -272,14 +290,20 @@ o = Object
 
     def update_variable_configuration(update_hash)
       update_p = false
+      updates = []
+      starts  = @variable_configuration.keys
       update_hash.each do |(k, v)|
         bug() unless k.instance_of?(Symbol)
         bug() unless v.instance_of?(Array)
-        next if v.map{|a| a.first }.include?(SingletonClass)
-        # variable annotation
+        if v.map{|a| a.first }.include?(SingletonClass)
+          update_p = true unless @ignore_configuration_of_variables[k]
+          @ignore_configuration_of_variables[k] = true
+        end
+        next if @ignore_configuration_of_variables[k]
+        # annotation of variables
         a0 = v
         a0 = a0.map{|(c, singleton_p)|
-          bug(c) unless c.is_a?(Class)
+          bug(c) unless c.is_a?(Class) || (c.is_a?(Module) && singleton_p)
           bug()  unless c != SingletonClass
           if singleton_p
             wrapper = ClassWrapper.new(c, false)
@@ -290,31 +314,70 @@ o = Object
           wrapper
         }
         a1 = @variable_configuration[k] || []
-        update_p = true unless (a0 - a1).empty?
+        updates << k unless (a0 - a1).empty?
         a1 |= a0
         @variable_configuration[k] = a1
       end
-      update_p
+      deletes = __ignore_configuration_of_variables(:update)
+      inc_p = !(updates - deletes).empty?
+      dec_p = !(starts & deletes).empty?
+      inc_p | dec_p | update_p
     end
 
     def update_return_value_configuration(update_hash)
       update_p = false
+      updates = []
+      starts  = []
+      @return_value_configuration.each do |klass, hash|
+        bug() unless klass.instance_of?(ClassWrapper)
+        bug() unless hash.instance_of?(Hash)
+        hash.keys.each do |mid|
+          bug() unless mid.instance_of?(Symbol)
+          starts << [klass, mid]
+        end
+      end
       bug() unless update_hash.size == 2
       update_hash.each do |(sym, mtbl)|
         bug() unless sym == :singleton_methods || sym == :instance_methods
         bug() unless mtbl.is_a?(Hash)
         mtbl.each do |(k, v)|
-          bug() unless k.instance_of?(Class)
+          bug() unless k.instance_of?(Class) || (k.instance_of?(Module) && sym == :singleton_methods)
           bug() unless v.instance_of?(Hash)
-          next if k == SingletonClass
-          # return value annotation
+          if k == SingletonClass
+            bug() if sym == :singleton_methods
+            ignore_targets = v.keys
+            bug() if ignore_targets.find{|m| !m.instance_of?(Symbol)}
+            @ignore_configuration_of_return_values[SingletonClass] ||= []
+            update_p = true unless (ignore_targets - @ignore_configuration_of_return_values[SingletonClass]).empty?
+            @ignore_configuration_of_return_values[SingletonClass] |= ignore_targets
+            next
+          end
+          # annotation of return values
           h0 = v
           k  = ClassWrapper.new(k, sym == :instance_methods)
           h1 = @return_value_configuration[k] || {}
           h0.each do |(mid, klasses0)|
-            next if klasses0.include?(SingletonClass)
+            ignore_p = false
+            bug() unless klasses0.is_a?(Array)
+            klasses0.each do |(c, singleton_p)|
+              if c == SingletonClass
+                bug() if singleton_p
+                ignore_p = true
+                break
+              end
+            end
+            if ignore_p
+              bug() unless k.instance_of?(ClassWrapper)
+              ignore_targets = (@ignore_configuration_of_return_values[k] ||= [])
+              unless ignore_targets.include?(mid)
+                ignore_targets.push(mid)
+                update_p = true 
+              end
+              next
+            end
+            next if @ignore_configuration_of_return_values[k] && @ignore_configuration_of_return_values[k].include?(mid)
             klasses0 = klasses0.map{|(c, singleton_p)|
-              bug(c) unless c.is_a?(Class)
+              bug(c) unless c.is_a?(Class) || (c.is_a?(Module) && singleton_p)
               bug()  unless c != SingletonClass
               if singleton_p
                 wrapper = ClassWrapper.new(c, false)
@@ -325,14 +388,20 @@ o = Object
               wrapper
             }
             klasses1 = h1[mid] || []
-            update_p = true unless (klasses0 - klasses1).empty?
+            updates |= [[k, mid]] unless (klasses0 - klasses1).empty?
             klasses1 |= klasses0
             h1[mid] = klasses1
           end
           @return_value_configuration[k] = h1
         end
       end
-      update_p
+      deletes = __ignore_configuration_of_return_values(:update)
+      inc_p = !(updates - deletes).empty?
+      dec_p = !(starts & deletes).empty?
+      bug() if updates.find{|(k, v)| !(k.instance_of?(ClassWrapper) && v.instance_of?(Symbol))}
+      bug() if deletes.find{|(k, v)| !(k.instance_of?(ClassWrapper) && v.instance_of?(Symbol))}
+      bug() if  starts.find{|(k, v)| !(k.instance_of?(ClassWrapper) && v.instance_of?(Symbol))}
+      inc_p | dec_p | update_p
     end
 
     def compact()
@@ -2259,7 +2328,7 @@ Currently, CastOff doesn't support object, which cannot marshal dump (e.g. STDIN
       :@@reuse_compiled_code                     => [true,  false, true],
       :@@allow_builtin_variable_incompatibility  => [false, true,  false],
       :@@prefetch_constant                       => [true,  true,  false],
-      :@@deoptimize                              => [false, true,  false],
+      :@@deoptimize                              => [false, true,  true],
       :@@development                             => [false, true,  true],
       :@@alert_override                          => [true,  true,  false],
       :@@skip_configuration_check                => [false, false, true],
@@ -2378,6 +2447,48 @@ Currently, CastOff doesn't support object, which cannot marshal dump (e.g. STDIN
 
     private
 
+    def __ignore_configuration_of_variables(sign)
+      deletes = []
+      @ignore_configuration_of_variables.each do |(k, v)|
+        bug() unless k.instance_of?(Symbol)
+        bug() unless v == true
+        next unless @variable_configuration[k]
+        bug() if @variable_configuration[k].empty?
+        vlog("(#{sign}): ignore #{k} => #{@variable_configuration[k]}")
+        @variable_configuration.delete(k)
+        deletes |= [k]
+      end
+      deletes
+    end
+
+    def __ignore_configuration_of_return_values(sign)
+      deletes = []
+      @ignore_configuration_of_return_values.each do |(k, mids)|
+        bug() if mids.find{|m| !m.instance_of?(Symbol)}
+        if k.instance_of?(ClassWrapper)
+          h = @return_value_configuration[k]
+          next  unless h
+          bug() unless h.instance_of?(Hash)
+          kh = {k => h}
+        else
+          bug() unless k == SingletonClass
+          kh = @return_value_configuration.dup
+        end
+        kh.each do |(k, h)|
+          h.keys.each do |m|
+            bug() unless m.instance_of?(Symbol)
+            if mids.include?(m)
+              vlog("(#{sign}): ignore #{k}#{k.singleton? ? '.' : '#'}#{m} => #{h[m]}")
+              h.delete(m)
+              @return_value_configuration.delete(k) if h.empty?
+              deletes |= [[k, m]]
+            end
+          end
+        end
+      end
+      deletes
+    end
+
     def invalid_configuration(message = "Invalid configuration")
       raise(InvalidConfigurationError, message)
     end