fastruby 0.0.21 → 0.0.22

data/Rakefile

@@ -7,7 +7,7 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'fastruby'
-  s.version = '0.0.21'
+  s.version = '0.0.22'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY

data/benchmarks/benchmark.rb

@@ -38,6 +38,9 @@ Benchmark::bm(20) do |b|
   Y.optimize(:bar)
   X.build([X,Fixnum,Fixnum],:foo)
   Y.build([Y,X],:bar)
+  Fixnum.build([Fixnum,Fixnum],:-)
+  Fixnum.build([Fixnum,Fixnum],:>)
+  Fixnum.build([Fixnum,Fixnum],:+)
 
 	b.report("fastruby") do
 		y.bar(x)

data/benchmarks/benchmark.rb~

@@ -1,18 +1,6 @@
 require "rubygems"
 require "fastruby"
 
-class Fixnum
-  fastruby(:fastruby_only => true) do
-    def +(b)
-      _static{INT2FIX(FIX2INT(self)+FIX2INT(b))}
-    end
-
-    def -(b)
-      _static{INT2FIX(FIX2INT(self)-FIX2INT(b))}
-    end
-  end
-end
-
 class X
   def foo(a,b)
 		return a+b
@@ -50,6 +38,9 @@ Benchmark::bm(20) do |b|
   Y.optimize(:bar)
   X.build([X,Fixnum,Fixnum],:foo)
   Y.build([Y,X],:bar)
+  Fixnum.build([Fixnum,Fixnum],:-)
+  Fixnum.build([Fixnum,Fixnum],:>)
+  Fixnum.build([Fixnum,Fixnum],:+)
 
 	b.report("fastruby") do
 		y.bar(x)

data/benchmarks/benchmark8.rb

@@ -0,0 +1,48 @@
+require "rubygems"
+require "fastruby"
+
+class X
+  def foo(a,b)
+		return a+b
+	end
+end
+
+class Y
+	def bar(x)
+		i = 1000000
+
+    # removed lvar_type (see benchmark.rb)
+			
+		ret = 0
+		while i > 0
+			ret = x.foo(i,i)
+			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(:foo)
+  Y.optimize(:bar)
+  X.build([X,Fixnum,Fixnum],:foo)
+  Y.build([Y,X],:bar)
+  Fixnum.build([Fixnum,Fixnum],:-)
+  Fixnum.build([Fixnum,Fixnum],:>)
+  Fixnum.build([Fixnum,Fixnum],:+)
+
+	b.report("fastruby") do
+		y.bar(x)
+	end
+end

data/benchmarks/benchmark8.rb~

@@ -0,0 +1,46 @@
+require "rubygems"
+require "fastruby"
+
+class X
+  def foo(a,b)
+		return a+b
+	end
+end
+
+class Y
+	def bar(x)
+		i = 1000000
+			
+		ret = 0
+		while i > 0
+			ret = x.foo(i,i)
+			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(:foo)
+  Y.optimize(:bar)
+  X.build([X,Fixnum,Fixnum],:foo)
+  Y.build([Y,X],:bar)
+  Fixnum.build([Fixnum,Fixnum],:-)
+  Fixnum.build([Fixnum,Fixnum],:>)
+  Fixnum.build([Fixnum,Fixnum],:+)
+
+	b.report("fastruby") do
+		y.bar(x)
+	end
+end

data/lib/fastruby.rb

@@ -23,6 +23,7 @@ require "fastruby/object"
 require "fastruby/exceptions"
 require "fastruby/custom_require"
 require "fastruby/set_tree"
+require "continuation" if RUBY_VERSION =~ /^1\.9/
 require "base64"
 
 class Object
@@ -32,7 +33,7 @@ class Object
 end
 
 module FastRuby
-  VERSION = "0.0.21" unless defined? FastRuby::VERSION
+  VERSION = "0.0.22" unless defined? FastRuby::VERSION
 end
 
 require "fastruby/corelib"

data/lib/fastruby.rb~

@@ -23,6 +23,7 @@ require "fastruby/object"
 require "fastruby/exceptions"
 require "fastruby/custom_require"
 require "fastruby/set_tree"
+require "continuation" if RUBY_VERSION =~ /^1\.9/
 require "base64"
 
 class Object
@@ -32,7 +33,7 @@ class Object
 end
 
 module FastRuby
-  VERSION = "0.0.20" unless defined? FastRuby::VERSION
+  VERSION = "0.0.21" unless defined? FastRuby::VERSION
 end
 
 require "fastruby/corelib"

data/lib/fastruby/builder.rb

@@ -34,7 +34,22 @@ require FastRuby.fastruby_load_path + "/../ext/fastruby_base/fastruby_base"
 module FastRuby
   class Method
     attr_accessor :options
