fastruby 0.0.1

data/README

@@ -0,0 +1,142 @@
+= 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 NOT a separated ruby interpreter. Then, the design is simple
+
+Fastruby IS NOT a DSL to generate C code using ruby or a Ruby to C translator, the goal of fastruby is to execute RUBY code
+
+*************************************************************************************************************
+
+The current version of fastruby is a Proof of Concept and it's not ready to go to production
+
+*************************************************************************************************************
+
+== Core Concepts
+
+=== Native build
+
+All code processed by fastruby ends with a native representation, in the current version, this is acomplished using RubyParser to parse rubycode. 
+The ruby code is translated to C and then processed with RubyInline
+
+=== Transparent multimethods (and multiblocks)
+
+The methods processed by fastruby has multiple internal implementations depending on the type of the arguments. 
+Each possible signature has a version of the method and this are built in runtime when the method is called with a new signature.
+The same concept will be applied to blocks (anonymous methods) in future releases
+
+=== Type inference
+
+Each version of a method is built for a specific signature, so, the builder can asume a type for the arguments and build method calls using that assumption.
+Whereever the translator can asume a type for a expression involved in a method call (used as argument or as receiver), this information can be used to encode 
+direct calls instead of normal and expensive ruby calls.
+
+The currently implementation only can infer types for method and block arguments, and for literals
+
+=== 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.
+The syntaxis of these directives are the same as normal ruby call (see examples)
+Also, fastruby will define a API to customize aspects of fastruby internals. E.g the build method to invoke the build of methods with a specific signature (see examples)
+
+== Installation
+
+The install is as simple as execute the well-known gem install:
+
+sudo gem install fastruby
+
+== Documentation
+
+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
+
+I will stabilize the API and document it for next releases. I promise
+
+== Known Limitations & Issues
+
+* fastruby only can be called from inside a class scope, and only can be used to define instance methods (no class methods)
+* fastruby invokations can't take more than one method
+* 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 singleton methods (both define & call)
+* does not support methods with variable number of arguments
+* does not support exception handling (rescue, ensure, etc...)
+
+== Usage
+
+The basic method is fastruby, fastruby takes a string with ruby code and compile it
+
+=== Example 1: How invoke fastruby
+
+  require "fastruby"
+  
+  class X
+    fastruby '
+    def foo
+      print "hello world\n"
+    end
+    '
+  end
+  
+  X.new.foo
+  
+=== Example 2: Prebuild
+
+Normally, the method is built at runtime when is called with a new signature, You can prebuild the method to prevent this when the method is called for first time
+
+  require "fastruby"
+  
+  class X
+    fastruby '
+    def foo(a,b)
+      a+b
+    end
+    '
+  end
+  
+  X.build([X,String,String] , :foo)
+  
+  p X.new.foo("fast", "ruby") # will use the prebuilded method
+  p X.new.foo(["fast"], ["ruby"]) # will build foo for X,Array,Array signature and then execute it
+
+=== Example 3: Explicit inference
+
+Current fastruby allows to explictly define a type for a expression, a basic example show as tell to fastruby to assume that the result of to_s is of type String in the following case:
+
+  require "fastruby"
+  
+  class X
+    fastruby '
+    def foo(a)
+      a.to_s.infer(String) + "_"
+    end
+    '
+  end
+  
+  p X.new.foo(9) 
+
+When fastruby can infer the type of an expression, the method calls that involve that expression can be accelerated. This is not necessary for arguments passed to a method or block
+
+=== Example 4: Variable types
+
+Like static languages, you can define a type for a variable to help the inference and gain some performance. This can be done by using lvar_type directive
+
+  class X
+    fastruby '
+    def foo
+      lvar_type(i, Fixnum)
+      i = 100
+      while (i > 0)
+	i = i - 1
+      end
+      nil
+    end
+    '
+  end
+  
+With no lvar_type, the calls to Fixnum#> and Fixnum#- will be dynamic and more expensive
+
+== Copying
+
+Copyright (c) 2011 Dario Seminara, released under the GPL License (see LICENSE)

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require "rspec/core/rake_task"
+
+spec = Gem::Specification.new do |s|
+  s.name = 'fastruby'
+  s.version = '0.0.1'
+  s.author = 'Dario Seminara'
+  s.email = 'robertodarioseminara@gmail.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'fast execution of ruby code'
+  s.homepage = "http://github.com/tario/fastruby"
+  s.add_dependency "RubyInline", "= 3.9.0"
+  s.add_dependency "ruby_parser", "= 2.0.6"
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ 'README' ]
+#  s.rdoc_options << '--main' << 'README'
+  s.files = Dir.glob("{benchmarks,examples,lib,spec}/**/*") +
+    [ 'LICENSE', 'AUTHORS', 'README', 'Rakefile', 'TODO' ]
+end
+
+desc 'Run tests'
+
+RSpec::Core::RakeTask.new("test:units") do |t|
+  t.pattern= 'spec/**/*.rb'
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new :rdoc do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.add 'lib', 'README'
+  rd.main = 'README'
+end
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_rdoc, :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]

