fastruby 0.0.19 → 0.0.20

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.0.20  Fastruby implementation of some fixnum methods allowing inline it 
+
+    Improve and bug fixing on inline
+  
+    Syntantic sugar for fastruby method definitions (see README)
+
+    Internal design improvements, builder pipeline and translator decoupling
+
 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

data/{README → README.rdoc}

@@ -33,6 +33,12 @@ direct calls instead of normal and expensive ruby calls.
 
 The currently implementation only can infer types for method and block arguments, and for literals
 
+=== Method inlining
+
+Type information is used to inline methods by replacing calls with the implementation of method being called. This greatly increase the performance WITHOUT
+breaking the expected dynamics of ruby code (e.g. allow replace an inlined method), many of corelib methods was reimplemented with ruby to allow inline them
+and increase the performance of code using corelib methods (e.g. Fixnum methods)
+
 === Customization through build directives and API
 
 To compensate for the described limitations, fastruby suport a few build directives to allow the programmer help the inference.
@@ -61,7 +67,6 @@ I will stabilize the API and document it for next releases. I promise
 * fastruby on ruby1.8 is faster than ruby1.8 on a few cases (see benchmarks) but is slower than ruby1.9
 * callcc is not supported, it works but using it may result in unexpected behaviour
 * 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)
-* 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.19'
+  s.version = '0.0.20'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY
@@ -15,15 +15,15 @@ spec = Gem::Specification.new do |s|
   s.homepage = "http://github.com/tario/fastruby"
   s.add_dependency "RubyInline", "= 3.11.0"
   s.add_dependency "ruby_parser", ">= 2.0.6"
-  s.add_dependency "define_method_handler", ">= 0.0.5"
+  s.add_dependency "define_method_handler", ">= 0.0.6"
   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.extra_rdoc_files = [ 'README.rdoc' ]
   s.extensions = FileList["ext/**/extconf.rb"].to_a
-#  s.rdoc_options << '--main' << 'README'
+#  s.rdoc_options << '--main' << 'README.rdoc'
   s.files = Dir.glob("{benchmarks,examples,lib,spec}/**/*") + Dir.glob("ext/**/*.inl")+ Dir.glob("ext/**/*.c") + Dir.glob("ext/**/*.h") + Dir.glob("ext/**/extconf.rb") +
-    [ 'LICENSE', 'AUTHORS', 'README', 'Rakefile', 'TODO', 'CHANGELOG' ]
+    [ 'LICENSE', 'AUTHORS', 'README.rdoc', 'Rakefile', 'TODO', 'CHANGELOG' ]
 end
 
 desc 'Run tests'
@@ -35,8 +35,8 @@ end
 desc 'Generate RDoc'
 Rake::RDocTask.new :rdoc do |rd|
   rd.rdoc_dir = 'doc'
-  rd.rdoc_files.add 'lib', 'README'
-  rd.main = 'README'
+  rd.rdoc_files.add 'lib', 'README.rdoc'
+  rd.main = 'README.rdoc'
 end
 
 desc 'Build Gem'

data/benchmarks/benchmark.rb~

@@ -1,9 +1,21 @@
 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)
-		a+b
+		return a+b
 	end
 end
 
@@ -15,7 +27,7 @@ class Y
 			
 		ret = 0
 		while i > 0
-			ret = (i+i)
+			ret = x.foo(i,i)
 			i = i - 1
 		end
 		return ret

data/ext/fastruby_base/fastruby_base.inl

@@ -143,6 +143,10 @@ struct METHOD {
     NODE *body;
 };
 
+        
+RUBY_EXTERN void* ruby_current_thread;
+
+
 static inline void stack_chunk_initialize(struct STACKCHUNK* sc) {
 	// initialize pointers with zeros
 	memset(sc->pages, 0, sizeof(sc->pages));
@@ -351,16 +355,16 @@ static void init_stack_chunk() {
 	rb_define_singleton_method(rb_cStackChunk, "create", rb_stack_chunk_create,0);
 	rb_define_method(rb_cStackChunk, "alloc", rb_stack_chunk_alloc,1);
 }
-
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
 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_LEN(rb_values); i++) {
-	  	address = (void**)FIX2LONG(rb_ary_entry(rb_values,i));
-	  	*address = 0;
+	  	address = (void**)NUM2PTR(rb_ary_entry(rb_values,i));
+      *address = 0;
 	  }
   }
   

data/lib/fastruby/builder/inference_updater.rb

