fastruby 0.0.13 → 0.0.14

data/CHANGELOG

@@ -1,3 +1,9 @@
+0.0.14	Support for method replacement ("monkey patching")
+
+		Internal: Implemented method hash to store implementation pointers
+
+		Internal: Fixed inference of arguments on methods with splat arguments
+
 0.0.13	Argument splat method calls (not optimized yet)
 
 		Array arguments on methods (optional arguments, variable number of arguments)

data/README

@@ -57,10 +57,11 @@ I will stabilize the API and document it for next releases. I promise
 
 == Known Limitations & Issues
 
-* monkey patching does not work with fastruby methods
 * callcc is not supported, it works but using it may result in unexpected behaviour
 * recursive methods will be slow since the optimization of method calls only works with already defined methods
-* calls with blocks to ruby or cruby methods are almost as slow as normal ruby (if the called method is defined by fastruby, the call it's pretty fast)
+* calls with blocks to ruby or cruby methods are almost as slow as normal ruby (if the called method is defined by fastruby, the call is pretty fast)
+* When calling fastruby methods from normal ruby, the max. number of arguments allowed is 15
+* replacement of methods using identical code strings will work, but it will generate duplicated objects on the cache each time te snippet run
 
 == Usage
 

data/Rakefile

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

data/benchmarks/benchmark7.rb

@@ -0,0 +1,77 @@
+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)
+		if n > 1
+			n * factorial(n-1)
+		else
+			1
+		end
+	end
+end
+
+class Y2
+		def bar(x)
+			i = 100000
+			
+			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
+		y.bar(x)
+	end
+
+	b.report("ruby") do
+		y2.bar(x2)
+	end
+end

data/ext/fastruby_base/fastruby_base.c

@@ -1,5 +1,7 @@
 #include "fastruby_base.inl"
 
 void Init_fastruby_base() {
-	Init_stack_chunk();
+	init_stack_chunk();
+	init_class_extension();
+	init_fastruby_method();
 }

data/ext/fastruby_base/fastruby_base.inl

@@ -25,6 +25,13 @@ struct FASTRUBYTHREADDATA {
 	VALUE rb_stack_chunk;
 };
 