-
+    
+    def self.observe_method_name(mname, &blk)
+      @observers ||= Hash.new
+      @observers[mname] = @observers[mname] || Array.new
+      @observers[mname] << lambda(&blk)
+    end
+    
+    def self.notify_method_name(mname)
+      return unless @observers
+      return unless @observers[mname]
+      
+      @observers[mname].each do |obs|
+        obs.call
+      end
+    end
+        
     def initialize(method_name, owner)
       @method_name = method_name
       @owner = owner
@@ -46,6 +61,8 @@ module FastRuby
     end
     
     def tree_changed
+      FastRuby::Method.notify_method_name(@method_name)
+      
       @observers.values.each do |observer|
         observer.call(self)
       end

data/lib/fastruby/builder.rb~

@@ -34,7 +34,22 @@ require FastRuby.fastruby_load_path + "/../ext/fastruby_base/fastruby_base"
 module FastRuby
   class Method
     attr_accessor :options
-
+    
+    def self.observe_method_name(mname, &blk)
+      @observers ||= Hash.new
+      @observers[mname] = @observers[mname] || Array.new
+      @observers[mname] << lambda(&blk)
+    end
+    
+    def self.notify_method_name(mname)
+      return unless @observers
+      return unless @observers[mname]
+      
+      @observers[mname].each do |obs|
+        obs.call
+      end
+    end
+        
     def initialize(method_name, owner)
       @method_name = method_name
       @owner = owner
@@ -46,6 +61,8 @@ module FastRuby
     end
     
     def tree_changed
+      FastRuby::Method.notify_method_name(@method_name)
+      
       @observers.values.each do |observer|
         observer.call(self)
       end
@@ -181,10 +198,6 @@ module FastRuby
         context.locals = FastRuby::GetLocalsProcessor.get_locals(inlined_tree)
       
         FastRuby.logger.info "Compiling #{@owner}::#{@method_name} for signature #{signature.inspect}"
-
-if @method_name == :bar
-  print inlined_tree.to_ruby
-end
         c_code = context.to_c_method(inlined_tree,signature)
    
         unless options[:main]

data/lib/fastruby/modules/lvar_type/lasgn.rb~

@@ -0,0 +1,41 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+require "define_method_handler"
+ 
+module FastRuby
+  class LvarType
+    
+    
+    define_method_handler(:process) {|tree|
+      @current_index = (@current_index || 1) + 1
+      varname = "lvar_type_tmp_#{@current_index}".to_sym
+      class_condition = fs("_static{CLASS_OF(_a) == ::#{@infer_lvar_map[tree[1]].to_s}._invariant }", :_a => fs(:lvar,varname))
+
+      fs(:block,
+            fs(:lasgn, varname, tree[2]),
+            fs(:if, class_condition, fs(:lasgn, tree[1], fs(:lvar, varname.to_sym)), fs('_raise(FastRuby::TypeMismatchAssignmentException, "")') )
+            )
+      }.condition{|tree| tree && 
+        tree.node_type == :lasgn &&
+        tree.size == 3 &&
+        @infer_lvar_map[tree[1]] }
+  end
+end

data/lib/fastruby/modules/translator/block.rb

@@ -23,7 +23,7 @@ module FastRuby
 
     define_translator_for(:yield, :method => :to_c_yield, :arity => 1)
     def to_c_yield(tree)