@@ -0,0 +1,76 @@
+=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 InferenceUpdater
+    class AddInfer
+      attr_accessor :variable_hash
+      
+      define_method_handler(:process, :priority => 1) {|tree|
+          tree        
+        }.condition{|tree| (tree.node_type == :iter and tree[1][2] == :_static) or (tree.node_type == :call and tree[2] == :infer) }
+        
+      define_method_handler(:process, :priority => -1) {|tree|
+          tree.map{|subtree| process subtree}
+        }.condition{|tree| tree.respond_to?(:node_type) }
+
+      define_method_handler(:process, :priority => 1) {|tree|
+          tree
+        }.condition{|tree| not tree.respond_to?(:node_type) }
+
+      define_method_handler(:process) {|tree|
+          fs(:call, tree, :infer, fs(:arglist, fs(:const, variable_hash[tree[1]].to_s.to_sym)))
+        }.condition{|tree| tree.node_type == :lvar and variable_hash[tree[1]] and variable_hash[tree[1]] != :dynamic}
+
+    end
+    
+    def initialize(inferencer)
+      @inferencer = inferencer
+    end
+    
+    def call(tree)
+      variable_hash = Hash.new
+      
+      # search variable assignments
+      tree.walk_tree do |subtree|
+        if subtree.node_type == :lasgn and subtree[2]
+          types = @inferencer.infer(subtree[2])
+          lname = subtree[1]
+          if types.size == 1
+            if variable_hash[lname]
+              if variable_hash[lname] != types.first
+                variable_hash[lname] = :dynamic
+              end
+            else
+              variable_hash[lname] = types.first
+            end
+          elsif types.size == 0
+            variable_hash[lname] = :dynamic
+          end 
+        end
+      end
+      
+      add_infer = AddInfer.new
+      add_infer.variable_hash = variable_hash
+      
+      add_infer.process(tree)
+    end
+  end
+end

data/lib/fastruby/builder/inference_updater.rb~

@@ -0,0 +1,76 @@
+=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 InferenceUpdater
+    class AddInfer
+      attr_accessor :variable_hash
+      
+      define_method_handler(:process, :priority => 1) {|tree|
+          tree        
+        }.condition{|tree| (tree.node_type == :iter and tree[1][2] == :_static) or (tree.node_type == :call and tree[2] == :infer) }
+        
+      define_method_handler(:process, :priority => -1) {|tree|
+          tree.map &method(:process)
+        }.condition{|tree| tree.respond_to?(:node_type) }
+
+      define_method_handler(:process, :priority => 1) {|tree|
+          tree
+        }.condition{|tree| not tree.respond_to?(:node_type) }
+
+      define_method_handler(:process) {|tree|
+          fs(:call, tree, :infer, fs(:arglist, fs(:const, variable_hash[tree[1]].to_s.to_sym)))
+        }.condition{|tree| tree.node_type == :lvar and variable_hash[tree[1]] and variable_hash[tree[1]] != :dynamic}
+
+    end
+    
+    def initialize(inferencer)
+      @inferencer = inferencer
+    end
+    
+    def call(tree)
+      variable_hash = Hash.new
+      
+      # search variable assignments
+      tree.walk_tree do |subtree|
+        if subtree.node_type == :lasgn and subtree[2]
+          types = @inferencer.infer(subtree[2])
+          lname = subtree[1]
+          if types.size == 1
+            if variable_hash[lname]
+              if variable_hash[lname] != types.first
+                variable_hash[lname] = :dynamic
+              end
+            else
+              variable_hash[lname] = types.first
+            end
+          elsif types.size == 0
+            variable_hash[lname] = :dynamic
+          end 
+        end
+      end
+      
+      add_infer = AddInfer.new
+      add_infer.variable_hash = variable_hash
+      
+      add_infer.process(tree)
+    end
+  end
+end

data/lib/fastruby/builder/inferencer.rb

@@ -0,0 +1,38 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+require "fastruby/modules"
+
+module FastRuby
+  class Inferencer
+    define_method_handler(:infer, :priority => -1000) do |tree|
+      []
+    end
+    
+    def self.define_infer_for(node_type, &blk)
+      define_method_handler(:infer, &blk).condition{|tree| tree.node_type == node_type}
+    end
+    
+    FastRuby::Modules.load_all("inferencer")
+  end
+end

data/lib/fastruby/{inliner → builder}/inliner.rb

@@ -18,51 +18,40 @@ 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 "set"
-require "sexp"
 require "define_method_handler"
+require "fastruby/modules"
 
 module FastRuby
   class Inliner
-    attr_accessor :infer_lvar_map
-    attr_accessor :infer_self
-    attr_reader :extra_locals
-    attr_reader :extra_inferences
     attr_reader :inlined_methods
-    
-    def initialize
-      @extra_locals = Set.new
-      @extra_inferences = Hash.new
+
+    def initialize(inferencer)
       @inlined_methods = Array.new
+      @inferencer = inferencer
     end
     
     define_method_handler(:inline, :priority => -1000) do |tree|
       FastRubySexp.from_sexp(tree)
     end
     
