fastruby 0.0.17 → 0.0.18

data/benchmarks/benchmark5.rb

@@ -2,81 +2,51 @@ require "rubygems"
 require "fastruby"
 
 class X
-	fastruby "
-		def bar
-		end
-	"
-	
-	fastruby "
-		def foo
-			yield(self)
-		end
-	"
-end
-
-class Y
-	fastruby "
-		def bar(x)
-			i = 1000000
-			
-			lvar_type(i,Fixnum)
-			lvar_type(x2,X)
-	
-			ret = 0
-			while i > 0
-				x.foo do |x2|
-					x2.bar
-				end
-				  i = i - 1
-			end
-			0
-		end
-
-	"
-end
-
-class X2
 	def bar
 	end
 	
-	def foo
+  def foo
 		yield(self)
 	end
 end
 
-class Y2
-		def bar(x)
-			i = 1000000
+class Y
+	def bar(x)
+		i = 1000000
 			
-			ret = 0
-			while i > 0
-				x.foo do |x2|
-					x2.bar
-				end
-				  i = i - 1
+		lvar_type(:i,Fixnum)
+		lvar_type(:x2,X)
+	
+		ret = 0
+		while i > 0
+			x.foo do |x2|
+				x2.bar
 			end
-			0
+			  i = i - 1
 		end
+		0
+	end
 end
 
-
 x = X.new
 y = Y.new
-y2 = Y2.new
-x2 = X2.new
-
-Y.build([Y,X],:bar) 
-X.build([X],:foo)
-X.build([X],:bar)
 
 require 'benchmark'
 
 Benchmark::bm(20) do |b|
-	b.report("fastruby") do
+	b.report("ruby") do
 		y.bar(x)
 	end
 
-	b.report("ruby") do
-		y2.bar(x2)
+  Y.optimize(:bar) 
+  X.optimize(:foo)
+  X.optimize(:bar)
+
+  Y.build([Y,X],:bar) 
+  X.build([X],:foo)
+  X.build([X],:bar)
+
+	b.report("fastruby") do
+		y.bar(x)
 	end
 end

data/benchmarks/benchmark5.rb~

@@ -0,0 +1,54 @@
+require "rubygems"
+require "fastruby"
+
+def lvar_type(*x); end
+
+class X
+	def bar
+	end
+	
+  def foo
+		yield(self)
+	end
+end
+
+class Y
+	def bar(x)
+		i = 1000000
+			
+		lvar_type(:i,Fixnum)
+		lvar_type(:x2,X)
+	
+		ret = 0
+		while i > 0
+			x.foo do |x2|
+				x2.bar
+			end
+			  i = i - 1
+		end
+		0
+	end
+end
+
+x = X.new
+y = Y.new
+
+require 'benchmark'
+
+Benchmark::bm(20) do |b|
+	b.report("ruby") do
+		y.bar(x)
+	end
+
+  Y.optimize(:bar) 
+  X.optimize(:foo)
+  X.optimize(:bar)
+
+  Y.build([Y,X],:bar) 
+  X.build([X],:foo)
+  X.build([X],:bar)
+
+	b.report("fastruby") do
+		y.bar(x)
+	end
+end

data/benchmarks/benchmark6.rb

@@ -1,64 +1,43 @@
 require "rubygems"
 require "fastruby"
 
-class X
-	fastruby '
-		def foo
-			"65535".to_i
-		end
-	'
-end
-
-class Y
-	fastruby "
-		def bar(x)
-			i = 1000000
-			lvar_type(i,Fixnum)
-	
-			while i > 0
-				x.foo
-				i = i - 1
-			end
-			0
-		end
+def lvar_type(*x); end
 
-	"
-end
-
-class X2
+class X
 	def foo
 		"65535".to_i
 	end
 end
 
-class Y2
-		def bar(x)
-			i = 1000000
+class Y
+	def bar(x)
+		i = 1000000
+		lvar_type(i,Fixnum)
 	
-			while i > 0
-				x.foo
-				i = i - 1
-			end
-			0
+		while i > 0
+			x.foo
+			i = i - 1
 		end
