cast_off 0.2.3 → 0.3.1

data/lib/cast_off/compile/ir/guard_ir.rb

@@ -93,19 +93,26 @@ expected <%= @guard_value.types %> but %s, %s\\n\\
 }
       EOS
 
-      GUARD_TEMPLATE = ERB.new(<<-EOS, 0, '%-', 'g0')
-%bug() if @guard_value.undefined? || @guard_value.dynamic?
-<%= guard_begin() %>
+      GUARD_RECOMPILATION_FUNCTION_TEMPLATE = ERB.new(<<-EOS, 0, '%-', '__recompilation')
+NOINLINE(static void <RECOMPILATION_FUNCTION_NAME>(VALUE obj));
+static void <RECOMPILATION_FUNCTION_NAME>(VALUE obj)
+{
 #if 1
-    if(!sampling_table) register_sampling_table(rb_hash_new());
-%  get_definition(@guard_value).each do |defn|
+  if(!sampling_table) register_sampling_table(rb_hash_new());
+%  count = 0
+%  defs = get_definition(@guard_value)
+%  defs.each do |defn|
 %    case defn
 %    when SubIR
 %      case defn.src
 %      when LocalVariable, DynamicVariable, InstanceVariable, ClassVariable, GlobalVariable, Self
-    sampling_variable(<%= @guard_value %>, ID2SYM(rb_intern("<%= defn.src.source %>")));
-%      when ConstWrapper, Literal
+%        count += 1
+  sampling_variable(obj, ID2SYM(rb_intern("<%= defn.src.source %>")));
+%      when ConstWrapper
 %        # Fixme
+  /* <%= defn.src.path %> */
+%      when Literal
+%        # nothing to do
 %      else
 %        bug(defn.src)
 %      end
@@ -115,12 +122,25 @@ expected <%= @guard_value.types %> but %s, %s\\n\\
 %      recv.types.each do |k|
 %        recv_class = @translator.get_c_classname(k)
 %        bug() unless recv_class
-    __sampling_poscall(<%= @guard_value %>, <%= recv_class %>, ID2SYM(rb_intern("<%= defn.method_id %>")));
+%        count += 1
+  __sampling_poscall(obj, <%= recv_class %>, ID2SYM(rb_intern("<%= defn.method_id %>")));
 %      end
 %    end
 %  end
-    rb_funcall(rb_mCastOff, rb_intern("re_compile"), 2, rb_str_new2("<%= @translator.signiture() %>"), sampling_table_val);
+%  if count > 0
+  rb_funcall(rb_mCastOff, rb_intern("re_compile"), 2, rb_str_new2("<%= @translator.signiture() %>"), sampling_table_val);
+%  else
+%    dlog("skip recompilation: defs = \#{defs.join("\\n")}")
+%  end
 #endif
+}
+      EOS
+
+      GUARD_TEMPLATE = ERB.new(<<-EOS, 0, '%-', 'g0')
+%bug() if @guard_value.undefined? || @guard_value.dynamic?
+<%= guard_begin() %>
+%func = @translator.declare_recompilation_function(GUARD_RECOMPILATION_FUNCTION_TEMPLATE.trigger(binding))
+    <%= func %>(<%= @guard_value %>);
 %if @configuration.deoptimize?
     goto <%= @insn.guard_label %>;
 %  @insn.iseq.inject_guard(@insn, GUARD_DEOPTIMIZATION_TEMPLATE.trigger(binding))

data/lib/cast_off/compile/ir/simple_ir.rb