data/TODO

@@ -0,0 +1,31 @@
+Basic functionality:
+
+* Flow control setences: case
+* Exceptions
+* Defining and call of methods with variable number of arguments
+* Blocks with variable number of arguments
+* call to monkey patched methods from fastruby code
+* callcc
+
+To improve:
+
+* Inlining of methods
+* Error check (e.g. calling a directive with invalid parameters)
+* Fastruby builds himself to improve performance of dynamic builds
+* Multiblocks
+* Fastruby method allow defining many methods in only one call and allow define classes
+* Oracle testing using normal ruby as oracle
+* Inference using "return types" of methods when the implementation of the method is known
+* RubySpec: make code executed by fastruby pass RubySpec
+
+Refactor:
+
+* hashes of methods on builder refactored into an only hash
+* refactor anonoymous methods (tip: use ruby format string for names)
+* Clean of duplicated code
+* Remove ruby inline explicit dependency
+
+Documentation:
+
+* Builder directives
+* Build API

data/benchmarks/benchmark.rb

@@ -0,0 +1,68 @@
+require "rubygems"
+require "fastruby"
+
+class X
+	fastruby "
+		def foo(a,b)
+			return a+b
+		end
+	"
+end
+
+class Y
+	fastruby "
+		def bar(x)
+			i = 1000000
+			
+			lvar_type(i,Fixnum)
+			
+			ret = 0
+			while i > 0
+				ret = x.foo(i,i)
+				i = i - 1
+			end
+			return ret
+		end
+
+	"
+end
+
+class X2
+	def foo(a,b)
+		return a+b
+	end
+end
+
+class Y2
+		def bar(x)
+			i = 1000000
+			ret = 0
+			while i > 0
+				ret = x.foo(i,i)
+				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/benchmarks/benchmark2.rb

@@ -0,0 +1,70 @@
+require "rubygems"
+require "fastruby"
+
+class X
+	fastruby "
+		def foo
+			yield
+		end
+	"
+end
+
+class Y
+	fastruby "
+		def bar(x)
+			i = 1000000
+			
+			lvar_type(i,Fixnum)
+			
+			ret = 0
+			while i > 0
+				x.foo do
+				end
+				  i = i - 1
+			end
+			0
+		end
+
+	"
+end
+
+class X2
+	def foo
+		yield
+	end
+end
+
+class Y2
+		def bar(x)
+			i = 1000000
+			
+			ret = 0
+			while i > 0
+				x.foo do
+				  i = i - 1
+				end
+			end
+			0
+		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/benchmarks/benchmark3.rb

@@ -0,0 +1,70 @@
+require "rubygems"
+require "fastruby"
+
+class X
+	fastruby "
+		def foo
+			yield(1,2,3)
+		end
+	"
+end
+
+class Y
+	fastruby "
+		def bar(x)
+			i = 1000000
+			
+			lvar_type(i,Fixnum)
+			
+			ret = 0
+			while i > 0
+				x.foo do |a,b,c|
+				end
+				  i = i - 1
+			end
+			0
+		end
+
+	"
+end
+
+class X2
+	def foo
+		yield
+	end
+end
+
+class Y2
+		def bar(x)
+			i = 1000000
+			
+			ret = 0
+			while i > 0
+				x.foo do
+				  i = i - 1
+				end
+			end
+			0
+		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/benchmarks/benchmark4.rb

