Migrating everthing to ruby1.9

Since the warning I get from a excellent talk of @yhara at @RubyConfAr, ruby 1.9 is the present while ruby 1.8 is the past. The next step regarding my projects is to ensure that all works on ruby 1.9 (but keeping the compatibility with ruby1.8 at the same time)

This is the status of the more important projects.

ImageRuby

All tests on ImageRuby spec works with 1.9,2-p180 thanks to the contribution fix of amadanmath. Of course I will be listen to bug reports regarding ruby1.9 compatibility

Shikashi (and dependencies)

All tests on Shikashi spec works with 1.9,2-p180. Specific ruby 1.9 syntaxis are not convered by the spec. I have created a new issue for this (the issue corresponds to partialruby gem)

To make shikashi fully compatible with ruby1.9, I must find a replacement for RubyParser which is not compatible with some of ruby 1.9 specific syntax, for example, RubyParser is unable to recognize the new syntax for hashes of ruby 1.9

Fastruby

This is the most complex case, these are the remaining issues:

• Main headers of fastruby won't compile since these sources use syntax not supported by ruby1.9
• Use of C-Api specific to ruby1.8
• Remove support for syntax specific to ruby1.8 (only when run under ruby1.8)
• Add support for syntax specific to ruby1.9 (only when run under ruby1.9)
• RubyInline does not work with ruby1.9
• RubyParser does not work with ruby1.9

See ruby1.9 issues on fastruby

I will fork or find a fork of rubyinline to fix issues related with ruby1.9 compatibility, for the case of RubyParser (affecting shikashi too) I will replace parsing using Ripper which is the native out-of-the-box implementation of parsing on ruby1.9

Fastruby 0.0.15 released. Callcc and continuation objects!

Fastruby is a gem which allows to execute ruby code much faster than normal, currently in a state of transition between a spike and a usable gem, it is released when possible with incremental improvements.
The v0.0.15 release adds the support for continuation objects created using callcc function. To acchieve this, the implementation uses the non-lineal stack created on previous releases.

Also this release adds a few extra language support improvements such as method default arguments

Install

You can clone the repository at github:

git clone git://github.com/tario/fastruby.git
git checkout v0.0.15

Or install it using gem install:

gem install fastruby

New Features

• Continuation calls, non-local gotos
• Support for default method arguments
• Support for passing proc as block on method call
• Support for receiving block as proc object

Fixes

• Internal fix to support unlimited number of arguments on methods when called from normal ruby
• Minor fixes to splat arguments on blocks
• Removed yield_signature (inference of yield arguments) since this is not longer applicable

Examples of code being supported

Example of continuation calls, tail recursion

require "fastruby"

fastruby '
class X
def fact( n )
    a = callcc { |k| [ n, 1, k ] }
    n = a[0]
    f  = a[1]
    k  = a[2]
    if ( n == 0 ) then return f
    else
 k.call n-1, n*f, k
    end
end
end
'

p X.new.fact(6) # 720

Default Arguments

require "fastruby"

fastruby '
class X
def foo(a,b = a.reverse)
  a + b
end
end
'

p X.new.foo("13") # 1331
p X.new.foo("xx", "yy") # xxyy

Passing proc objects as blocks

require "fastruby"

fastruby '
class X
def bar
  yield(1)
  yield(2)
  yield(3)
end

def foo
  pr = proc do |x|
    p x
  end

  bar(&pr) # passing proc as a block
end
end
'

X.new.foo

Receiving blocks as proc objects

require "fastruby"

fastruby '
class X
def bar(&pr)
  pr.call(1)
  pr.call(2)
  pr.call(3)
end

def foo
  bar do |x|
    p x
  end
end
end
'

X.new.foo

Fastruby 0.0.14 released with support for method replacement

Fastruby is a gem which allows to execute ruby code much faster than normal, currently in a state of transition between a spike and a usable gem, it is released when possible with incremental improvements.
The v0.0.14 release make a internal redesign of the method hash structure to allow the store of function pointer pointers, this is what allows to reference a fixed function pointer which may change enabling method replacement while retaining most of the performance (fastruby calls now consume a extra indirection and a few extra checks)