+struct METHOD {
+    VALUE klass, rklass;
+    VALUE recv;
+    ID id, oid;
+    int safe_level;
+    NODE *body;
+};
 
 static inline void stack_chunk_initialize(struct STACKCHUNK* sc) {
 	// initialize pointers with zeros
@@ -207,7 +214,7 @@ static inline struct FASTRUBYTHREADDATA* rb_current_thread_data() {
 	Data_Get_Struct(rb_thread_data,struct FASTRUBYTHREADDATA,thread_data);
 	return thread_data;
 }
-
+        
 static void init_stack_chunk() {
 
 	rb_mFastRuby = rb_define_module("FastRuby");
@@ -220,3 +227,74 @@ static void init_stack_chunk() {
 	rb_define_method(rb_cStackChunk, "alloc", rb_stack_chunk_alloc,1);
 }
 
+static VALUE clear_method_hash_addresses(VALUE klass,VALUE rb_method_hash) {
+
+  if (rb_method_hash != Qnil) {
+	  VALUE rb_values = rb_funcall(rb_method_hash, rb_intern("values"),0);
+	  void** address;
+	  int i;
+	  
+	  for (i = 0; i < RARRAY(rb_values)->len; i++) {
+	  	address = (void**)FIX2LONG(rb_ary_entry(rb_values,i));
+	  	*address = 0;
+	  }
+  }
+  
+  return Qnil;
+}
+
+static VALUE has_fastruby_function(VALUE self, VALUE rb_method_hash, VALUE mname) {
+	ID id = rb_intern(RSTRING(mname)->ptr);
+	VALUE tmp = rb_hash_aref(rb_method_hash, LONG2FIX(id));
+	
+	if (tmp != Qnil) {
+		void** address = (void**)FIX2LONG(tmp);
+		
+		if (*address == 0) {
+			return Qfalse;
+		} else {
+			return Qtrue;
+		}
+	}
+	
+	return Qfalse;
+}
+
+static void init_class_extension() {
+	VALUE rb_mFastRubyBuilderModule = rb_define_module_under(rb_mFastRuby, "BuilderModule");
+	rb_define_method(rb_mFastRubyBuilderModule, "clear_method_hash_addresses",clear_method_hash_addresses,1);
+	rb_define_method(rb_mFastRubyBuilderModule, "has_fastruby_function",has_fastruby_function,2);
+}
+
+static VALUE fastruby_method_tree(VALUE self) {
+	VALUE rb_tree_pointer = rb_ivar_get(self, rb_intern("@tree"));
+	if (rb_tree_pointer == Qnil) return Qnil;
+	VALUE* tree_pointer = (VALUE*)FIX2LONG(rb_tree_pointer);
+	return *tree_pointer;
+}
+
+static VALUE fastruby_method_tree_pointer(VALUE self) {
+	VALUE rb_tree_pointer = rb_ivar_get(self, rb_intern("@tree"));
+
+	if (rb_tree_pointer == Qnil) {
+		VALUE* tree_pointer = malloc(sizeof(VALUE*));
+		*tree_pointer = Qnil;
+		rb_tree_pointer = LONG2FIX(tree_pointer);
+		rb_ivar_set(self, rb_intern("@tree"), rb_tree_pointer);
+	}
+
+	return rb_tree_pointer;
+}
+
+static VALUE fastruby_method_tree_eq(VALUE self, VALUE val) {
+	VALUE* tree_pointer = (VALUE*)FIX2LONG(fastruby_method_tree_pointer(self));
+	*tree_pointer = val;
+	return Qnil;
+}
+
+static void init_fastruby_method() {
+	VALUE rb_cFastRubyMethod = rb_define_class_under(rb_mFastRuby, "Method", rb_cObject);
+	rb_define_method(rb_cFastRubyMethod, "tree_pointer", fastruby_method_tree_pointer,0);
+	rb_define_method(rb_cFastRubyMethod, "tree", fastruby_method_tree,0);
+	rb_define_method(rb_cFastRubyMethod, "tree=", fastruby_method_tree_eq,1);
+}

data/lib/fastruby/builder.rb

@@ -22,6 +22,9 @@ require "fastruby/inline_extension"
 require "fastruby/method_extension"
 require "fastruby/logging"
 require "fastruby/getlocals"
+require "fastruby_load_path"
+
+require FastRuby.fastruby_load_path + "/../ext/fastruby_base/fastruby_base"
 
 module FastRuby
 
@@ -43,7 +46,6 @@ module FastRuby
   end
 
   class Method
-    attr_accessor :tree
     attr_accessor :locals
     attr_accessor :options
     attr_accessor :snippet_hash
@@ -53,75 +55,28 @@ module FastRuby
       @owner = owner
     end
 
-    def method_from_signature(signature, inference_complete)
-      begin
-        recvtype = @owner
-        if recvtype.respond_to? :fastruby_method and inference_complete
+    def build(signature, noreturn = false)
+      return nil unless tree
+      
+      no_cache = false
 
-          method_tree = nil
-          begin
-            method_tree = recvtype.instance_method(@method_name.to_sym).fastruby.tree
-          rescue NoMethodError
-          end
+      mname = FastRuby.make_str_signature(@method_name, signature)
 
-          if method_tree
-            recvtype.build(signature, @method_name.to_sym)
-          else
-            recvtype.instance_method(@method_name.to_sym)
-          end
-        else
-          recvtype.instance_method(@method_name.to_sym)
+      if @owner.respond_to? :method_hash
+        method_hash = @owner.method_hash(@method_name.to_sym) || {}
+        if (@owner.has_fastruby_function(method_hash,mname.to_s))
+          FastRuby.logger.info "NOT Building #{@owner}::#{@method_name} for signature #{signature.inspect}, it's already done"
+          return nil
         end
-      rescue NameError
-        nil
       end
-    end
-
-    def convention(signature, inference_complete)
-        recvtype = @owner
-        if recvtype.respond_to? :fastruby_method and inference_complete
 
-          method_tree = nil
-          begin
-            method_tree = recvtype.instance_method(@method_name.to_sym).fastruby.tree
-          rescue NoMethodError, NameError
-          end
+      FastRuby.logger.info "Building #{@owner}::#{@method_name} for signature #{signature.inspect}"
 
-          if method_tree
-            
-            args_tree = method_tree[2]
-            
-            if args_tree.any?{|x|x.to_s.match(/\*/)}
-              :fastruby_array
-            else
-              :fastruby
-            end
-          else
-            :cruby
-          end
-        else
-          :cruby
-        end
-    end
-
-    def build(signature, noreturn = false)
+      
       require "fastruby/translator/translator"
       require "rubygems"
       require "inline"
 
-      no_cache = false
-
-      mname = FastRuby.make_str_signature(@method_name, signature)
-
-      begin
-        if (@owner.instance_method(mname))
-          FastRuby.logger.info "NOT Building #{@owner}::#{@method_name} for signature #{signature.inspect}, it's already done"
-          return @owner.instance_method(mname)
-        end
-      rescue NameError
-        FastRuby.logger.info "Building #{@owner}::#{@method_name} for signature #{signature.inspect}"
-      end
-
       context = FastRuby::Context.new
       context.locals = locals
       context.options = options
@@ -134,11 +89,17 @@ module FastRuby
 
       (1..signature.size).each do |i|
         arg = args_tree[i]
-        context.infer_lvar_map[arg] = signature[i]
+        if arg
+          if arg.to_s.match(/\*/)
+            context.infer_lvar_map[arg.to_s.gsub("*","").to_sym] = Array
+          else
+            context.infer_lvar_map[arg.to_sym] = signature[i]
+          end
+        end
       end
 
       context.infer_self = signature[0]
-      c_code = context.to_c_method(tree)
+      c_code = context.to_c_method(tree,signature)
 
       unless options[:main]
          context.define_method_at_init(@owner,@method_name, args_tree.size+1, signature)
@@ -213,16 +174,13 @@ module FastRuby
         FastRuby.cache.insert(snippet_hash, so_name) unless no_cache
       end
 
-      if noreturn then
-        nil
-      else
-        ret = @owner.instance_method(mname)
+      ret = Object.new
 
-        ret.extend MethodExtent
-        ret.yield_signature = context.yield_signature
+      ret.extend MethodExtent
+      ret.yield_signature = context.yield_signature
+
+      ret
 
-        ret
-      end
     end
 
     module MethodExtent
@@ -235,12 +193,22 @@ module FastRuby
       fastruby_method(method_name.to_sym).build(signature, noreturn)
     end
 
-    def convention(signature, method_name, inference_complete)
-      fastruby_method(method_name.to_sym).convention(signature, inference_complete)
+    def register_method_value(method_name,key,value)
+      @method_hash = Hash.new unless @method_hash
+      @method_hash[method_name] = Hash.new unless @method_hash[method_name]
+      @method_hash[method_name][key] = value
     end
-
-    def method_from_signature(signature, method_name, inference_complete)
-      fastruby_method(method_name.to_sym).method_from_signature(signature, inference_complete)
+    
+    def method_hash(method_name)
+      @method_hash = Hash.new unless @method_hash
+      @method_hash[method_name]
+    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
     end
 
     def fastruby_method(mname_)

data/lib/fastruby/object.rb

@@ -86,7 +86,7 @@ class Object
     else
 
       objs.sort{|x,y|
-          (y =~ /Inline_Object/ ? 1 : 0) - (x =~ /Inline_Object/ ? 1 : 0)
+          File.new(x).ctime <=> File.new(y).ctime
         }.each do |obj|
 
         begin

data/lib/fastruby/set_tree.rb

@@ -35,6 +35,12 @@ module FastRuby
       end
     end
   end
+  
+  def self.unset_tree(klass, method_name)
+    fastrubym = klass.fastruby_method(method_name)
+    fastrubym.tree = nil
+    nil
+  end
 
   def self.set_tree(klass, method_name, tree, snippet_hash, options = {})
     locals = Set.new

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

@@ -98,9 +98,8 @@ module FastRuby
 
         args[1..-1].each do |arg|
           argtype = infer_type(arg)
-          if argtype
-            signature << argtype
-          else
+          signature << argtype
+          unless argtype
             inference_complete = false
           end
         end

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

@@ -32,45 +32,9 @@ module FastRuby
       hash = Hash.new
       value_cast = ( ["VALUE"]*(args_tree.size+2) ).join(",")
       
-      multiple_arguments = args_tree[1..-1].find{|x| x.to_s =~ /\*/}
+      strmethodargs = "self,block,(VALUE)&frame"
       
-      args_array_accessors = if multiple_arguments
-        (0..args_tree.size-3).map{|x| "argv[#{x}]"} + ["argarray"]
-      else
-        (0..args_tree.size-2).map{|x| "argv[#{x}]"}
-      end
-      
-      strmethodargs = ""
-
-      if args_tree.size > 1
-        strmethodargs = "self,block,(VALUE)&frame,#{args_array_accessors.map(&:to_s).join(",") }"
-      else
-        strmethodargs = "self,block,(VALUE)&frame"
-      end
-      
-      strmakecall = if multiple_arguments
-                "
-                  if (argc_ > #{args_tree.size-2}) {
-                    VALUE argarray = rb_ary_new4(argc_-#{args_tree.size-2}, argv+#{args_tree.size-2});
-                    return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
-                  } else if (argc_ == #{args_tree.size-2}) {
-                    // pass pre-calculated method arguments plus an empty array
-                    VALUE argarray = rb_ary_new();
-                    return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
-                  } else {
-                    rb_raise(rb_eArgError, \"wrong number of arguments (%d for #{args_tree.size-2}))\", argc_);
-                  }
-                "
-              else
-                "if (argc_ == #{args_tree.size-1} && argc == #{args_tree.size+1}) {
-                  return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
-                } else {
-                  rb_raise(rb_eArgError, \"wrong number of arguments (%d for #{args_tree.size-1}))\", argc_);
-                }"
-              end
-
       anonymous_method_name = anonymous_function{ |anonymous_method_name| "VALUE #{anonymous_method_name}(int argc_, VALUE* argv, VALUE self) {
-
           VALUE klass = #{global_klass_variable};
           char method_name[0x100];
 
@@ -78,47 +42,58 @@ module FastRuby
           method_name[1] = 0;
 
           sprintf(method_name+1, \"#{method_name}\");
+          sprintf(method_name+strlen(method_name), \"%lu\", FIX2LONG(rb_obj_id(CLASS_OF(self))));
           
-          int i;
-          for (i=0; i<argc_; i++) {
-            sprintf(method_name+strlen(method_name), \"%lu\", FIX2LONG(rb_obj_id(CLASS_OF(argv[i]))));
-          }
+                      int i;
+                      for (i=0; i<argc_; i++) {
+                        sprintf(method_name+strlen(method_name), \"%lu\", FIX2LONG(rb_obj_id(CLASS_OF(argv[i]))));
+                      }
 
-          NODE* body;
+          void** address = 0;
+          void* fptr = 0;
           ID id;
+          VALUE rb_method_hash;
 
           id = rb_intern(method_name);
-          body = rb_method_node(klass,id);
+          rb_method_hash = rb_funcall(klass, #{intern_num :method_hash},1,#{literal_value method_name});
+          
+          if (rb_method_hash != Qnil) {
+            VALUE tmp = rb_hash_aref(rb_method_hash, LONG2FIX(id));
+            if (tmp != Qnil) {
+                address = (void**)FIX2LONG(tmp);
+                fptr = *address;
+            }
+          }
 
-          if (body == 0) {
-            VALUE argv_class[argc_+1];
+          if (fptr == 0) {
+                          VALUE argv_class[argc_+1];
+                          
+                          argv_class[0] = CLASS_OF(self); 
+                          for (i=0; i<argc_; i++) {
+                            argv_class[i+1] = CLASS_OF(argv[i]);
+                          }
+                          
+                          VALUE signature = rb_ary_new4(argc_+1,argv_class);
+            
+            rb_funcall(#{global_klass_variable}, #{intern_num :build}, 2, signature,rb_str_new2(#{method_name.to_s.inspect}));
+  
+            id = rb_intern(method_name);
+            rb_method_hash = rb_funcall(klass, #{intern_num :method_hash},1,#{literal_value method_name});
             
-            argv_class[0] = CLASS_OF(self); 
-            for (i=0; i<argc_; i++) {
-              argv_class[i+1] = CLASS_OF(argv[i]);
+            if (rb_method_hash != Qnil) {
+              VALUE tmp = rb_hash_aref(rb_method_hash, LONG2FIX(id));
+              if (tmp != Qnil) {
+                  address = (void**)FIX2LONG(tmp);
+                  fptr = *address;
+              }
             }
             
-            VALUE signature = rb_ary_new4(argc_+1,argv_class);
-            VALUE mobject = rb_funcall(#{global_klass_variable}, #{intern_num :build}, 2, signature,rb_str_new2(#{method_name.to_s.inspect}));
-
-            struct METHOD {
-              VALUE klass, rklass;
-              VALUE recv;
-              ID id, oid;
-              int safe_level;
-              NODE *body;
-            };
-
-            struct METHOD *data;
-            Data_Get_Struct(mobject, struct METHOD, data);
-            body = data->body;
-
-            if (body == 0) {
-              rb_raise(rb_eRuntimeError,\"method not found after build: '%s'\", method_name);
+            if (fptr == 0) {
+              rb_raise(rb_eRuntimeError, \"Error: method not found after build\");
             }
+
           }
 
-            if (nd_type(body) == NODE_CFUNC) {
               struct {
                 void* parent_frame;
                 void* plocals;
@@ -137,8 +112,6 @@ module FastRuby
               frame.thread_data = rb_current_thread_data();
               frame.targetted = 0;
 
-              int argc = body->nd_argc;
-
               VALUE block = Qfalse;
 
               if (rb_block_given_p()) {
@@ -166,10 +139,15 @@ module FastRuby
                 return Qnil;
               }
 
-              #{strmakecall}
-            }
+                  if (argc_ == 0) return ((VALUE(*)(VALUE,VALUE,VALUE))fptr)(#{strmethodargs});
+                    
+                  #{ (1..15).map{ |i|
+                    value_cast = ( ["VALUE"]*(i+3) ).join(",")
+                    "if (argc_ == #{i}) return ((VALUE(*)(#{value_cast}))fptr)(#{strmethodargs}, #{(0..i-1).map{|x| "argv[#{x}]"}.join(",")});"
+                    }.join("\n");
+                  }
 
-          return Qnil;
+              rb_raise(rb_eArgError, \"too many arguments: %d\", argc_);
         }"
       }
 
@@ -179,8 +157,9 @@ module FastRuby
       alt_options.delete(:main)
 
       inline_block "
+        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
+        
         #{global_klass_variable} = plocals->self;
-
         // set tree
         rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 5,
                 #{global_klass_variable},
@@ -191,7 +170,6 @@ module FastRuby
 
                 );
 
-        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
         "
 
     end

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

@@ -463,10 +463,9 @@ module FastRuby
 
         call_frame_struct_code = "
                 #{@block_struct} block;
-                #{@locals_struct} *plocals = (void*)param;
 
                 block.block_function_address = (void*)#{anonymous_function(&block_code)};
-                block.block_function_param = (void*)param;
+                block.block_function_param = (void*)plocals;
 
                 // create a call_frame
                 #{@frame_struct} call_frame;
@@ -534,48 +533,45 @@ module FastRuby
           };
           "        
 
-      if call_args_tree.size > 1 ? call_args_tree.last[0] == :splat : false
+      recvtype = nil if call_args_tree.size > 1 ? call_args_tree.last[0] == :splat : false
+      unless recvtype
         inline_block "
           #{funcall_call_code}
         "
       else
+        encoded_address = encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name)
 
-        if call_args_tree.size > 1
+        fastruby_call_code = if call_args_tree.size > 1
           value_cast = ( ["VALUE"]*(call_tree[3].size) ).join(",") + ", VALUE, VALUE"
 
-          str_called_code_args = call_tree[3][1..-1].map{|subtree| to_c subtree}.join(",")
-
-            caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param, VALUE pframe) {
+            "
                 // call to #{call_tree[2]}
                 #{call_frame_struct_code}
 
-                VALUE ret = ((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name)})(#{str_recv}, (VALUE)&block, (VALUE)&call_frame, #{str_called_code_args});
+                VALUE ret = ((VALUE(*)(#{value_cast}))#{encoded_address})(#{str_recv}, (VALUE)&block, (VALUE)&call_frame, #{str_called_code_args});
                 plocals->call_frame = old_call_frame;
                 return ret;
-              }
             "
-            }
-
         else
-            caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param, VALUE pframe) {
+            "
                 #{call_frame_struct_code}
 
                 // call to #{call_tree[2]}
-                VALUE ret = ((VALUE(*)(VALUE,VALUE,VALUE))#{encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name)})(#{str_recv}, (VALUE)&block, (VALUE)&call_frame);
+                VALUE ret = ((VALUE(*)(VALUE,VALUE,VALUE))#{encoded_address})(#{str_recv}, (VALUE)&block, (VALUE)&call_frame);
                 plocals->call_frame = old_call_frame;
                 return ret;
-              }
             "
-            }
         end
         
         inline_block "
-          if (#{convention_global_name}) {
-            return #{anonymous_function(&caller_code)}((VALUE)plocals, (VALUE)pframe);
-          } else {
+          if (#{@last_address_name} == 0) {
             #{funcall_call_code}
+          } else {
+            if (*#{@last_address_name} == 0) {
+              #{funcall_call_code}
+            } else {
+              #{fastruby_call_code}
+            }
           }
         "
       end