fastruby 0.0.19 → 0.0.20

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

@@ -21,6 +21,7 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 require "set"
 require "sexp"
 require "define_method_handler"
+require "fastruby/modules"
 
 module FastRuby
   class Reductor
@@ -28,12 +29,14 @@ module FastRuby
       define_method_handler(:reduce, options, &blk).condition{|tree| tree.respond_to?(:node_type) && tree.node_type == ntype}
     end
     
+    def call(*args)
+      reduce *args
+    end
+    
     define_method_handler(:reduce, :priority => -1000) do |tree|
       FastRubySexp.from_sexp(tree)
     end
     
-    Dir.glob(FastRuby.fastruby_load_path + "/fastruby/reductor/modules/**/*.rb").each do |path|
-      require path
-    end
+    FastRuby::Modules.load_all("reductor")
   end
 end

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

@@ -0,0 +1,42 @@
+=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 Reductor
+    def self.reduce_for(ntype, options = {}, &blk)
+      define_method_handler(:reduce, options, &blk).condition{|*x| tree = x.first;  tree.respond_to?(:node_type) && tree.node_type == ntype}
+    end
+    
+    def call(*args)
+      reduce args.first
+    end
+    
+    define_method_handler(:reduce, :priority => -1000) do |*x| tree = x.first; 
+      FastRubySexp.from_sexp(tree)
+    end
+    
+    FastRuby::Modules.load_all("reductor")
+  end
+end

data/lib/fastruby/builder.rb

@@ -22,19 +22,18 @@ require "fastruby/method_extension"
 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/builder/inliner"
+require "fastruby/builder/inferencer"
+require "fastruby/builder/lvar_type"
+require "fastruby/builder/pipeline"
+require "fastruby/builder/locals_inference"
+require "fastruby/builder/inference_updater"
 
 require FastRuby.fastruby_load_path + "/../ext/fastruby_base/fastruby_base"
 
 module FastRuby
   class Method
-    attr_accessor :locals
     attr_accessor :options
-    attr_accessor :snippet_hash
 
     def initialize(method_name, owner)
       @method_name = method_name
@@ -69,15 +68,22 @@ module FastRuby
       rebuild(signature, noreturn)
     end
     
+    def has_loops?(tree)
+      if tree.respond_to? :node_type
+        nt = tree.node_type
+        return false if nt == :defn or nt == :defs
+        return true if nt == :for or nt == :iter or nt == :while or nt == :retry
+        tree.each do |subtree|
+          return true if has_loops? subtree
+        end
+      end
+      false
+    end
+    
     def rebuild(signature, noreturn = false)
       no_cache = false
       mname = FastRuby.make_str_signature(@method_name, signature)
 
-      inliner = FastRuby::Inliner.new
-
-      context = FastRuby::Context.new
-      context.options = options
-
       args_tree = if tree[0] == :defn
          tree[2]
       elsif tree[0] == :defs
@@ -85,10 +91,15 @@ module FastRuby
       else
         raise ArgumentError, "unknown type of method definition #{tree[0]}"
       end
+      
+      impl_tree = if tree[0] == :defn
+        tree[3]
+      elsif tree[0] == :defs
+        tree[4]
+      end
 
       # create random method name
-      context.snippet_hash = snippet_hash
-      context.alt_method_name = "_" + @method_name.to_s + "_" + rand(10000000000).to_s
+      infer_lvar_map = Hash.new
 
       (1..signature.size-1).each do |i|
         arg = args_tree[i]
@@ -97,26 +108,48 @@ module FastRuby
           
           if arg
             if arg.to_s.match(/\*/)
-              context.infer_lvar_map[arg.to_s.gsub("*","").to_sym] = Array
+              infer_lvar_map[arg.to_s.gsub("*","").to_sym] = Array
             else
-              context.infer_lvar_map[arg.to_sym] = signature[i]
+              infer_lvar_map[arg.to_sym] = signature[i]
             end
           end
         end
       end
 
-      context.infer_self = signature[0]
+      inferencer = Inferencer.new
+      inferencer.infer_self = signature[0]
       
-      inliner.infer_self = context.infer_self
-      inliner.infer_lvar_map = context.infer_lvar_map
-
-      inlined_tree = inliner.inline(tree)
-      context.locals = locals + inliner.extra_locals
+      locals_inference = LocalsInference.new
+      locals_inference.infer_self = signature[0]
+      locals_inference.infer_lvar_map = infer_lvar_map
+      
+      inference_updater = InferenceUpdater.new(inferencer)
+      
+      inliner = FastRuby::Inliner.new(inferencer)
+      pipeline = Pipeline.new
+      
+      if options[:validate_lvar_types]
+        pipeline << LvarType.new(locals_inference)
+      end
+      pipeline << locals_inference
       