@@ -0,0 +1,94 @@
+require "rubygems"
+require "fastruby"
+
+class Y
+	fastruby "
+		def bar
+			i = 1000000
+			
+			lvar_type(i,Fixnum)
+			
+			ret = 0
+			while i > 0
+			  $a = 9
+			  i = i - 1
+			end
+			0
+		end
+
+	"
+end
+
+class Y2
+		def bar
+			i = 1000000
+			
+			ret = 0
+			while i > 0
+			  $a = 9
+			  i = i - 1
+			end
+			0
+		end
+end
+
+
+class Y_
+	fastruby "
+		def bar
+			i = 1000000
+			
+			lvar_type(i,Fixnum)
+			
+			ret = 0
+			while i > 0
+			  i = i - 1
+			end
+			0
+		end
+
+	"
+end
+
+class Y2_
+		def bar
+			i = 1000000
+			
+			ret = 0
+			while i > 0
+			  i = i - 1
+			end
+			0
+		end
+end
+
+
+y = Y.new
+y2 = Y2.new
+y_ = Y_.new
+y2_ = Y2_.new
+
+Y.build([Y],:bar)
+Y_.build([Y_],:bar)
+
+require 'benchmark'
+
+Benchmark::bm(20) do |b|
+
+	b.report("fastruby") do
+		y.bar
+	end
+
+	b.report("ruby") do
+		y2.bar
+	end
+	
+	b.report("lfastruby") do
+		y_.bar
+	end
+
+	b.report("lruby") do
+		y2_.bar
+	end
+	
+end

data/benchmarks/benchmark5.rb

@@ -0,0 +1,80 @@
+require "rubygems"
+require "fastruby"
+
+class X
+	fastruby "
+		def bar
+		end
+	"
+	
+	fastruby "
+		def foo
+			yield(self)
+		end
+	"
+end
+
+class Y
+	fastruby "
+		def bar(x)
+			i = 1000000
+			
+			lvar_type(i,Fixnum)
+	
+			x2 = 0
+			ret = 0
+			while i > 0
+				x.foo do |x2|
+					x2.bar
+				end
+				  i = i - 1
+			end
+			0
+		end
+
+	"
+end
+
+class X2
+	def bar
+	end
+	
+	def foo
+		yield(self)
+	end
+end
+
+class Y2
+		def bar(x)
+			i = 1000000
+			
+			ret = 0
+			while i > 0
+				x.foo do |x2|
+					x2.bar
+				end
+				  i = i - 1
+			end
+			0
+		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/benchmarks/benchmark6.rb

@@ -0,0 +1,64 @@
+require "rubygems"
+require "fastruby"
+
+class X
+	fastruby '
+		def foo
+			"65535".to_i
+		end
+	'
+end
+
+class Y
+	fastruby "
+		def bar(x)
+			i = 1000000
+			lvar_type(i,Fixnum)
+	
+			while i > 0
+				x.foo
+				i = i - 1
+			end
+			0
+		end
+
+	"
+end
+
+class X2
+	def foo
+		"65535".to_i
+	end
+end
+
+class Y2
+		def bar(x)
+			i = 1000000
+	
+			while i > 0
+				x.foo
+				i = i - 1
+			end
+			0
+		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/examples/example1.rb

@@ -0,0 +1,12 @@
+  require "fastruby"
+  
+  class X
+    fastruby '
+    def foo
+	  print "hello world\n"
+    end
+   '
+  end
+  
+  X.new.foo
+  

data/examples/example2.rb

@@ -0,0 +1,14 @@
+require "fastruby"
+  
+  class X
+    fastruby '
+    def foo(a,b)
+      a+b
+    end
+    '
+  end
+  
+  X.build([X,String,String] , :foo)
+  
+  p X.new.foo("fast", "ruby") # will use the prebuilded method
+  p X.new.foo(["fast"], ["ruby"]) # will build foo for X,Array,Array signature and then execute it

data/examples/example3.rb

@@ -0,0 +1,12 @@
+  require "fastruby"
+  
+  class X
+    fastruby '
+    def foo(a)
+      a.to_s + "_"
+    end
+    '
+  end
+  
+  p X.new.foo(9) 
+