+		0
+	end
 end
 
-
 x = X.new
 y = Y.new
-y2 = Y2.new
-x2 = X2.new
-
-Y.build([Y,X],:bar) 
 
 require 'benchmark'
 
 Benchmark::bm(20) do |b|
-	b.report("fastruby") do
+	b.report("ruby") do
 		y.bar(x)
 	end
 
-	b.report("ruby") do
-		y2.bar(x2)
+  X.optimize(:foo)
+  Y.optimize(:bar)
+  X.build([X],:foo)
+  Y.build([Y,X],:bar) 
+
+	b.report("fastruby") do
+		y.bar(x)
 	end
 end

data/benchmarks/benchmark6.rb~

@@ -0,0 +1,41 @@
+require "rubygems"
+require "fastruby"
+
+class X
+	def foo
+		"65535".to_i
+	end
+end
+
+class Y
+	def bar(x)
+		i = 1000000
+		lvar_type(i,Fixnum)
+	
+		while i > 0
+			x.foo
+			i = i - 1
+		end
+		0
+	end
+end
+
+x = X.new
+y = Y.new
+
+require 'benchmark'
+
+Benchmark::bm(20) do |b|
+	b.report("ruby") do
+		y.bar(x)
+	end
+
+  X.optimize(:foo)
+  Y.optimize(:bar)
+  X.build([X],:foo)
+  Y.build([Y,X],:bar) 
+
+	b.report("fastruby") do
+		y.bar(x)
+	end
+end

data/benchmarks/benchmark7.rb

@@ -2,76 +2,47 @@ require "rubygems"
 require "fastruby"
 
 class X
-	fastruby "
-		def factorial(n)
-			if n > 1
-				n * factorial((n-1).infer(Fixnum))
-			else
-				1
-			end
-		end
-	"
-end
-
-class Y
-	fastruby "
-		def bar(x)
-			i = 100000
-			
-			lvar_type(i,Fixnum)
-			
-			ret = 0
-			while i > 0
-				x.factorial(20)
-				i = i - 1
-			end
-			return ret
-		end
-
-	"
-end
-
-class X2
-	def factorial(n)
+  def factorial(n)
 		if n > 1
-			n * factorial(n-1)
+			n * factorial((n-1).infer(Fixnum))
 		else
 			1
 		end
 	end
 end
 
-class Y2
-		def bar(x)
-			i = 100000
+class Y
+	def bar(x)
+		i = 100000
+		
+		lvar_type(i,Fixnum)
 			
-			ret = 0
-			while i > 0
-				x.factorial(20)
-				i = i - 1
-			end
-			return ret
-		end
-
+		ret = 0
+		while i > 0
+			x.factorial(20)
+			i = i - 1
+  	end
+		return ret
+	end
 end
 
-
 x = X.new
 y = Y.new
-y2 = Y2.new
-x2 = X2.new
-
-Y.build([Y,X],:bar)
 
 require 'benchmark'
 
 Benchmark::bm(20) do |b|
-
-	b.report("fastruby") do
+	b.report("ruby") do
 		y.bar(x)
 	end
 
-	b.report("ruby") do
-		y2.bar(x2)
+  X.optimize(:factorial)
+  Y.optimize(:bar)
+  X.build([X],:factorial)
+  Y.build([Y,X],:bar)
+
+	b.report("fastruby") do
+		y.bar(x)
 	end
 end
+

data/benchmarks/benchmark7.rb~

@@ -0,0 +1,48 @@
+require "rubygems"
+require "fastruby"
+
+class X
+  def factorial(n)
+		if n > 1
+			n * factorial(1)
+		else
+			1
+		end
+	end
+end
+
+class Y
+	def bar(x)
+		i = 100000
+		
+		lvar_type(i,Fixnum)
+			
+		ret = 0
+		while i > 0
+			x.factorial(20)
+			i = i - 1
+  	end
+		return ret
+	end
+end
+
+x = X.new
+y = Y.new
+
+require 'benchmark'
+
+Benchmark::bm(20) do |b|
+	b.report("ruby") do
+		y.bar(x)
+	end
+
+  X.optimize(:factorial)
+  Y.optimize(:bar)
+  X.build([X],:factorial)
+  Y.build([Y,X],:bar)
+
+	b.report("fastruby") do
+		y.bar(x)
+	end
+end
+