-      inliner.extra_inferences.each do |local, itype|
-        context.infer_lvar_map[local] = itype
+      if has_loops?(impl_tree)
+        pipeline << inliner
+        if options[:validate_lvar_types]
+          pipeline << LvarType.new(locals_inference)
+        end
+  
+        pipeline << inference_updater
+        pipeline << inliner
+        if options[:validate_lvar_types]
+          pipeline << LvarType.new(locals_inference)
+        end
+  
+        pipeline << inference_updater
       end
       
+      inlined_tree = pipeline.call(tree)
+
       inliner.inlined_methods.each do |inlined_method|
         inlined_method.observe("#{@owner}##{@method_name}#{mname}") do |imethod|
           rebuild(signature, noreturn)
@@ -133,6 +166,20 @@ module FastRuby
 
       $last_obj_proc = nil
       if paths.empty?
+        unless Object.respond_to? :inline
+          require "rubygems"
+          require "inline"
+          require "fastruby/inline_extension"
+        end
+        
+        unless defined? FastRuby::Context
+          require "fastruby/translator/translator"
+        end
+        
+        context = FastRuby::Context.new(true, inferencer)
+        context.options = options
+        context.locals = FastRuby::GetLocalsProcessor.get_locals(inlined_tree)
+      
         FastRuby.logger.info "Compiling #{@owner}::#{@method_name} for signature #{signature.inspect}"
         c_code = context.to_c_method(inlined_tree,signature)
    
@@ -248,8 +295,9 @@ module FastRuby
       @method_hash = Hash.new unless @method_hash
       @method_hash[method_name]
     end
-    
+
     def method_added(method_name)
+      clear_method_hash_addresses(@method_hash[method_name]) if @method_hash and @method_hash[method_name]
       FastRuby.unset_tree(self,method_name)
     end
 

data/lib/fastruby/builder.rb~

@@ -0,0 +1,311 @@
+=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 "fastruby/method_extension"
+require "fastruby/logging"
+require "fastruby/getlocals"
+require "fastruby_load_path"
+require "fastruby/builder/inliner"
+require "fastruby/builder/inferencer"
+require "fastruby/builder/lvar_type"
+require "fastruby/builder/pipeline"
+require "fastruby/builder/locals_inference"
+require "fastruby/builder/inference_updater"
+
+require FastRuby.fastruby_load_path + "/../ext/fastruby_base/fastruby_base"
+
+module FastRuby
+  class Method
+    attr_accessor :options
+
+    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
+      mname = FastRuby.make_str_signature(@method_name, signature)
+
+      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
+      end
+
+      rebuild(signature, noreturn)
+    end
+    
+    def has_loops?(tree)
+      if tree.respond_to? :node_type
+        nt = tree.node_type
+        return false if nt == :defn or nt == :defs
+        return true if nt == :for or nt == :iter or nt == :while or nt == :retry
+        tree.each do |subtree|
+          return true if has_loops? subtree
+        end
+      end
+      false
+    end
+    
+    def rebuild(signature, noreturn = false)
+      no_cache = false
+      mname = FastRuby.make_str_signature(@method_name, signature)
+
+      args_tree = if tree[0] == :defn
+         tree[2]
+      elsif tree[0] == :defs
+         tree[3]
+      else
+        raise ArgumentError, "unknown type of method definition #{tree[0]}"
+      end
+      
+      impl_tree = if tree[0] == :defn
+        tree[3]
+      elsif tree[0] == :defs
+        tree[4]
+      end
+
+      # create random method name
+      infer_lvar_map = Hash.new
+
+      (1..signature.size-1).each do |i|
+        arg = args_tree[i]
+        
+        if arg.instance_of? Symbol
+          
+          if arg
+            if arg.to_s.match(/\*/)
+              infer_lvar_map[arg.to_s.gsub("*","").to_sym] = Array
+            else
+              infer_lvar_map[arg.to_sym] = signature[i]
+            end
+          end
+        end
+      end
+
+      inferencer = Inferencer.new
+      inferencer.infer_self = signature[0]
+      
+      locals_inference = LocalsInference.new
+      locals_inference.infer_self = signature[0]
+      locals_inference.infer_lvar_map = infer_lvar_map
+      
+      inference_updater = InferenceUpdater.new(inferencer)
+      
+      inliner = FastRuby::Inliner.new(inferencer)
+      pipeline = Pipeline.new
+      
+      if options[:validate_lvar_types]
+        pipeline << LvarType.new(locals_inference)
+      end
+      pipeline << locals_inference
+      
+      if has_loops?(impl_tree)
+        pipeline << inliner
+        if options[:validate_lvar_types]
+          pipeline << LvarType.new(locals_inference)
+        end
+  
+        pipeline << inference_updater
+        pipeline << inliner
+        if options[:validate_lvar_types]
+          pipeline << LvarType.new(locals_inference)
+        end
+  
+        pipeline << inference_updater
+      end
+      
+      inlined_tree = pipeline.call(tree)
+
+      inliner.inlined_methods.each do |inlined_method|
+        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)
+
+      $last_obj_proc = nil
+      if paths.empty?
+        unless Object.respond_to? :inline
+          require "rubygems"
+          require "inline"
+          require "fastruby/inline_extension"
+        end
+        
+        unless defined? FastRuby::Context
+          require "fastruby/translator/translator"
+        end
+        
+        context = FastRuby::Context.new(true, inferencer)
+        context.options = options
+        context.locals = FastRuby::GetLocalsProcessor.get_locals(inlined_tree)
+      
+        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
+          
+          @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
+        
+          unless no_cache
+            no_cache = context.no_cache
+          end
+    
+          unless no_cache
+            FastRuby.cache.insert(code_sha1, so_name)
+          end
+        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
+      
+      observe("#{@owner}##{@method_name}#{mname}") do |imethod|
+        if tree
+          rebuild(signature, noreturn)
+        end
+      end
+    end
+  end
+
+  module BuilderModule
+    def build(signature, method_name, noreturn = false)
+      fastruby_method(method_name.to_sym).build(signature, noreturn)
+    end
+
+    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_hash(method_name)
+      @method_hash = Hash.new unless @method_hash
+      @method_hash[method_name]
+    end
+
+    def method_added(method_name)
+      clear_method_hash_addresses(@method_hash[method_name]) if @method_hash and @method_hash[method_name]
+      FastRuby.unset_tree(self,method_name)
+    end
+
+    def fastruby_method(mname_)
+      mname = mname_.to_sym
+      @fastruby_method = Hash.new unless @fastruby_method
+      @fastruby_method[mname] = FastRuby::Method.new(mname,self) unless @fastruby_method[mname]
+      @fastruby_method[mname]
+    end
+  end
+end