-    Dir.glob(FastRuby.fastruby_load_path + "/fastruby/inliner/modules/**/*.rb").each do |path|
-      require path
-    end
-    
-    def add_local(local)
-      @extra_locals << local
+    def call(*args)
+      if args.first.find_tree{|tree| tree.node_type == :call && tree[2] != :infer && infer_type(tree[1] || fs(:self))}
+        inline *args
+      else
+        args.first
+      end
     end
     
+    FastRuby::Modules.load_all("inliner")
+
     def infer_type(recv)
-      if recv[0] == :call
-        if recv[2] == :infer
-          eval(recv[3].last.last.to_s)
-        end
-      elsif recv[0] == :lvar
-        @infer_lvar_map[recv[1]]
-      elsif recv[0] == :self
-        @infer_self
-      elsif recv[0] == :str or recv[0] == :lit
-        recv[1].class
+      array = @inferencer.infer(recv).to_a
+      
+      if array.size == 1
+        array[0]
       else
         nil
       end
     end
-
   end
 end

data/lib/fastruby/builder/inliner.rb~

@@ -0,0 +1,60 @@
+=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"
+require "fastruby/modules"
+
+module FastRuby
+  class Inliner
+    attr_reader :inlined_methods
+
+    def initialize(inferencer)
+      @inlined_methods = Array.new
+      @inferencer = inferencer
+    end
+    
+    define_method_handler(:inline, :priority => -1000) do |tree|
+      FastRubySexp.from_sexp(tree)
+    end
+    
+    def call(*args)
+
+      return args.first
+
+      if args.first.find_tree{|tree| tree.node_type == :call && tree[2] != :infer && infer_type(tree[1] || fs(:self))}
+        inline *args
+      else
+        args.first
+      end
+    end
+    
+    FastRuby::Modules.load_all("inliner")
+
+    def infer_type(recv)
+      array = @inferencer.infer(recv).to_a
+      
+      if array.size == 1
+        array[0]
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/fastruby/builder/locals_inference.rb

@@ -0,0 +1,53 @@
+=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 LocalsInference
+    attr_accessor :infer_self
+    attr_accessor :infer_lvar_map
+    
+    def call(arg)
+      if arg.find_tree{|subtree| subtree.node_type == :lvar && @infer_lvar_map[subtree[1]]}
+        transform_block = proc do |tree|
+          if tree.node_type == :lvar
+            next tree unless @infer_lvar_map
+            lvar_type = @infer_lvar_map[tree[1]]
+            next tree unless lvar_type
+            fs(:call, tree, :infer, fs(:arglist, fs(:const, lvar_type.to_s.to_sym)))
+          elsif tree.node_type == :iter
+            if tree[1][2] == :_static
+              tree
+            end
+          elsif tree.node_type == :call
+            if tree[2] == :infer
+              tree[1]
+            end
+          else
+            nil
+          end
+        end
+        
+        arg.transform &transform_block
+      else      
+        arg
+      end
+    end
+  end
+end

data/lib/fastruby/builder/lvar_type.rb

@@ -0,0 +1,43 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+require "fastruby/modules"
+
+module FastRuby
+  class LvarType
+    def initialize(inferencer)
+      @infer_lvar_map = Hash.new
+      @inferencer = inferencer
+    end
+
+    def call(*args)
+      if args.first.find_tree{|tree| tree.node_type == :call && tree[2] == :lvar_type}
+        process *args
+      else
+        args.first
+      end
+    end
+    
+    FastRuby::Modules.load_all("lvar_type")
+  end
+end

data/lib/fastruby/builder/lvar_type.rb~

@@ -0,0 +1,44 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+require "fastruby/modules"
+
+module FastRuby
+  class LvarType
+    def initialize(inferencer)
+      @infer_lvar_map = Hash.new
+      @inferencer = inferencer
+    end
+
+    def call(*args)
+        p args.first
+     # if args.first.find_tree{|tree| tree.node_type == :call && tree[2] == :lvar_type}
+     #   process *args
+     # else
+        args.first
+     # end
+    end
+    
+    FastRuby::Modules.load_all("lvar_type")
+  end
+end

data/lib/fastruby/builder/pipeline.rb

@@ -0,0 +1,43 @@
+=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 Pipeline
+    def initialize
+      @array = Array.new
+    end
+    
+    def << (object)
+      @array << object
+    end
+      
+    def call(arg)
+      
+      last_result = arg 
+      @array.each do |processor|
+        last_result = processor.call(last_result)
+      end
+      
+      last_result
+    end
+  end
+end

data/lib/fastruby/builder/pipeline.rb~

@@ -0,0 +1,43 @@
+=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 Pipeline
+    def initialize
+      @array = Array.new
+    end
+    
+    def << (object)
+      @array << object
+    end
+    
+    def call(arg)
+      
+      last_result = arg 
+      @array.each do |processor|
+        last_result = processor.call(last_result)
+      end
+      
+      last_result
+    end
+  end
+end