data/ext/fastruby_base/fastruby_base.inl

@@ -412,6 +412,7 @@ 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

@@ -22,6 +22,7 @@ require "fastruby/method_extension"
 require "fastruby/logging"
 require "fastruby/getlocals"
 require "fastruby_load_path"
+require "fastruby/inliner/inliner"
 
 require FastRuby.fastruby_load_path + "/../ext/fastruby_base/fastruby_base"
 
@@ -34,13 +35,23 @@ module FastRuby
     def initialize(method_name, owner)
       @method_name = method_name
       @owner = owner
+      @observers = Hash.new
+    end
+    
+    def observe(key, &blk)
+      @observers[key] = blk
+    end
+    
+    def tree_changed
+      @observers.values.each do |observer|
+        observer.call(self)
+      end
     end
 
     def build(signature, noreturn = false)
       return nil unless tree
-      
-      no_cache = false
 
+      no_cache = false
       mname = FastRuby.make_str_signature(@method_name, signature)
 
       if @owner.respond_to? :method_hash
@@ -51,16 +62,21 @@ module FastRuby
         end
       end
 
-      FastRuby.logger.info "Building #{@owner}::#{@method_name} for signature #{signature.inspect}"
-
+      rebuild(signature, noreturn)
+    end
+    
+    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
+
       context = FastRuby::Context.new
-      context.locals = locals
       context.options = options
 
       args_tree = if tree[0] == :defn
@@ -91,88 +107,127 @@ module FastRuby
       end
 
       context.infer_self = signature[0]
-      c_code = context.to_c_method(tree,signature)
+      
+      inliner.infer_self = context.infer_self
+      inliner.infer_lvar_map = context.infer_lvar_map
 
-      unless options[:main]
-         context.define_method_at_init(@owner,@method_name, args_tree.size+1, signature)
+      inlined_tree = inliner.inline(tree)
+      context.locals = locals + inliner.extra_locals
+      
+      inliner.extra_inferences.each do |local, itype|
+        context.infer_lvar_map[local] = itype
       end
+      
+      inliner.inlined_methods.each do |inlined_method|
+        inlined_method.observe("#{@owner}##{@method_name}") do |imethod|
+          rebuild(signature, noreturn)
+        end
+      end
+      
+      alt_options = options.dup
+      alt_options.delete(:self)
+      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)
 
-      so_name = nil
-
-      old_class_self = $class_self
-      $class_self = @owner
       $last_obj_proc = nil
-
-      begin
-
-        unless $inline_extra_flags
-          $inline_extra_flags = true
-          
-          ['CFLAGS','CXXFLAGS','OPTFLAGS','cflags','cxxflags','optflags'].each do |name|
-            RbConfig::CONFIG[name].gsub!(/\-O\d/,"-O1") if RbConfig::CONFIG[name]
+      if paths.empty?
+        FastRuby.logger.info "Compiling #{@owner}::#{@method_name} for signature #{signature.inspect}"
+        c_code = context.to_c_method(inlined_tree,signature)
+   
+        unless options[:main]
+           context.define_method_at_init(@method_name, args_tree.size+1, signature)
+        end
+  
+        so_name = nil
+  
+        old_class_self = $class_self
+        $class_self = @owner
+  
+        begin
+
+          unless $inline_extra_flags
+            $inline_extra_flags = true
+            
+            ['CFLAGS','CXXFLAGS','OPTFLAGS','cflags','cxxflags','optflags'].each do |name|
+              RbConfig::CONFIG[name].gsub!(/\-O\d/,"-O1") if RbConfig::CONFIG[name]
+            end
+            
+            if RUBY_VERSION =~ /^1\.8/
+              RbConfig::CONFIG['CFLAGS'] << " -DRUBY_1_8 -Wno-clobbered"
+            elsif RUBY_VERSION =~ /^1\.9/
+              RbConfig::CONFIG['CFLAGS'] << " -DRUBY_1_9 -Wno-clobbered"
+            end
           end
           