Install

You can clone the repository at github:

git clone git://github.com/tario/fastruby.git
git checkout v0.0.14

Or install it using gem install:

gem install fastruby

New Features

• Support for method replacement
  
• Fix on type inference of splat method arguments (as Array)
  

Examples of code being supported

Replacement of methods

require "fastruby"

fastruby '
class X
  def foo(a)
    a+1
  end
end
'

x = X.new
p x.foo(4) # 5

fastruby '
class X
  def foo(a)
    a*2
  end
end
'

p x.foo(4) # 8

Remaining uncovered items on v0.0.14 release

• Memory handling of function pointers on method hash (will be fixed for v0.0.15)
  
• Fix limitation of 15 arguments when calling method defined on fastruby from normal ruby
• Fix duplication of objects on cache when methods are replaced
• Optimization of splat callls, currently this calls are executing using normal rb_funcall2 (will be improved for v0.2.0)
• Optimization of calls to methods with variable number of arguments, currently are wrapped using rb_funcall (will be improved for v0.2.0)
  
  

Fastruby 0.0.13 released with support for splat arguments and method with array arguments

Fastruby is a gem which allows to execute ruby code much faster than normal, currently in a state of transition between a spike and a usable gem, it is released when possible with incremental improvements.
The v0.0.13 release of fastruby make a little internal design improvement regarding translator class and the implementation of splat arguments and methods with optional arguments (see examples below)

Install

You can clone the repository at github:

git clone git://github.com/tario/fastruby.git
git checkout v0.0.13

Or install it using gem install:

gem install fastruby

New Features

• Support for definition of methods with variable number of arguments
• Support for splat arguments on method calls
  

Examples of code being supported

Multiple arguments and call with splat

require "fastruby"

fastruby '
class X
def foo(*array)
  array.each do |x|
    p x
  end
end

def bar(*args)
  foo(*args)
end
end
'

x = X.new
x.foo(1,2,3) # prints 1,2 and 3
x.bar(4,5,6) # prints 4,5 and 6

Remaining uncovered items on v0.0.13 release

• Configuration of signatures for methods with variable number of arguments (will be implemented for v0.0.14)
• Build-time type inference of splat arguments as Array type (will be implemented for v0.0.14)
• Optimization of splat callls, currently this calls are executing using normal rb_funcall2 (will be improved for v0.2.0)
• Optimization of calls to methods with variable number of arguments, currently are wrapped using rb_funcall (will be improved for v0.2.0)
  
  

Fastruby 0.0.11 released with support for retry, redo and foreach

Fastruby is a gem which allows to execute ruby code much faster than normal, currently in a state of transition between a spike and a usable gem, it is released when possible with incremental improvements.
The v0.0.11 release of fastruby make internal improvements regarding non-local jumps and implements foreach support, including retry and redo statements (both applicable to any kind of block, and retry applicable on rescue clause)

Install

You can clone the repository at github:

git clone git://github.com/tario/fastruby.git
git checkout v0.0.11

Or install it using gem install:

gem install fastruby

New Features

• Support for retry
• Support for redo
• Foreach
  

Examples of code being supported

For each with redo and retry

require "fastruby"

fastruby '
class X
 def foo
   sum = 0

   for i in (4..8)
     p i # 4 4 4 4 4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7 8
     sum = sum +  i
     redo if sum < 20
     retry if sum < 100 and i == 7
   end

   sum
 end
end
'

x = X.new
x.foo # 46

Fastruby 0.0.9 released with support for proc

Fastruby is a gem which allows to execute ruby code much faster than normal, currently in a state of transition between a spike and a usable gem, it is released when possible with incremental improvements.
Following the release of version v0.0.8 which did implement several internal improvements including a new non-linear stack structure, the new release v0.0.9 implements the support for procedure objects based in the previous implementation

Install

You can clone the repository at github:

git clone git://github.com/tario/fastruby.git
git checkout v0.0.9

Or install it using gem install:

gem install fastruby

New Features

• Support for proc
  

Examples of code being supported

return method from proc

require "fastruby"

fastruby '
class X
  def foo
    pr = Proc.new do
      return "return foo from inside proc"
    end

    pr.call

    return "return foo"
  end
end
'

x = X.new
x.foo # this returns "return foo from inside proc"

The behavior of Proc objects (those created using Proc.new) are very similar to the behavior of lambdas, but with a few little differences:

• It is possible to do non-local return's from Proc.new of the method where the block was defined, this non-local return will fail with LocalJumpError when the method scope is closed in the moment of invoking the return (in lambdas, return only acts as next; ie, only ends the lambda function)
• Break jumps are illegal from Proc.new blocks and always fails with LocalJumpError (in lambdas, break acts as next)
  

As additional note, block objects created using proc method are exact the same block objects created using lambda method, only check the the ruby 1.8 source code to see something like that:

   ...
 rb_define_global_function("proc", proc_lambda, 0);
 rb_define_global_function("lambda", proc_lambda, 0);
 ...

Fastruby roadmap up to 0.5.0

Fastruby development (up to 1.0.0 release) will be divided into two main phases:

• Incremental Proof of Concept. Transition from a base spike/PoC (version 0.0.1) to usable gem (version 0.1.0).
  
• Usable versions. Transition from minimally usable gem (version 0.1.0) to stable API release (version 1.0.0)
  

This is a rough roadmap and might change in the future if new ideas or optimizations are discovered

PoC Incremental Versions

Version 0.0.8: lambdas (already released)

• Implementation of DAG stack including GC mark of local variables residing on it
  
• lambda support
• refactor of break implementation
  

Version 0.0.9: proc

• proc support using the same functionality as for lambda
  

Version 0.0.10: Gem packaging fixes

Version 0.0.11: for, retry, redo

• refactor of non-local jumps to use ruby API
  
• trivial implementation of for
• implementation of retry and redo as non-local retro-jumps (like the implementation of loop/while)
  

Version 0.0.12: Full exception support

Version 0.0.13: Methods with variable number of arguments

Version 0.0.14: Support for method replacement

Version 0.0.15: continuation objects


Etc...

Version 0.1.0: First usable release

• Any ruby code executable by MRI can be executed by fastruby
  

Usable Versions (Following semantic versioning)

Zero used as mayor version number is used when API is changed every day without backward compatibility (despite the fact that will be backward compatibility when possible). Also, on 0.X.X versions the API is completely undefined.
Bugs and spec un-compliance of 0.1.0 release will be fixed on subsequent stabilization releases (0.1.1, 0.1.2, etc...)

Version 0.1.0: Execution of Ruby

Features:

• Any executable code in ruby is executable via fastruby and gives the same results
  
• Interoperation between ruby and fastruby is granted
  

Version 0.2.0: Fast execution of ruby, internal optimizations

Features

• All internal optimizations documented up to 0.1.0 release
  
  • Linear stack when possible using nonlambda qualifier
    
  • Method dispatcher cache (to speedup calls from ruby)
    
  • Optimization of C frames to make ruby return using C return when possible (useful on small methods)

Version 0.3.0: Fast execution of ruby, C extension API

• C extension points
  • API to define methods in C, by class, method name and signature allowing replacement of ruby standard lib implementation in the future.

Version 0.4.0: Fast execution of ruby, C extension API 2

• C extension points
  • Macro methods (keeping dynamism). Examples:
    
    1. Fixnum#+(x:Fixnum) => INT2FIX(FIX2INT(self)+FIX2INT( x) )
    2. String#[](x:Fixnum) => rb_str_new2(RSTRING(self)->ptr[FIX2INT(x)],1)
    3. String#[]=(x:Fixnum,y:Fixnum) =>
       RSTRING(self)->ptr[FIX2INT(x)]=FIX2INT(y)
       

Version 0.5.0: Faster standard lib

• Ruby standard lib re-implemented in a separated gem optimized for fastruby
• Fastruby works with and without optimized stdlib