-
+      @has_yield = true
       block_code = proc { |name| "
         static VALUE #{name}(VALUE frame_param, VALUE* block_args, int size) {
 

data/lib/fastruby/modules/translator/block.rb~

@@ -0,0 +1,128 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+module FastRuby
+  class Context
+
+    define_translator_for(:yield, :method => :to_c_yield, :arity => 1)
+    def to_c_yield(tree)
+      require "pry"; binding.pry
+      @has_yield = true
+      block_code = proc { |name| "
+        static VALUE #{name}(VALUE frame_param, VALUE* block_args, int size) {
+
+          #{@locals_struct} *plocals;
+          #{@frame_struct} *pframe;
+          pframe = (void*)frame_param;
+          plocals = (void*)pframe->plocals;
+
+          if ((plocals->block_function_address) == 0) {
+            #{_raise("rb_eLocalJumpError", "no block given")};
+          } else {
+            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))(plocals->block_function_address))(size, block_args, (VALUE)(plocals->block_function_param), (VALUE)pframe);
+          }
+        }
+      "
+      }
+
+      splat_arg = tree.find{|x| x == :yield ? false : x[0] == :splat}
+
+      protected_block(false) do
+        if splat_arg
+          "
+            VALUE splat_array = Qnil;
+            VALUE block_aux = Qnil;
+             #{to_c(splat_arg[1], "splat_array")};
+            
+            if (CLASS_OF(splat_array) == rb_cArray) {
+              VALUE block_args[_RARRAY_LEN(splat_array) + #{tree.size}];
+              int i;
+              #{ 
+                (0..tree.size-3).map{|i|
+                  "
+                  #{to_c(tree[i+1], "block_aux")};
+                  block_args[#{i}] = block_aux;
+                  "
+                }.join(";\n")
+              };
+              
+              for (i=0; i<_RARRAY_LEN(splat_array); i++) {
+                block_args[i+#{tree.size-2}] = rb_ary_entry(splat_array,i);
+              }
+              
+              last_expression = #{anonymous_function(&block_code)}((VALUE)pframe, block_args, _RARRAY_LEN(splat_array) + #{tree.size-2});
+            } else {
+              VALUE block_args[1+#{tree.size}];
+              #{ 
+                (0..tree.size-3).map{|i|
+                  "
+                  #{to_c(tree[i+1], "block_aux")};
+                  block_args[#{i}] = block_aux;
+                  "
+                }.join(";\n")
+              };
+              
+              block_args[#{tree.size-2}] = splat_array;
+              last_expression = #{anonymous_function(&block_code)}((VALUE)pframe, block_args, #{tree.size-1});
+            }
+            
+          "
+        else
+          if tree.size > 1
+              "last_expression = " + anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}},#{tree.size-1})"
+            else
+              "last_expression = " + anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){}, #{tree.size-1})"
+            end
+        end
+      end
+    end
+
+    define_translator_for(:block, :method => :to_c_block)
+    def to_c_block(tree, result_variable = nil)
+      if tree.size == 1
+        return inline_block("return Qnil;")
+      end
+
+      code = proc{
+        
+        str = tree[1..-2].map{ |subtree|
+          to_c(subtree,"last_expression")
+        }.join(";")
+  
+        if tree[-1]
+            str = str + ";#{to_c(tree[-1],"last_expression")};"
+        end
+  
+        if result_variable
+          str << "#{result_variable} = last_expression;"
+        else
+          str << "return last_expression;"
+        end
+        str
+      }
+  
+      if result_variable
+        code.call
+      else
+        inline_block &code
+      end
+    end
+  end
+end

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

@@ -106,6 +106,8 @@ module FastRuby
 
         if args.last[0] == :splat
           aux_varname = "_aux_" + rand(1000000).to_s
+
+          @has_inline_block = true
           code = protected_block(
             "
             
@@ -152,55 +154,37 @@ module FastRuby
           end
         end
       end
+      
+      signature = if recvtype
+        [recvtype]
+      else
+        [nil]
+      end 
+
+      args[1..-1].each do |arg|
+        argtype = infer_type(arg)
+        signature << argtype
+      end
+      
+      if block_pass_arg
 
-      if recvtype
-
-        address = nil
-        mobject = nil
-
-        inference_complete = true
-        signature = [recvtype]
-
-        args[1..-1].each do |arg|
-          argtype = infer_type(arg)
-          signature << argtype
-          unless argtype
-            inference_complete = false
-          end
-        end
-
-        if repass_var
-          extraargs = ","+repass_var
-          extraargs_signature = ",VALUE " + repass_var
-        else
-          extraargs = ""
-          extraargs_signature = ""
-        end
-
-          block_proc_tree = s(:call, block_pass_arg[1], :to_proc, s(:arglist)) if block_pass_arg
-
-          block_wrapping_proc = proc { |name| "
-            static VALUE #{name}(int argc, VALUE* argv, VALUE _locals, VALUE _parent_frame) {
-              return rb_proc_call(_locals, rb_ary_new4(argc, argv)); 
-            }
-          "
+        block_proc_tree = s(:call, block_pass_arg[1], :to_proc, s(:arglist))
+        block_wrapping_proc = proc { |name| "
+          static VALUE #{name}(int argc, VALUE* argv, VALUE _locals, VALUE _parent_frame) {
+            return rb_proc_call(_locals, rb_ary_new4(argc, argv)); 
           }
- 
+        "
+        }
+                
+        code = inline_block do 
           if argnum == 0
-            value_cast = "VALUE,VALUE,VALUE"
-
-
-              if block_pass_arg or result_var
-                code = proc{ "
-                {
-                VALUE recv = Qnil;
-                #{to_c recv, "recv"};
-
-                #{@block_struct} block, *pblock = Qfalse;
+            "
+            #{@block_struct} block, *pblock = Qfalse;
+            
+            VALUE proc = Qnil;
+            VALUE recv = Qnil;
 
-                #{if block_pass_arg
-                "
-                VALUE proc = Qnil;
+                #{to_c(recv, "recv")}
                 #{to_c(block_proc_tree, "proc") }
 
                 VALUE block_address_value = rb_ivar_get(proc, #{intern_num "__block_address"});
@@ -217,61 +201,21 @@ module FastRuby
                   block.proc = proc;
                   pblock = &block;
                 }
-
-                "
-                end
-                }
-
-                #{if result_var
-                "
-                #{result_var} = ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, 0, (VALUE[]){});
-                "
-                else
-                "
-                ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, 0, (VALUE[]){});
-                "
-                end
-                }
-                }
-                "
-                }
-              
-                result_var ? code.call : inline_block(&code)
-              else
-                 "((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, 0, (VALUE[]){})"               
-              end          
-
+            
+            return #{dynamic_call(signature,mname)}(recv, (void*)pblock, (void*)pframe, 0, (VALUE[]){});" 
           else