data/lib/fastruby/corelib/fixnum.rb

@@ -0,0 +1,75 @@
+=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 "fastruby/sexp_extension"
+
+class Fixnum
+  fastruby(:fastruby_only => true, :skip_reduce => true) do
+    if RUBY_VERSION =~ /^1\\.9/
+      def +(b)
+        if b._class == Fixnum
+          _static{LONG2NUM(FIX2LONG(self)+FIX2LONG(b))}
+        elsif b._class == Bignum
+          _static{rb_big_plus(b,self)}
+        elsif b._class == Float
+          _static{DBL2NUM(FIX2LONG(self) + RFLOAT_VALUE(b))}
+        else
+          _static{rb_num_coerce_bin(self, b, inline_c("'+'"))}
+        end
+      end
+
+      def -(b)
+        if b._class == Fixnum
+          _static{LONG2NUM(FIX2LONG(self)-FIX2LONG(b))}
+        elsif b._class == Bignum
+          _static{rb_big_minus(rb_int2big(FIX2LONG(self)),b)}
+        elsif b._class == Float
+          _static{DBL2NUM(FIX2LONG(self) - RFLOAT_VALUE(b))}
+        else
+          _static{rb_num_coerce_bin(self, b, inline_c("'-'"))}
+        end
+      end
+
+      def >(y)
+        if y._class == Fixnum
+          _static{FIX2LONG(self)>FIX2LONG(y) ? true: false }
+        elsif y._class == Bignum
+          _static{FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(self)), y)) > 0 ? true : false}
+        elsif y._class == Float
+          _static{FIX2LONG(self) > RFLOAT_VALUE(y) ? true : false}
+        else
+          _static{rb_num_coerce_relop(self, y, inline_c("'>'"))}
+        end
+      end
+      
+      def <(y)
+        if y._class == Fixnum
+          _static{FIX2LONG(self)<FIX2LONG(y) ? true: false }
+        elsif y._class == Bignum
+          _static{FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(self)), y)) < 0 ? true : false}
+        elsif y._class == Float
+          _static{FIX2LONG(self) < RFLOAT_VALUE(y) ? true : false}
+        else
+          _static{rb_num_coerce_relop(self, y, inline_c("'<'"))}
+        end
+      end    
+    end
+  end
+end