fastruby 0.0.18 → 0.0.19

data/CHANGELOG

@@ -1,3 +1,13 @@
+0.0.19  Fixed temporal variable names of case blocks to make it deterministic and allow caching
+
+    Fixed bug of duplicated entries on $LOAD_PATH, significant performance improvement saves 80% of time both with caching and without caching
+
+    Inline of methods with iter calls
+
+    Inline of iter calls
+
+    Use of observer to allow replacement of CFUNC calls (example: Fixnum#+)
+
 0.0.18  Optimize of exising methods using "optimize" (only pure ruby methods are supported)  
 
     Implemented new cache by syntax tree, more accurate, fixing a few cache bugs and compatible with inlining

data/Rakefile

@@ -7,7 +7,7 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'fastruby'
-  s.version = '0.0.18'
+  s.version = '0.0.19'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY
@@ -17,6 +17,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency "ruby_parser", ">= 2.0.6"
   s.add_dependency "define_method_handler", ">= 0.0.5"
   s.add_dependency "method_source", ">= 0.6.7"
+  s.add_dependency "ruby2ruby", ">= 1.3.1"
   s.has_rdoc = true
   s.extra_rdoc_files = [ 'README' ]
   s.extensions = FileList["ext/**/extconf.rb"].to_a

data/benchmarks/benchmark.rb~

@@ -1,11 +1,9 @@
 require "rubygems"
 require "fastruby"
 
-def lvar_type(*x); end
-
 class X
   def foo(a,b)
-		return a+b
+		a+b
 	end
 end
 
@@ -17,7 +15,7 @@ class Y
 			
 		ret = 0
 		while i > 0
-			ret = x.foo(i,i)
+			ret = (i+i)
 			i = i - 1
 		end
 		return ret

data/benchmarks/benchmark3.rb~

@@ -1,11 +1,9 @@
 require "rubygems"
 require "fastruby"
 
-def lvar_type(*x); end
-
 class X
 	def foo
-		yield(1,2,3)
+		yield(1)
 	end
 end
 
@@ -17,7 +15,7 @@ class Y
 			
 		ret = 0
 		while i > 0
-			x.foo do |a,b,c|
+			x.foo do |a|
 			end
 			  i = i - 1
 		end

data/ext/fastruby_base/fastruby_base.inl

@@ -402,6 +402,7 @@ static VALUE fastruby_method_tree_pointer(VALUE self) {
 
 	if (rb_tree_pointer == Qnil) {
 		VALUE* tree_pointer = malloc(sizeof(VALUE*));
+		rb_gc_register_address(tree_pointer);
 		*tree_pointer = Qnil;
 		rb_tree_pointer = LONG2FIX(tree_pointer);
 		rb_ivar_set(self, rb_intern("@tree"), rb_tree_pointer);
@@ -412,7 +413,6 @@ static VALUE fastruby_method_tree_pointer(VALUE self) {
 
 static VALUE fastruby_method_tree_eq(VALUE self, VALUE val) {
 	VALUE* tree_pointer = (VALUE*)FIX2LONG(fastruby_method_tree_pointer(self));
-  rb_ivar_set(self, rb_intern("__current_tree"), val);
 	*tree_pointer = val;
 	return Qnil;
 }

data/lib/fastruby/builder.rb

@@ -23,6 +23,10 @@ require "fastruby/logging"
 require "fastruby/getlocals"
 require "fastruby_load_path"
 require "fastruby/inliner/inliner"
+require "fastruby/translator/translator"
+require "rubygems"
+require "inline"
+require "fastruby/inline_extension"
 
 require FastRuby.fastruby_load_path + "/../ext/fastruby_base/fastruby_base"
 
@@ -68,11 +72,6 @@ module FastRuby
     def rebuild(signature, noreturn = false)
       no_cache = false
       mname = FastRuby.make_str_signature(@method_name, signature)
-      
-      require "fastruby/translator/translator"
-      require "rubygems"
-      require "inline"
-      require "fastruby/inline_extension"
 
       inliner = FastRuby::Inliner.new
 
@@ -119,13 +118,15 @@ module FastRuby
       end
       
       inliner.inlined_methods.each do |inlined_method|
-        inlined_method.observe("#{@owner}##{@method_name}") do |imethod|
+        inlined_method.observe("#{@owner}##{@method_name}#{mname}") do |imethod|
           rebuild(signature, noreturn)
         end
       end
       
       alt_options = options.dup
       alt_options.delete(:self)
+      
+      #require "pry"; binding.pry
       code_sha1 = FastRuby.cache.hash_snippet(inlined_tree.inspect, FastRuby::VERSION + signature.map(&:to_s).join('-') + alt_options.inspect)
       
       paths = FastRuby.cache.retrieve(code_sha1)
@@ -224,7 +225,7 @@ module FastRuby
         $class_self = old_class_self
       end
       
-      observe("#{@owner}##{@method_name}") do |imethod|
+      observe("#{@owner}##{@method_name}#{mname}") do |imethod|
         if tree
           rebuild(signature, noreturn)
         end

data/lib/fastruby/fastruby_sexp.rb

@@ -32,6 +32,24 @@ module FastRuby
       }
     end
     
+    def to_sexp
+      ret = s()
+      each do |subtree|
+        if subtree.respond_to?(:to_sexp)
+          ret << subtree.to_sexp
+        else
+          ret << subtree
+        end 
+      end
+      
+      ret
+    end
+    
+    def to_ruby
+      require "ruby2ruby"
+      Ruby2Ruby.new.process(to_sexp)
+    end
+    
     def map
       sexp = FastRubySexp.new
       self.each do |subtree|

data/lib/fastruby/inliner/modules/call.rb

@@ -24,82 +24,132 @@ require "define_method_handler"
  
 module FastRuby
   class Inliner
+    
+    class BlockProcessing
+      def initialize(inlined_name, break_inlined_name)
+        @inlined_name = inlined_name
+        @break_inlined_name = break_inlined_name
+      end
+      
+      define_method_handler(:process, :priority => -100) { |tree|
+        tree.map &method(:process)
+      }
+
+      define_method_handler(:process, :priority => 1000) { |tree|
+        tree
+      }.condition{|tree| not tree.respond_to?(:node_type) }
+
+      define_method_handler(:process) { |tree|
+        if tree[1]
+          fs(:call, nil, :_throw, fs(:arglist, fs(:lit,@inlined_name.to_sym), process(tree[1])))
+        else
+          fs(:call, nil, :_throw, fs(:arglist, fs(:lit,@inlined_name.to_sym), fs(:nil)))
+        end
+      }.condition{|tree| tree.node_type == :next}
+
+      define_method_handler(:process) { |tree|
+        if tree[1]
+          fs(:call, nil, :_throw, fs(:arglist, fs(:lit,@break_inlined_name.to_sym), process(tree[1])))
+        else
+          fs(:call, nil, :_throw, fs(:arglist, fs(:lit,@break_inlined_name.to_sym), fs(:nil)))
+        end
+      }.condition{|tree| tree.node_type == :break and @break_inlined_name}
+      
+      define_method_handler(:process) { |tree|
+        fs(:call, nil, :_loop, fs(:arglist, fs(:lit,@inlined_name.to_sym)))
+      }.condition{|tree| tree.node_type == :redo}
+
+      define_method_handler(:process) { |tree|
+        if tree[3]
+          fs(:iter, process(tree[1]), tree[2], tree[3].duplicate)
+        else
+          fs(:iter, process(tree[1]), tree[2])
+        end
+      }.condition{|tree| tree.node_type == :iter}
+    end
+    
     def inline_local_name(method_name, local_name)
       "__inlined_#{method_name}_#{local_name}".to_sym
     end
     
-    define_method_handler(:inline) { |tree|
-        ret_tree = fs(:iter)
-        ret_tree << tree[1].duplicate
-        
-        tree[2..-1].each do |subtree|
-          ret_tree << inline(subtree)
-        end
-        
-        ret_tree
-        
-      }.condition{|tree| tree.node_type == :iter}
+    def method_obj_or_gtfo(klass, method_name)
+      return nil unless klass.respond_to?(:fastruby_method)
+      klass.fastruby_method(method_name)
+    end
     
-    define_method_handler(:inline) { |tree|
-      
-      next tree if tree.find_tree(:block_pass)
-      
-      recv_tree = tree[1] || fs(:self)
-      method_name = tree[2]
-      args_tree = tree[3]
-      
-      if method_name == :lvar_type
-        lvar_name = args_tree[1][1] || args_tree[1][2]
-        lvar_type = eval(args_tree[2][1].to_s)
-
-        @infer_lvar_map[lvar_name] = lvar_type
-        next tree
+    def add_prefix(tree, prefix)
+      tree = tree.duplicate
+      tree.walk_tree do |subtree|
+        if subtree.node_type == :lvar or subtree.node_type == :lasgn
+          subtree[1] = inline_local_name(prefix, subtree[1])
+          add_local subtree[1]
+        end
       end
       
-      recvtype = infer_type(recv_tree)
- 
-      if recvtype
-        # search the tree of target method
-        next tree unless recvtype.respond_to?(:fastruby_method)
-
-        mobject = recvtype.fastruby_method(method_name)
+      tree
+    end
+    
+    def catch_block(name,tree)
+      fs(:block,fs(:iter, fs(:call, nil, :_catch, fs(:arglist, fs(:lit,name.to_sym))),nil,tree))
+    end
+    
+    def method_tree_to_inlined_block(mobject, call_tree, method_name, block_args_tree = nil, block_tree = nil)
+        args_tree = call_tree[3]
+        recv_tree = call_tree[1] || fs(:self)
         
-        next tree unless mobject
+        target_method_tree = mobject.tree 
         
-        target_method_tree = mobject.tree
-
-        next tree unless target_method_tree
-        next tree if target_method_tree.find_tree(:iter)
-        target_method_tree_args = target_method_tree[2]
+        @method_index = (@method_index || 0) + 1
         
-        next tree if target_method_tree_args.find{|subtree| subtree.to_s =~ /^\*/}
-
-
-        target_method_tree_block = target_method_tree.find_tree(:scope)[1].duplicate
+        prefix = method_name.to_s + "_" + @method_index.to_s
+        target_method_tree_block = add_prefix(target_method_tree.find_tree(:scope)[1], prefix)
         
-        target_method_tree_block.walk_tree do |subtree|
-          if subtree.node_type == :lvar or subtree.node_type == :lasgn
-            subtree[1] = inline_local_name(method_name, subtree[1])
-            add_local subtree[1]
+        if target_method_tree_block.find_tree(:return)
+          inlined_name = inline_local_name(method_name, "main_return_tagname")
+          target_method_tree_block = catch_block(inlined_name,target_method_tree_block)
+          
+          target_method_tree_block.walk_tree do |subtree|
+            if subtree[0] == :return
+              if subtree[1]
+                subtree[0..-1] = fs(:call, nil, :_throw, fs(:arglist, fs(:lit,inlined_name.to_sym), subtree[1]))
+              else
+                subtree[0..-1] = fs(:call, nil, :_throw, fs(:arglist, fs(:lit,inlined_name.to_sym), fs(:nil)))
+              end
+            end
           end
         end
         
+        target_method_tree_args = target_method_tree[2]
+
         newblock = fs(:block)
         
         (1..args_tree.size-1).each do |i|
           itype = infer_type(args_tree[i])
-          inlined_name = inline_local_name(method_name, target_method_tree_args[i])
+          inlined_name = inline_local_name(prefix, target_method_tree_args[i])
 
           add_local inlined_name
 
           self.extra_inferences[inlined_name] = itype if itype
-          newblock << fs(:lasgn, inlined_name, args_tree[i].duplicate)
+          newblock << fs(:lasgn, inlined_name, recursive_inline(args_tree[i].duplicate))
         end
         
-        inlined_name = inline_local_name(method_name, :self)
+        inlined_name = inline_local_name(prefix, :self)
         add_local inlined_name
         newblock << fs(:lasgn, inlined_name, recv_tree.duplicate)
         
+        return nil if target_method_tree_block.find_tree(:return)
+
+        break_tag = nil
+        
+        if block_tree
+          block_tree = recursive_inline(block_tree)
+          if block_tree.find_tree(:break) # FIXME: discard nested iter calls on finding
+            break_tag =  inline_local_name(prefix, "__break_tag")
+          end
+        end
+         
+        block_num = 0
+        
         target_method_tree_block.walk_tree do |subtree|
           if subtree.node_type == :call
             if subtree[1] == nil
@@ -112,38 +162,175 @@ module FastRuby
           end
           if subtree.node_type == :self
             subtree[0] = :lvar
-            subtree[1] = inline_local_name(method_name, :self)
+            subtree[1] = inline_local_name(prefix, :self)
           end
-        end
-        
-        (1..target_method_tree_block.size-1).each do |i|
-          subtree = target_method_tree_block[i]
-          
-          if subtree.find_tree(:return)
-            if i == target_method_tree_block.size-1
-              if subtree.node_type == :return
-                if subtree[1]
-                  if subtree[1].find_tree(:return)
-                    next tree
+          if subtree.node_type == :yield
+            if block_tree
+              # inline yield
+              yield_call_args = subtree.duplicate
+              
+              subtree[0..-1] = fs(:block)
+              
+              if block_args_tree
+                return nil if yield_call_args[1..-1].find{|x| x.node_type == :splat}
+                if block_args_tree.node_type == :masgn
+                  return nil if block_args_tree[1].size != yield_call_args.size
+                  return nil if block_args_tree[1][1..-1].find{|x| x.node_type == :splat}
+              
+                  (1..yield_call_args.size-1).each do |i|
+                    inlined_name = block_args_tree[1][i][1]
+                    add_local inlined_name
+                    subtree << fs(:lasgn, inlined_name, yield_call_args[i])
                   end
+                else
+                  return nil if 2 != yield_call_args.size
+
+                  inlined_name = block_args_tree[1]
+                  add_local inlined_name
+                  subtree << fs(:lasgn, inlined_name, yield_call_args[1])
                 end
+              else
+                return nil if yield_call_args.size > 1
+              end
+              
+              if block_tree.find_tree(:next) or block_tree.find_tree(:redo) or break_tag
+                inlined_name = inline_local_name(prefix, "block_block_#{block_num}")
+                block_num = block_num + 1
                 
-                subtree[0..-1] = subtree[1]
+                alt_block_tree = BlockProcessing.new(inlined_name, break_tag).process(block_tree)
+                alt_block_tree = catch_block(inlined_name,alt_block_tree)
+              else
+                alt_block_tree = block_tree.duplicate
               end
+              subtree << alt_block_tree
             else
-              # methods with return cannot be inlined
-              next tree
+              subtree[0..-1] = fs(:call, fs(:nil), :raise, fs(:arglist, fs(:const, :LocalJumpError), fs(:str, "no block given")))
             end
           end
-          
-          newblock << subtree
         end
         
         @inlined_methods << mobject
+        
+        if break_tag
+          inner_block = fs(:block)
+          target_method_tree_block[1..-1].each do |subtree|
+            inner_block << subtree
+          end
+          
+          newblock << catch_block(break_tag,inner_block)
+        else
+          target_method_tree_block[1..-1].each do |subtree|
+            newblock << subtree
+          end
+        end
         newblock
+    end
+    
+    define_method_handler(:inline) { |tree|
+      tree
+    }.condition{|tree| tree.node_type == :defs}
+    
+    define_method_handler(:inline) { |tree|
+        ret_tree = fs(:iter)
+        ret_tree << tree[1].duplicate
+        
+        call_tree = tree[1]
+        recv_tree = call_tree[1] || fs(:self)
+        method_name = call_tree[2]
+        args_tree = call_tree[3]
+        block_tree = tree[3] || fs(:nil)
+        block_args_tree = tree[2]
+        
+        tree[2..-1].each do |subtree|
+          ret_tree << inline(subtree)
+        end
+        
+        next ret_tree if block_tree.find_tree(:retry)
+
+        recvtype = infer_type(recv_tree)
+
+        if recvtype
+          # search the tree of target method
+          mobject = method_obj_or_gtfo(recvtype,method_name)
+  
+          next tree unless mobject
+          next tree unless mobject.tree
+        
+          exit_now = false
+          if block_tree.find_tree(:break) or block_tree.find_tree(:return)
+            mobject.tree.walk_tree do |subtree|
+              if subtree.node_type == :iter
+                if subtree.find_tree(:yield)
+                  exit_now = true
+                  break
+                end
+              end
+            end
+          end
+          
+          next tree if exit_now
+          
+          target_method_tree_args = mobject.tree[2]
+          next tree if target_method_tree_args.find{|subtree| subtree.to_s =~ /^\*/}
+
+          method_tree_to_inlined_block(mobject, call_tree, method_name, block_args_tree, block_tree) || ret_tree
+  
+        else
+          # nothing to do, we don't know what is the method
+          ret_tree
+        end
+     }.condition{|tree| tree.node_type == :iter}
+    
+    define_method_handler(:inline) { |tree|
+      
+      next tree if tree.find_tree(:block_pass)
+      
+      recv_tree = tree[1] || fs(:self)
+      method_name = tree[2]
+      args_tree = tree[3]
+      
+      if method_name == :lvar_type
+        lvar_name = args_tree[1][1] || args_tree[1][2]
+        lvar_type = eval(args_tree[2][1].to_s)
+
+        @infer_lvar_map[lvar_name] = lvar_type
+        next recursive_inline(tree)
+      end
+      
+      recvtype = infer_type(recv_tree)
+ 
+      if recvtype
+        # search the tree of target method
+        mobject = method_obj_or_gtfo(recvtype,method_name)
+
+        next recursive_inline(tree) unless mobject
+        next recursive_inline(tree) unless mobject.tree
+        
+        exit_now = false
+        mobject.tree.walk_tree do |subtree|
+          if subtree.node_type == :iter
+            if subtree.find_tree(:return)
+              exit_now = true
+              break
+            end
+          end
+        end
+          
+        next recursive_inline(tree) if exit_now
+
+        target_method_tree_args = if mobject.tree.node_type == :defn
+            mobject.tree[2]
+          else
+            mobject.tree[3]
+          end
+          
+        next recursive_inline(tree) if target_method_tree_args.find{|subtree| subtree.to_s =~ /^\*/}
+
+        method_tree_to_inlined_block(mobject, tree, method_name) || recursive_inline(tree)
+
       else
         # nothing to do, we don't know what is the method
-        tree
+        recursive_inline(tree)
       end
     }.condition{|tree| tree.node_type == :call}
   end

data/lib/fastruby/inliner/modules/recursive.rb

@@ -24,6 +24,11 @@ require "define_method_handler"
 
 module FastRuby
   class Inliner
+    
+    def recursive_inline(tree)
+      tree.map &method(:inline)
+    end
+    
     define_method_handler(:inline, :priority => -100) {|tree|
         tree.map &method(:inline)
       }.condition{|tree| tree.respond_to?(:node_type)}

data/lib/fastruby/reductor/modules/case.rb

@@ -41,7 +41,8 @@ module FastRuby
     end
         
     reduce_for(:case) do |tree|
-      temporal_var_name = "temporal_case_var_#{rand(1000000000)}".to_sym
+      @case_index = (@case_index || 0) + 1
+      temporal_var_name = "temporal_case_var_#{@case_index}".to_sym
       ifs = when_array_to_if(tree[2..-1], temporal_var_name)
       fs(:block, fs(:lasgn, temporal_var_name, tree[1]), ifs)
     end