-            value_cast = ( ["VALUE"]*(args.size) ).join(",") + ",VALUE,VALUE"
-            suffix = "_" + rand(1000000).to_s+"_"
-
-                strargs = (0..args_tree.size-2).map{|i| "#{suffix}arg#{i}"}.join(",")
-              if block_pass_arg or result_var
-                code = proc{ "
-                {
-                VALUE recv = Qnil;
-                
-                #{
-                (0..args_tree.size-2).map{ |x|
-                  "VALUE #{suffix}arg#{x};"
-                }.join("\n")
-                }
-
-                #{
-                (0..args_tree.size-2).map{ |x|
-                  to_c(args_tree[x+1], "#{suffix}arg#{x}") + ";"
-                }.join("\n")
-                }
-                
-                #{to_c recv, "recv"};
-
-                #{@block_struct} block, *pblock = Qfalse;
+            strargs = args[1..-1].map{|arg| to_c arg}.join(",")
+            "
+            #{@block_struct} block, *pblock = Qfalse;
+            
+            VALUE proc = Qnil;
+            VALUE recv = Qnil;
 
-                #{if block_pass_arg
-                "
-                VALUE proc = Qnil;
+                #{to_c(recv, "recv")}
                 #{to_c(block_proc_tree, "proc") }
+
                 VALUE block_address_value = rb_ivar_get(proc, #{intern_num "__block_address"});
+
                 if (block_address_value != Qnil) {
                   block.block_function_address = NUM2PTR(block_address_value);
                   block.block_function_param = NUM2PTR(rb_ivar_get(proc, #{intern_num "__block_param"}));
@@ -284,56 +228,35 @@ module FastRuby
                   block.proc = proc;
                   pblock = &block;
                 }
-
-                "
-                end
-                }
-
-                #{if result_var
-                "
-                #{result_var} = ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, #{args.size-1}, (VALUE[]){#{strargs}});
-                "
-                else
-                "
-                ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, #{args.size-1}, (VALUE[]){#{strargs}});
-                "
-                end
-                }
-
-                
-                }
-                "
-                }
-                
-                result_var ? code.call : inline_block(&code)
-              else
-                strargs = args[1..-1].map{|arg| to_c arg}.join(",")
-                "((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, #{args.size-1}, (VALUE[]){#{strargs}})"
-              end
+            
+            
+            return #{dynamic_call(signature,mname)}(recv, (void*)pblock, (void*)pframe, #{args.size-1}, (VALUE[]){#{strargs}});"
           end
-
-      else # else recvtype
-        if argnum == 0
-          code = protected_block("last_expression = rb_funcall(#{to_c recv}, #{intern_num tree[2]}, 0)", true, repass_var)
-          if result_var
+        end
+        
+        return (if result_var
           "
-            #{result_var} = #{code};
+          #{result_var} = #{code};
           "
-          else
-            code
-          end
+        else
+          code
+        end)   
+      else
+        code = if argnum == 0
+          "#{dynamic_call(signature,mname)}(#{to_c recv}, (void*)Qfalse, (void*)pframe, 0, (VALUE[]){})" 
         else
           strargs = args[1..-1].map{|arg| to_c arg}.join(",")
-          code = protected_block("last_expression = rb_funcall(#{to_c recv}, #{intern_num tree[2]}, #{argnum}, #{strargs} )", true, repass_var)
-          if result_var
+          "#{dynamic_call(signature,mname)}(#{to_c recv}, (void*)Qfalse, (void*)pframe, #{args.size-1}, (VALUE[]){#{strargs}})"
+        end
+  
+        return (if result_var
           "
-            #{result_var} = #{code};
+          #{result_var} = #{code};
           "
-          else
-            code
-          end
-        end
-      end # if recvtype
+        else
+          code
+        end)        
+      end
     end
 
     define_translator_for(:call, :method => :to_c_attrasgn, :arity => 1)