-          if RUBY_VERSION =~ /^1\.8/
-            RbConfig::CONFIG['CFLAGS'] << " -DRUBY_1_8 -Wno-clobbered"
-          elsif RUBY_VERSION =~ /^1\.9/
-            RbConfig::CONFIG['CFLAGS'] << " -DRUBY_1_9 -Wno-clobbered"
+          @owner.class_eval do
+            inline :C  do |builder|
+              builder.inc << context.extra_code
+              builder.init_extra = context.init_extra
+  
+                def builder.generate_ext
+                  ext = []
+  
+                  @inc.unshift "#include \"ruby.h\""
+  
+                  ext << @inc
+                  ext << nil
+                  ext << @src.join("\n\n")
+                  ext << nil
+                  ext << nil
+                  ext << "#ifdef __cplusplus"
+                  ext << "extern \"C\" {"
+                  ext << "#endif"
+                  ext << "  void Init_#{module_name}() {"
+  
+                  ext << @init_extra.join("\n") unless @init_extra.empty?
+  
+                  ext << nil
+                  ext << "  }"
+                  ext << "#ifdef __cplusplus"
+                  ext << "}"
+                  ext << "#endif"
+                  ext << nil
+  
+                  ext.join "\n"
+                end
+  
+              builder.c c_code
+              so_name = builder.so_name
+            end
           end
-        end
         
-        @owner.class_eval do
-          inline :C  do |builder|
-            builder.inc << context.extra_code
-            builder.init_extra = context.init_extra
-
-              def builder.generate_ext
-                ext = []
-
-                @inc.unshift "#include \"ruby.h\""
-
-                ext << @inc
-                ext << nil
-                ext << @src.join("\n\n")
-                ext << nil
-                ext << nil
-                ext << "#ifdef __cplusplus"
-                ext << "extern \"C\" {"
-                ext << "#endif"
-                ext << "  void Init_#{module_name}() {"
-
-                ext << @init_extra.join("\n") unless @init_extra.empty?
-
-                ext << nil
-                ext << "  }"
-                ext << "#ifdef __cplusplus"
-                ext << "}"
-                ext << "#endif"
-                ext << nil
-
-                ext.join "\n"
-              end
-
-            builder.c c_code
-            so_name = builder.so_name
+          unless no_cache
+            no_cache = context.no_cache
           end
-        end
-
-        if $last_obj_proc
-          unless options[:no_cache]
-            FastRuby.cache.register_proc(so_name, $last_obj_proc)
+    
+          unless no_cache
+            FastRuby.cache.insert(code_sha1, so_name)
           end
-          $last_obj_proc.call($class_self)
+        ensure
+          $class_self = old_class_self
+        end
+      else
+        paths.each do |path|
+          require path
         end
+      end
 
+      if $last_obj_proc
+        FastRuby.cache.register_proc(code_sha1, $last_obj_proc)
+      end
+      
+      $class_self = @owner
+      begin
+        FastRuby.cache.execute(code_sha1, signature, @owner)
       ensure
         $class_self = old_class_self
       end
-
-      unless no_cache
-        no_cache = context.no_cache
-      end
-
-      unless options[:no_cache]
-        FastRuby.cache.insert(snippet_hash, so_name) unless no_cache
+      
+      observe("#{@owner}##{@method_name}") do |imethod|
+        if tree
+          rebuild(signature, noreturn)
+        end
       end
     end
   end
@@ -194,10 +249,7 @@ module FastRuby
     end
     
     def method_added(method_name)
-      if self.respond_to? :clear_method_hash_addresses
-        FastRuby.unset_tree(self,method_name)
-        self.clear_method_hash_addresses(method_hash(method_name))
-      end
+      FastRuby.unset_tree(self,method_name)
     end
 
     def fastruby_method(mname_)