fastruby 0.0.5 → 0.0.6

data/CHANGELOG

@@ -1,3 +1,5 @@
+0.0.6	Implemented cache of native libraries to speedup init, see README for more info
+
 0.0.5	Support for case..when..end
 
 		Fixes on wrapping/translation of fastruby frames through ruby calls

data/README

@@ -1,6 +1,6 @@
 = Fastruby - fast execution of ruby code
 
-Fastruby is a gem which allows to execute ruby code faster than normal (about 100X of the MRI1.8)
+Fastruby is a gem which allows to execute ruby code faster than normal (about 20X of the MRI1.8)
 
 Fastruby IS NOT a separated ruby interpreter. Then, the design is simple
 
@@ -47,6 +47,8 @@ sudo gem install fastruby
 
 == Documentation
 
+Overhead due new frame structure of reduce the speed to 20x (previously was near 100X). This refactor was necessary 
+to implement most of the common ruby constructions (blocks, yields, breaks, next, exceptions, etc...)
 Since this first version of fastruby is in part an spike/PoC, there is no stable API to document. 
 So, I recommend not to develop other software on top of fastruby since its API could change in any moment. 
 But I will try as much as possible keep the backward compatibility in the near future
@@ -55,13 +57,27 @@ I will stabilize the API and document it for next releases. I promise
 
 == Known Limitations & Issues
 
-* Bootstrap is very slow since this is a Poc :P
 * monkey patching does not work with fastruby 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)
 * does not support methods with variable number of arguments
 
 == Usage
 
+=== Environment variables
+
+FASTRUBY_LOG			define the output file of logging (default is standard output)
+FASTRUBY_LOG_LEVEL	define the logging level (default 3)
+FASTRUBY_NO_CACHE	set to 1 to disable the cache globally
+
+=== Fastruby options
+
+This options can be passed to fastruby when defining fastruby blocks
+
+:no_cache				set to true to disable cache (default: false)
+:validate_lvar_vars		enable runtime check of assignments of typed variable (default: disabled)
+
+== Code Examples
+
 The basic method is fastruby, fastruby takes a string with ruby code and compile it
 
 === Example 1: How invoke fastruby

data/Rakefile

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

data/lib/fastruby/builder.rb

@@ -18,7 +18,6 @@ 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/translator"
 require "fastruby/inline_extension"
 require "fastruby/method_extension"
 require "fastruby/logging"
@@ -40,31 +39,80 @@ module FastRuby
 
     context.alt_method_name = "singleton_" + method_name + rand(100000000).to_s
 
-    [context.extra_code + context.to_c_method_defs(tree), context.alt_method_name]
+    [context.extra_code + context.to_c_method_defs(tree), context.alt_method_name, context.init_extra]
   end
 
   class Method
     attr_accessor :tree
     attr_accessor :locals
     attr_accessor :options
+    attr_accessor :snippet_hash
 
     def initialize(method_name, owner)
       @method_name = method_name
       @owner = owner
     end
 
-    def build(signature)
-      mname = "_" + @method_name.to_s + signature.map(&:internal_value).map(&:to_s).join
+    def method_from_signature(signature, inference_complete)
+      begin
+        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
+          end
+
+          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)
+        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
+
+          if method_tree
+            :fastruby
+          else
+            :cruby
+          end
+        else
+          :cruby
+        end
+    end
+
+    def build(signature, noreturn = false)
+      require "fastruby/translator"
+      require "rubygems"
+      require "inline"
 
-      FastRuby.logger.info mname.to_s
+      no_cache = false
+
+      mname = FastRuby.make_str_signature(@method_name, signature)
 
       begin
         if (@owner.instance_method(mname))
-          FastRuby.logger.info "NOT Building #{self}::#{@method_name} for signature #{signature.inspect}, it's already done"
+          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 #{self}::#{@method_name} for signature #{signature.inspect}"
+        FastRuby.logger.info "Building #{@owner}::#{@method_name} for signature #{signature.inspect}"
       end
 
       context = FastRuby::Context.new
@@ -74,7 +122,8 @@ module FastRuby
       args_tree = tree[2]
 
       # create random method name
-      context.alt_method_name = mname
+      context.snippet_hash = snippet_hash
+      context.alt_method_name = "_" + @method_name.to_s + "_" + rand(10000000000).to_s
 
       (1..signature.size).each do |i|
         arg = args_tree[i]
@@ -82,24 +131,91 @@ module FastRuby
       end
 
       context.infer_self = signature[0]
-
       c_code = context.to_c_method(tree)
 
-      @owner.class_eval do
-        inline :C  do |builder|
-          builder.inc << context.extra_code
-          builder.include "<node.h>"
-          builder.c c_code
+      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
+      $last_obj_proc = nil
+
+      begin
+
+        @owner.class_eval do
+          inline :C  do |builder|
+            builder.inc << context.extra_code
+            builder.include "<node.h>"
+            builder.init_extra = context.init_extra
+
+              def builder.generate_ext
+                ext = []
+
+                if @include_ruby_first
+                  @inc.unshift "#include \"ruby.h\""
+                else
+                  @inc.push "#include \"ruby.h\""
+                end
+
+                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
+
+        if $last_obj_proc
+          unless options[:no_cache]
+            FastRuby.cache.register_proc(so_name, $last_obj_proc)
+          end
+          $last_obj_proc.call($class_self)
+        end
+
+      ensure
+        $class_self = old_class_self
+      end
+
+      unless no_cache
+        no_cache = context.no_cache
       end
 
-      ret = @owner.instance_method(mname)
+      unless options[:no_cache]
+        FastRuby.cache.insert(snippet_hash, so_name) unless no_cache
+      end
 
-      ret.extend MethodExtent
-      ret.yield_signature = context.yield_signature
+      if noreturn then
+        nil
+      else
+        ret = @owner.instance_method(mname)
 
-      ret
+        ret.extend MethodExtent
+        ret.yield_signature = context.yield_signature
 
+        ret
+      end
     end
 
     module MethodExtent
@@ -108,8 +224,16 @@ module FastRuby
   end
 
   module BuilderModule
-    def build(signature, method_name)
-      fastruby_method(method_name.to_sym).build(signature)
+    def build(signature, method_name, noreturn = false)
+      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)
+    end
+
+    def method_from_signature(signature, method_name, inference_complete)
+      fastruby_method(method_name.to_sym).method_from_signature(signature, inference_complete)
     end
 
     def fastruby_method(mname_)

data/lib/fastruby/cache/cache.rb

@@ -0,0 +1,86 @@
+=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 "sha1"
+require "fileutils"
+
+module FastRuby
+
+  def self.cache
+    @@cache = FastRuby::Cache.new(ENV['HOME']+"/.fastruby/") unless defined? @@cache
+    @@cache
+  end
+
+  class Cache
+    include FileUtils
+
+    def initialize(base_path)
+      @base_path = base_path
+      create_dir_if_not_exists(@base_path)
+    end
+
+    def hash_snippet(snippet, addition)
+      SHA1.hexdigest(snippet + addition)
+    end
+
+    def insert(hash,path)
+      create_hash_dir(hash)
+      dest = hash_dir(hash)
+      cp_r path, dest
+    end
+
+    def retrieve(hash)
+      create_hash_dir(hash)
+      dest = hash_dir(hash)
+      Dir[dest + "*.so"]
+    end
+
+    def register_proc(obj, value)
+      @proc_hash = Hash.new unless @proc_hash
+      @proc_hash[obj] = value
+    end
+
+    def execute(obj, param)
+      @proc_hash = Hash.new unless @proc_hash
+      if @proc_hash[obj]
+        @proc_hash[obj].call(param)
+      end
+    end
+private
+
+    def hash_dir(hash)
+      @base_path + "/#{hash[0..1]}/#{hash[2..-1]}/"
+    end
+
+    def create_hash_dir(hash)
+      create_dir_if_not_exists(@base_path + "/#{hash[0..1]}/")
+      create_dir_if_not_exists(@base_path + "/#{hash[0..1]}/#{hash[2..-1]}/")
+    end
+
+    def create_dir_if_not_exists(dest)
+      begin
+        Dir.mkdir(dest)
+      rescue Errno::EEXIST
+      end
+    end
+
+
+  end
+end

data/lib/fastruby/custom_require.rb

@@ -19,6 +19,9 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 
 =end
 module Kernel
+
+  alias original_require require
+
   def fastruby_require(path)
     if path =~ /\.so$/
       require(path)

data/lib/fastruby/exceptions.rb

@@ -21,4 +21,14 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 module FastRuby
   class TypeMismatchAssignmentException < Exception
   end
+
+  class Context
+    class UnwindFastrubyFrame < Exception
+      def initialize(ex,target_frame,return_value)
+        @ex = ex
+        @target_frame = target_frame
+        @return_value = return_value
+      end
+    end
+  end
 end

data/lib/fastruby/fastruby_sexp.rb

@@ -0,0 +1,25 @@
+=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 FastRubySexp < Array
+    alias node_type first
+  end
+end

data/lib/fastruby/getlocals.rb

@@ -18,8 +18,8 @@ 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 "rubygems"
 require "set"
+require "fastruby/fastruby_sexp"
 
 module FastRuby
   class GetLocalsProcessor
@@ -35,7 +35,7 @@ module FastRuby
        @locals << tree[1]
       end
 
-      tree.select{|subtree| subtree.instance_of? Sexp}.each do |subtree|
+      tree.select{|subtree| subtree.instance_of? FastRuby::FastRubySexp}.each do |subtree|
         process(subtree)
       end
     end