fastruby 0.0.16 → 0.0.17

data/CHANGELOG

@@ -1,3 +1,19 @@
+0.0.17  Fixed bug of non-volatile variables on scopes calling setjmp
+
+    Fixed bug of native pointers encoding on 32 bits systems
+
+    peforrmance: implemented linear stack scopes when possible
+
+		performance: refactored C translation to avoid unecessary non-local jumps such return
+
+		performance: refactored C translation to avoid unecessary anonymous C functions
+
+		performance: Implemented direct call to CFUNC methods on ruby1.9
+
+		Added support for single methods (with "no class")
+
+		Fixed bug with default argument initialization and redo
+
 0.0.16	Limited (see known issues on README) support for ruby1.9-p180 (tested with rvm)
 
 		Support for ruby1.8-p334 (tested with rvm)
@@ -82,4 +98,4 @@
 
 0.0.2	Added missing sexp_processor dependency
 
-0.0.1	First test release
+0.0.1	First test release

data/Rakefile

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

data/ext/fastruby_base/fastruby_base.inl

@@ -37,7 +37,71 @@ struct FASTRUBYTHREADDATA {
 
 #ifdef RUBY_1_9
 
-void* rb_method_entry(VALUE klass, ID id);
+
+typedef enum {
+    NOEX_PUBLIC    = 0x00,
+    NOEX_NOSUPER   = 0x01,
+    NOEX_PRIVATE   = 0x02,
+    NOEX_PROTECTED = 0x04,
+    NOEX_MASK      = 0x06,
+    NOEX_BASIC     = 0x08,
+    NOEX_UNDEF     = NOEX_NOSUPER,
+    NOEX_MODFUNC   = 0x12,
+    NOEX_SUPER     = 0x20,
+    NOEX_VCALL     = 0x40,
+    NOEX_RESPONDS  = 0x80
+} rb_method_flag_t;
+
+typedef enum {
+    VM_METHOD_TYPE_ISEQ,
+    VM_METHOD_TYPE_CFUNC,
+    VM_METHOD_TYPE_ATTRSET,
+    VM_METHOD_TYPE_IVAR,
+    VM_METHOD_TYPE_BMETHOD,
+    VM_METHOD_TYPE_ZSUPER,
+    VM_METHOD_TYPE_UNDEF,
+    VM_METHOD_TYPE_NOTIMPLEMENTED,
+    VM_METHOD_TYPE_OPTIMIZED, /* Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING   /* wrapper for method_missing(id) */
+} rb_method_type_t;
+
+typedef struct rb_method_cfunc_struct {
+    VALUE (*func)(ANYARGS);
+    int argc;
+} rb_method_cfunc_t;
+
+typedef struct rb_method_attr_struct {
+    ID id;
+    VALUE location;
+} rb_method_attr_t;
+
+typedef struct rb_iseq_struct rb_iseq_t;
+
+typedef struct rb_method_definition_struct {
+    rb_method_type_t type; /* method type */
+    ID original_id;
+    union {
+	rb_iseq_t *iseq;            /* should be mark */
+	rb_method_cfunc_t cfunc;
+	rb_method_attr_t attr;
+	VALUE proc;                 /* should be mark */
+	enum method_optimized_type {
+	    OPTIMIZED_METHOD_TYPE_SEND,
+	    OPTIMIZED_METHOD_TYPE_CALL
+	} optimize_type;
+    } body;
+    int alias_count;
+} rb_method_definition_t;
+
+typedef struct rb_method_entry_struct {
+    rb_method_flag_t flag;
+    char mark;
+    rb_method_definition_t *def;
+    ID called_id;
+    VALUE klass;                    /* should be mark */
+} rb_method_entry_t;
+
+rb_method_entry_t* rb_method_entry(VALUE klass, ID id);
 void* rb_global_entry(ID id);
 
 typedef struct RNode {
@@ -106,6 +170,11 @@ static inline int stack_chunk_get_current_position(struct STACKCHUNK* sc) {
 	}
  }
 
+typedef struct {
+  int size;
+  void *p1,*p2,*p3,*p4,*p5;
+  VALUE data[0x10000];
+} generic_scope_t;
 
 static inline void* stack_chunk_alloc(struct STACKCHUNK* sc, int size){
 
@@ -171,6 +240,7 @@ static inline void* stack_chunk_alloc(struct STACKCHUNK* sc, int size){
 		address = sc->pages[page]+position_in_page;
 	}
 
+  ((generic_scope_t*)address)->size = size;
 	return address;
 }
 
@@ -178,11 +248,19 @@ static inline void stack_chunk_mark(struct STACKCHUNK* sc) {
 	// Mark local variables on each allocated page up to current_position
 	int i;
 
-	for (i=0; i<sc->current_position; i++) {
+	for (i=0; i<sc->current_position; ) {
 		int position_in_page = i & PAGE_MASK;
 		int page = i / PAGE_SIZE;
 
-		rb_gc_mark(sc->pages[page][position_in_page]);
+    generic_scope_t* scope = (void*)&(sc->pages[page][position_in_page]);
+
+    if (scope->size == 0) {
+      i = i + 1;
+    } else {
+  	  i = i + scope->size;
+      int j;
+      for (j=0;j<scope->size-6;j++) rb_gc_mark(scope->data[j]);
+    }
 	}
 }
 

data/lib/fastruby/fastruby_sexp.rb

@@ -21,5 +21,26 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 module FastRuby
   class FastRubySexp < Array
     alias node_type first
+    
+    def walk_tree(&block)
+      each do |subtree|
+        if subtree.instance_of? FastRubySexp
+          subtree.walk_tree(&block)
+        end
+      end
+      block.call(self)
+    end
+    
+    def find_tree(ndtype = nil)
+      walk_tree do |subtree|
+        if (not block_given?) || yield(subtree)
+          if (not ndtype) || ndtype == subtree.node_type
+            return subtree
+          end
+        end
+      end
+      
+      return nil
+    end
   end
 end

data/lib/fastruby/getlocals.rb

@@ -50,6 +50,7 @@ module FastRuby
 
       if tree[0] == :block_pass
         @locals << :__xblock_arguments
+        @locals << :__x_proc
       end
 
       tree.select{|subtree| subtree.instance_of? FastRuby::FastRubySexp}.each do |subtree|
@@ -63,4 +64,4 @@ module FastRuby
       processor.locals
     end
   end
-end
+end

data/lib/fastruby/object.rb

@@ -95,7 +95,7 @@ class Object
           if $last_obj_proc
             FastRuby.cache.register_proc(obj, $last_obj_proc)
           end
-          FastRuby.cache.execute(obj, self)
+          FastRuby.cache.execute(obj, self.kind_of?(Class) ? self : Object)
         rescue Exception => e
           p e
         end

data/lib/fastruby/sexp_extension.rb

@@ -19,6 +19,9 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 
 =end
 require "fastruby/fastruby_sexp"
+require "fastruby/sexp_extension_edges"
+require "ruby_parser"
+require "set"
 
 class Object
   def to_fastruby_sexp
@@ -27,14 +30,200 @@ class Object
 end
 
 module FastRuby
+  class Graph
+    attr_reader :edges
+    attr_reader :vertexes
+
+    def initialize(hash = {})
+      @edges = []
+      @vertexes = Set.new
+      @vertex_output = Hash.new
+
+      hash.each do |orig,v|
+        v.each do |dest|
+          add_edge(orig,dest)
+        end
+      end
+    end
+ 
+    def add_edge(orig,dest)
+      @vertexes << orig
+      @vertexes << dest
+
+      @vertex_output[orig] ||= Set.new
+      @vertex_output[orig] << dest
+
+      @edges << [orig,dest]
+    end
+
+    def each_vertex_output(vertex,&blk)
+      outputs = @vertex_output[vertex]
+      if outputs
+        blk ? outputs.each(&blk) : outputs
+      else
+        Set.new
+      end
+    end
+
+    def each_path_from(vertex, history = [])
+      outputs = each_vertex_output(vertex) - history.select{|h| h[0] == vertex }.map(&:last)
+      outputs.delete(vertex)
+
+      if outputs.count == 0
+        yield [vertex]
+        return
+      end      
+
+      outputs.each do |vo|
+        each_path_from(vo,history+[[vertex,vo]]) do |subpath|
+          yield [vertex]+subpath
+        end
+      end
+    end
+  end
+
   class FastRubySexp
     def self.from_sexp(value)
+      return nil if value == nil
+      return value if value.kind_of? FastRubySexp
+
       ary = FastRuby::FastRubySexp.new
       value.each do |x|
         ary << x.to_fastruby_sexp
       end
       ary
     end
+
+    def transform(&blk)
+      ret = FastRuby::FastRubySexp.from_sexp( blk.call(self) )
+
+      unless ret
+        ret = FastRuby::FastRubySexp.new
+        each{|st2|
+          if st2.respond_to?(:transform)
+            ret << st2.transform(&blk)
+          else
+            ret << st2
+          end
+        } 
+      end
+
+      ret
+    end
+
+    def self.parse(code)
+      from_sexp(RubyParser.new.parse(code))
+    end
+
+    def to_graph
+      graph = Graph.new
+      self.edges.each &graph.method(:add_edge)
+
+      if ENV['FASTRUBY_GRAPH_VERTEX_CHECK'] == '1' 
+        output_vertexes = [];
+
+        self.walk_tree do |subtree|
+          if graph.each_vertex_output(subtree).count == 0
+            # vertexes with no output
+            unless [:arglist,:scope].include? subtree.node_type 
+              output_vertexes << subtree
+              if output_vertexes.count > 1
+                raise RuntimeError, "invalid output vertexes #{output_vertexes.map &:node_type}"
+              end
+            end
+          end
+        end
+      end
+
+      graph
+    end
+
+    def edges
+      Edges.new(self)
+    end
+
+    def first_tree
+      if respond_to? "first_tree_#{node_type}" 
+        send("first_tree_#{node_type}")
+      else
+        return self[1].first_tree if self.count == 2 and self[1].respond_to? :node_type
+        return self[1].first_tree if [:if,:block,:while,:until,:or,:and,:ensure].include? node_type
+        return self[2].first_tree if [:lasgn,:iasgn,:gasgn,:cdecl].include? node_type
+
+        self
+      end    
+    end
+
+    def first_tree_rescue
+      if self[1].node_type == :resbody
+        return self
+      else
+        return self[1].first_tree
+      end
+    end
+    
+    def first_tree_return
+      self[1] ? self[1].first_tree : self
+    end
+
+    alias first_tree_break first_tree_return
+    alias first_tree_next first_tree_return 
+
+    def first_tree_yield
+      if self.size > 1
+        self[-1].first_tree
+      else
+        self
+      end
+    end
+
+    def first_tree_iter
+      call_tree = self[1]
+      recv = call_tree[1]
+      if recv
+        recv.first_tree
+      else
+        args_tree = call_tree[3]
+        if args_tree.size > 1
+          args_tree[1].first_tree
+        else
+          call_tree
+        end
+      end
+    end
+
+    def first_tree_call
+      recv = self[1]
+      if recv
+        recv.first_tree
+      else
+        args_tree = self[3]
+        if args_tree.size > 1
+          args_tree[1].first_tree
+        else
+          self
+        end
+      end
+    end
+
+    def find_break(&blk)
+      subarray = if node_type == :while
+        []
+      elsif node_type == :iter
+        self[1..-2]
+      elsif node_type == :break
+        blk.call(self)
+        return; nil
+      else
+        self[1..-1]
+      end
+
+      subarray.each do |subtree|
+        if subtree.respond_to? :find_break
+          subtree.find_break(&blk)
+        end 
+      end
+    end
   end
 end
 

data/lib/fastruby/sexp_extension_edges.rb

@@ -0,0 +1,210 @@
+=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
+    class Edges
+      def initialize(frbsexp)
+        @frbsexp = frbsexp
+      end
+
+      def each(&blk)
+        node_type = @frbsexp.node_type
+
+        @frbsexp.each do|st|
+          next unless FastRubySexp === st
+          st.edges.each(&blk)
+        end
+
+        if respond_to? "edges_#{node_type}"
+          send("edges_#{node_type}", &blk)
+        end
+      end
+
+      def edges_lasgn(&blk)
+        blk.call(@frbsexp[2],@frbsexp)        
+      end
+
+      alias edges_gasgn edges_lasgn
+      alias edges_cdecl edges_lasgn
+      alias edges_iasgn edges_lasgn
+
+      def edges_ensure(&blk)
+        if @frbsexp.size > 2
+          @frbsexp[1].walk_tree do |subtree|
+            if subtree.node_type == :call or subtree.node_type == :iter
+              blk.call(subtree,@frbsexp[2].first_tree)
+            end
+          end
+
+          blk.call(@frbsexp[2],@frbsexp)
+        else
+          blk.call(@frbsexp[1],@frbsexp)
+        end
+      end
+
+      def edges_rescue(&blk)
+        return if @frbsexp[1].node_type == :resbody
+        
+        blk.call(@frbsexp[1],@frbsexp)
+
+        exit_tree = nil
+        resbody_array_tree = @frbsexp[2][1]
+
+        if resbody_array_tree.size > 1
+          exit_tree = resbody_array_tree[1].first_tree
+          lasgn_tree = resbody_array_tree.find{|st| 
+                if st.respond_to? :node_type
+                  st.node_type == :lasgn
+                else
+                  false
+                end
+          }
+
+          (1..resbody_array_tree.size-2).each do |i|
+            blk.call(resbody_array_tree[i], resbody_array_tree[i+1].first_tree)
+
+            if lasgn_tree
+              blk.call(resbody_array_tree[i], lasgn_tree.first_tree)
+            end 
+          end
+
+          if @frbsexp[2]
+            if @frbsexp[2][2]
+              blk.call(resbody_array_tree[-1],@frbsexp[2][2].first_tree)
+            else            
+              blk.call(resbody_array_tree[-1],@frbsexp)
+            end
+          else
+            blk.call(resbody_array_tree[-1],@frbsexp)
+          end
+        else
+          if @frbsexp[2]
+          if @frbsexp[2][2]
+            exit_tree = @frbsexp[2][2].first_tree
+          end
+          end
+        end
+
+        unless exit_tree
+          exit_tree = @frbsexp
+        end
+
+        if @frbsexp[2]
+          if @frbsexp[2][2]
+            blk.call(@frbsexp[2][2],@frbsexp)
+            blk.call(@frbsexp[1],exit_tree)
+            retry_tree = @frbsexp[2][2].find_tree(:retry)
+            if retry_tree
+              blk.call(retry_tree,@frbsexp[1].first_tree)
+            end
+          end
+        end
+
+        @frbsexp[1].walk_tree do |subtree|
+          if subtree.node_type == :call or subtree.node_type == :iter
+            blk.call(subtree,exit_tree)
+          end
+        end    
+
+      end
+
+      def edges_or(&blk)
+        (1..@frbsexp.size-2).each do |i|
+          blk.call(@frbsexp[i],@frbsexp[i+1].first_tree)
+        end
+
+        blk.call(@frbsexp[-1],@frbsexp)
+      end
+      alias edges_and edges_or
+  
+      def edges_if(&blk)
+        if @frbsexp[2]
+          blk.call(@frbsexp[1],@frbsexp[2].first_tree)
+          blk.call(@frbsexp[2],@frbsexp)
+        end
+
+        if @frbsexp[3]
+          blk.call(@frbsexp[3],@frbsexp)
+          blk.call(@frbsexp[1],@frbsexp[3].first_tree)
+        end
+
+        unless @frbsexp[2] and @frbsexp[3]
+          blk.call(@frbsexp[1],@frbsexp)
+        end     
+      end
+
+      def edges_scope(&blk)
+        blk.call(@frbsexp[1], @frbsexp)
+      end
+
+      def edges_while(&blk)
+        if @frbsexp[2]
+          blk.call(@frbsexp[1], @frbsexp[2].first_tree)
+          blk.call(@frbsexp[2], @frbsexp[1].first_tree)
+          @frbsexp[2].find_break do |subtree|
+            blk.call(subtree, @frbsexp)
+          end
+        end
+
+        blk.call(@frbsexp[1], @frbsexp)
+      end
+
+      alias edges_until edges_while
+
+      def edges_block(&blk)
+        (2..@frbsexp.size-1).each do |i|
+          blk.call(@frbsexp[i-1], @frbsexp[i].first_tree)
+        end
+        blk.call(@frbsexp.last, @frbsexp)
+      end
+
+      def edges_call(&blk)
+        args_tree = @frbsexp[3]
+
+        (2..args_tree.size-1).each do |i|
+          blk.call(args_tree[i-1], args_tree[i])
+        end
+
+        recv_tree = @frbsexp[1]
+        
+        if recv_tree
+          if args_tree.size > 1
+            blk.call(recv_tree, args_tree[1])
+          end
+        end
+
+        if args_tree.size > 1
+          blk.call(args_tree.last, @frbsexp)
+        end
+      end
+
+      def self.do_nothing_for(*nodename)
+        nodename.each do |nn|
+          define_method("edges_#{nn}") do
+          end
+        end
+      end
+
+      do_nothing_for(:nil,:lit,:break)
+    end
+  end
+end
+