@@ -670,7 +670,7 @@ Call site is (#{insn}).
           change = false
           @cfg.blocks.each do |b|
             foo = b.irs & irs
-            bar = b.information.variable_definition & irs
+            bar = b.information.definition & irs
             if foo.size > 0 || bar.size > 0
               vars = []
               bar.each do |ir|
@@ -745,7 +745,7 @@ Call site is (#{insn}).
         when Literal
           return [target]
         when Variable
-          ds = @information.variable_definition_of(target)
+          ds = @information.definition_of(target)
           bug() if ds.empty?
           ary = []
           ds.each do |d|

data/lib/cast_off/compile/translator.rb

@@ -87,6 +87,7 @@ static void sampling_variable(VALUE val, VALUE sym)
   /* :variable => [klass0, klass1, ...] */
   VALUE klass = rb_class_of(val);
   VALUE hashval;
+  VALUE singleton_class_obj_p = Qfalse;
   st_table *hash;
 
   if (!st_lookup(sampling_table, (st_data_t)sym, (st_data_t*)&hashval)) {
@@ -96,11 +97,16 @@ static void sampling_variable(VALUE val, VALUE sym)
   hash = RHASH_TBL(hashval);
 
   if (FL_TEST(klass, FL_SINGLETON)) {
-    klass = rb_cCastOffSingletonClass;
+    if (rb_obj_class(val) == rb_cClass) {
+      klass = val;
+      singleton_class_obj_p = Qtrue;
+    } else {
+      klass = rb_cCastOffSingletonClass;
+    }
   }
 
   if (!st_lookup(hash, (st_data_t)klass, 0)) {
-    st_insert(hash, (st_data_t)klass, (st_data_t)Qtrue);
+    st_insert(hash, (st_data_t)klass, (st_data_t)singleton_class_obj_p);
   }
 
   return;
@@ -109,18 +115,30 @@ static void sampling_variable(VALUE val, VALUE sym)
 static void __sampling_poscall(VALUE val, VALUE method_klass, VALUE method_id)
 {
   VALUE klass;
-  VALUE method_id_hashval, hashval;
-  st_table *method_id_hash, *hash;
+  VALUE mtblval, method_id_hashval, hashval;
+  VALUE singleton_class_obj_p = Qfalse;
+  VALUE class_method_p = Qfalse;
+  st_table *mtbl, *method_id_hash, *hash;
 
   if (FL_TEST(method_klass, FL_SINGLETON)) {
-    method_klass = rb_cCastOffSingletonClass;
+    VALUE recv = rb_ivar_get(method_klass, rb_intern("__attached__"));
+    if (rb_obj_class(recv) == rb_cClass && rb_class_of(recv) == method_klass) {
+      method_klass = recv;
+      class_method_p = Qtrue;
+    } else {
+      method_klass = rb_cCastOffSingletonClass;
+    }
   }
 
-  klass = rb_class_of(val);
+  if (!st_lookup(sampling_table, (st_data_t)class_method_p, (st_data_t*)&mtblval)) {
+    mtblval = rb_hash_new();
+    st_insert(sampling_table, (st_data_t)class_method_p, (st_data_t)mtblval);
+  }
+  mtbl = RHASH_TBL(mtblval);
 
-  if (!st_lookup(sampling_table, (st_data_t)method_klass, (st_data_t*)&method_id_hashval)) {
+  if (!st_lookup(mtbl, (st_data_t)method_klass, (st_data_t*)&method_id_hashval)) {
     method_id_hashval = rb_hash_new();
-    st_insert(sampling_table, (st_data_t)method_klass, (st_data_t)method_id_hashval);
+    st_insert(mtbl, (st_data_t)method_klass, (st_data_t)method_id_hashval);
   }
   method_id_hash = RHASH_TBL(method_id_hashval);
   if (!st_lookup(method_id_hash, (st_data_t)method_id, (st_data_t*)&hashval)) {
@@ -129,12 +147,18 @@ static void __sampling_poscall(VALUE val, VALUE method_klass, VALUE method_id)
   }
   hash = RHASH_TBL(hashval);
 
+  klass = rb_class_of(val);
   if (FL_TEST(klass, FL_SINGLETON)) {
-    klass = rb_cCastOffSingletonClass;
+    if (rb_obj_class(val) == rb_cClass) {
+      klass = val;
+      singleton_class_obj_p = Qtrue;
+    } else {
+      klass = rb_cCastOffSingletonClass;
+    }
   }
 
   if (!st_lookup(hash, (st_data_t)klass, 0)) {
-    st_insert(hash, (st_data_t)klass, (st_data_t)Qtrue);
+    st_insert(hash, (st_data_t)klass, (st_data_t)singleton_class_obj_p);
   }
 
   return;
@@ -385,6 +409,10 @@ static inline int empty_method_table_p(VALUE klass)
 <%= func.gsub(/<CLASS_CHECK_FUNCTION_NAME>/, name) %>
 %end
 
+%@recompilation_functions.each do |(func, name)|
+<%= func.gsub(/<RECOMPILATION_FUNCTION_NAME>/, name) %>
+%end
+
 %if !inline_block?
 static inline void expand_dframe(rb_thread_t *th, long size, rb_iseq_t *iseq, int root_p)
 {
@@ -769,6 +797,7 @@ void Init_<%= signiture() %>(void)
       @declare_constants = {}
       @class_check_functions = {}
       @throw_exception_functions = {}
+      @recompilation_functions = {}
       @prefetch_constants = {}
       @ivar_index = {}
       @loopkey = {}
@@ -912,6 +941,15 @@ Source line is #{@root_iseq.source_line}.
       name
     end
 
+    def declare_recompilation_function(func)
+      unless name = @recompilation_functions[func]
+        idx = @recompilation_functions.size()
+        name = "recompilation_#{idx}"
+        @recompilation_functions[func] = name
+      end
+      name
+    end
+
     def prefetch_constant(var, path, singleton_p)
       if @prefetch_constants[var]
         bug() unless @prefetch_constants[var] == [path, singleton_p]

data/lib/cast_off/compile.rb

@@ -546,26 +546,35 @@ Currently, CastOff cannot compile method which source file is not exist.
 
     def parse_sampling_table(sampling_table)
       reciever_result = {}
-      return_value_result = {}
+      return_value_result = {:instance_methods => {}, :singleton_methods => {}}
       sampling_table.each do |(key0, val0)|
         case key0
         when Symbol
           bug() unless val0.is_a?(Hash)
-          reciever_result[key0] = val0.keys
-        when Class
+          reciever_result[key0] = val0.to_a
+        when TrueClass, FalseClass
+          mtbl = return_value_result[(key0 ? :singleton_methods : :instance_methods)]
+          bug() unless mtbl.is_a?(Hash)
           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
+          val0.each do |(klass, midtbl)|
+            bug() unless klass.is_a?(Class)
+            bug() unless midtbl.is_a?(Hash)
+            newval = {}
+            midtbl.each do |(key1, val1)|
+              bug() unless key1.is_a?(Symbol)
+              bug() unless val1.is_a?(Hash)
+              newval[key1] = val1.to_a
+            end
+            mtbl[klass] = newval
           end
-          return_value_result[key0] = newval
         else
           bug("#{key0}, #{key0.class}")
         end
       end
-      bug() unless (reciever_result.keys & return_value_result.keys).empty?
+      k0 = reciever_result.keys
+      k1 = return_value_result[:instance_methods].keys
+      k2 = return_value_result[:singleton_methods].keys
+      bug() unless (k0 & k1 & k2).empty?
       [reciever_result, return_value_result]
     end
 
@@ -603,8 +612,13 @@ Currently, CastOff cannot compile method which source file is not exist.
             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]
+              val0.each do |(klass, singleton_p)|
+                kstr = klass.to_s
+                if singleton_p
+                  bug() unless klass.is_a?(Class)
+                  kstr = "Class<#{kstr}>"
+                end
+                ary << [key0.to_s, kstr]
               end
             end
             suggestion.add_suggestion(msg, ["<Variable>", "<SamplingResultClass>"], ary)
@@ -612,11 +626,22 @@ Currently, CastOff cannot compile method which source file is not exist.
           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]}
+            return_value_result.each do |sym, mtbl|
+              bug() unless sym == :singleton_methods || sym == :instance_methods
+              bug() unless mtbl.is_a?(Hash)
+              mtbl.each do |key0, val0|
+                bug() unless key0.is_a?(Class)
+                bug() unless val0.is_a?(Hash)
+                val0.each do |(mid, classes)|
+                  classes.each do |(klass, singleton_p)|
+                    kstr = klass.to_s
+                    if singleton_p
+                      bug() unless klass.is_a?(Class)
+                      kstr = "Class<#{kstr}>"
+                    end
+                    ary << ["#{key0}#{sym == :singleton_methods ? '.' : '#'}#{mid}", kstr]
+                  end
+                end
               end
             end
             suggestion.add_suggestion(msg, ["<Method>", "<SamplingResultClass>"], ary)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cast_off
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,14 +9,14 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-16 00:00:00.000000000 Z
+date: 2011-11-18 00:00:00.000000000 Z
 dependencies: []
 description: ! 'CastOff is a performance improvement tool for Ruby1.9.3
 
 '
 email: shiba@rvm.jp
 executables:
-- CastOff
+- cast_off
 extensions:
 - ext/cast_off/extconf.rb
 extra_rdoc_files:
@@ -95,7 +95,7 @@ files:
 - cast_off.gemspec
 - README
 - README.en
-- bin/CastOff
+- bin/cast_off
 homepage: http://github.com/soba1104/CastOff
 licenses: []
 post_install_message: