XRuby 0.2.0 released

I am glad to announce that XRuby 0.2.0 is now available for download at:
http://code.google.com/p/xruby/downloads/list

Here is a summary of major changes in this release:

1. Beanworms started to work on the debugging support and we now have a basic debugger in trunk.
2. Zhang Yu and Haofei Wang added/fixed lots of builtin methods
3. Dreamhead rewrote RubySymbol as the old one was plain wrong
4. As test::unit works on XRuby, we imported unit tests from c ruby (test\ruby) to test our implementation. The result was not very impressive so far, less than half of the tests passed. We are planning to make all tests pass in the coming weeks.
5. Meanwhile, Femto is leading our efforts to create an ANTLR v3 based ruby parser in another branch. Upgrading our parser from ANTLR v2 to v3 is indeed challenging, but he has make very impressive progress.

Thank you everybody who contributed to this release!

InfoQ article on XRuby

Werner Schuster from InfoQ has a very nice article about XRuby, you can read it here.

UPDATE 04/27/2007: InfoQ China had an interview with our core developer Dreamhead. You can read it here (in Chinese). And congratulations to Dreamhead for joining Thoughtworks.

XRuby 0.1.4 released

I am glad to announce that XRuby 0.1.4 is now available for download at: http://code.google.com/p/xruby/downloads/list

The most significant change in this release is: one of our team member, dreamhead, single-handly created a new runtime (the core of the system that manages ruby types, methods...) to make it very close to the classic C ruby, and therefore fixed several compatibility issues with C ruby. As a translator of the Chinese version Ruby Hacking Guide, dreamhead has very good knowledge of the ruby internal and gives a great lift on the XRuby's development.

As we have learned rewriting is very difficult, we learned it again in a hard way. Dreamhead wrote most of code last year, several months before 0.1.0 release. First we tried to make a wholesale replacement of the runtime, but problems were here and there and lots of unit tests broke. Since we do not want to have a broken system in the SVN trunk, we decided to take 'refactoring' approach and merge changes step by step. It is still very hard, but dreamhead made lots of efforts and finished the merge yesterday.

Actually it may take less time if we insist on following the 'rewrite' approach (replace all the old code and fix broken tests), but the benefit of 'refactoring' is significant: it gives us a stable code base so that we made several releases during this big change.

There are more exciting news behind the scene now: Beanworms is working on the debugger support, and Femto and Yuesefa have showed interest to migrate our ruby parser to ANTLR 3.0.

Thank you for people who helps us on making this release. It has been a great learning experience working with the project.

Ruby builtin in pure Ruby

[Update 03/12/2007 If you know how to implement Interge#times in pure ruby and make it have the same behavior as Ruby 1.8.5, please let me know. Thank you!]

One of the best things I love about rubinius project is: their developers try to keep the dependency on system language (C in their case) minimal, and they take it seriously. Take a look of http://code.fallingsnow.net/svn/rubinius/trunk/kernel/core/, you will find out lots of buitlin libraries are implemented in pure ruby, even lots of string functions.

Pure ruby builtin has some drawbacks, though. One is performance penalty, the other is potential side effects. For example, basically Integer#times can be implemented as simple as this in pure ruby:

class Integer
 def times  
  i = 0  
  while i < self
   yield i
   i += 1;  
  end 
  self
 end
end

But this version of Integer#times does not work exactly the same as Ruby 1.8.5. If an user want to override Fixnum#+ (this may never happen in real life):

class Fixnum
  def + x
    return 9999
  end
end

Our Integer#times's behavior will change, while Ruby 1.8.5 won't. That is because Ruby 1.8.5's implementation (int_dotimes() in Numeric.c) optimizes for Fixnum: it does not call '+' method dynamically for Fixnum, instead, it just increases the integer directly. If you want to implement this method as same as Ruby 1.8.5 then you have to write code in system language.

This kind of optimization is all over the place in c ruby. I am not clear about its motivation, but I guess performance is one of the reasons. For example, "30000000.times {|x|}" is about twice faster than "i = 0; while i < 30000000; i +=1; end" in Ruby 1.8.5.

Difference people may have different opinions on what the 'right' behavior should be. As for me, I like the behavior of the pure ruby implementation better.

XRuby is faster than Ruby 1.8.5 in most benchmarks

Two weeks ago, Antonio Cangiano compared the performance of different ruby implementations using Ruby 1.9 (YARV)'s benchmark suite. His numbers got me thinking: all alternative implementations performed badly -- most are even way slower than ruby 1.8.5. Does it signal that JVM and .NET are bad platform for Ruby language?

With this doubt I tried the benchmark with XRuby. XRuby is a ruby compiler. Unlike other implementations, it generates Java bytecode that run directly on JVM. But at first the numbers are not impressive: the 0.1.2 version is still slower than Ruby 1.8.5 in most of the cases.

Maybe I should mention that the XRuby team had done virtually nothing for performance before, and we would avoid optimization as long as possible if it makes our code complicated. But after doing some measurements, it turns out our bad performance are largely caused by a logic 'error': as we know Ruby Fixnum can not have singleton methods, but in 0.1.2 it still lookup an empty method table. And along with some bad code practices (iterating an empty ArrayList without checking if it is empty first etc), it makes method lookup much slower than it should be.

I fixed the problem by adding about 10 lines of code, and got great result: In most benchmarks, XRuby 0.1.3 is faster than Ruby 1.8.5. For some, faster in a significant way. There are still some tests in which we are slower, but it looks like caused by poorly implemented builtin.

The following table shows the benchmark result for XRuby 0.1.3. The best part is: we did it without a method cache. YARV is still faster than XRuby, but we have lots of room to improve too.

>java -Xmx512m -jar xruby-0.1.3.jar benchmark\run.rb

Test	Ruby 1.8.5	XRuby 0.1.3
bm_app_answer.rb	fail	fail
bm_app_factorial.rb	fail	fail
bm_app_fib.rb	20.02	12.29
bm_app_mandelbrot.rb	7.099	8.252
bm_app_pentomino.rb	289.8	538.5
bm_app_raise.rb	4.846	3.986
bm_app_strconcat.rb	5.898	3.234
bm_app_tak.rb	26.14	22.12
bm_app_tarai.rb	20.89	18.35
bm_loop_times.rb	14.28	19.30
bm_loop_whileloop.rb	26.03	19.27
bm_loop_whileloop2.rb	5.257	4.786
bm_so_ackermann.rb	fail	fail
bm_so_array.rb	19.17	46.84
bm_so_concatenate.rb	5.727	9.684
bm_so_count_words.rb	2.944	45.50
bm_so_exception.rb	9.793	7.399
bm_so_lists.rb	3.666	24.59
bm_so_matrix.rb	6.249	8.452
bm_so_nested_loop.rb	15.17	13.45
bm_so_object.rb	21.49	7.991
bm_so_random.rb	6.169	5.888
bm_so_sieve.rb	2.042	2.753
bm_vm1_block.rb	64.57	38.69
bm_vm1_const.rb	47.47	25.57
bm_vm1_ensure.rb	45.54	20.01
bm_vm1_length.rb	55.50	40.89
bm_vm1_rescue.rb	39.61	20.64
bm_vm1_simplereturn.rb	56.02	29.06
bm_vm1_swap.rb	76.35	30.52
bm_vm2_array.rb	19.34	8.532
bm_vm2_method.rb	33.72	19.63
bm_vm2_poly_method.rb	45.23	20.62
bm_vm2_poly_method_ov.rb	12.64	8.261
bm_vm2_proc.rb	21.08	17.86
bm_vm2_regexp.rb	13.09	30.87
bm_vm2_send.rb	11.71	15.75
bm_vm2_super.rb	13.92	7.510
bm_vm2_unif1.rb	11.30	8.292
bm_vm2_zsuper.rb	15.71	7.740
bm_vm3_thread_create_join.rb	0.110	1.331

* The test environment is Intel Pentium M 1G CPU, 1G Memory, Windows XP SP2, Java 1.5.0_09.

XRuby 0.1.2 released

XRuby 0.1.2 is now available for download from the project download page: http://code.google.com/p/xruby/downloads/list

This latest release contains more built-in libraries and a few bug fixes for the compiler. We expect to release a new stable version every month.

Last week, Antonio Cangiano did a very interesting job to compare the performance of different ruby implementations using YARV's benchmark suite. XRuby is not included in his test as Antonio may not know our project exists. For people who are interested, here is the XRuby's performance data (due to my limited resource, only ruby 1.8.5 interpreter was compared):

>java -Xmx512m -jar xruby-0.1.2.jar benchmark\run.rb

Test	Ruby 1.8.5	XRuby 0.1.2
bm_app_answer.rb	fail	fail
bm_app_factorial.rb	fail	fail
bm_app_fib.rb	20.42	33.84
bm_app_mandelbrot.rb	7.270	15.33
bm_app_pentomino.rb	294.2	956.9
bm_app_raise.rb	4.906	4.597
bm_app_strconcat.rb	5.917	5.858
bm_app_tak.rb	26.46	38.95
bm_app_tarai.rb	21.08	35.51
bm_loop_times.rb	14.83	93.55
bm_loop_whileloop.rb	26.26	76.5
bm_loop_whileloop2.rb	5.327	16.15
bm_so_ackermann.rb	fail	fail
bm_so_array.rb	19.35	300.2
bm_so_concatenate.rb	5.868	26.58
bm_so_count_words.rb	2.253	46.43
bm_so_exception.rb	9.893	9.973
bm_so_lists.rb	3.696	41.04
bm_so_matrix.rb	6.328	21.29
bm_so_nested_loop.rb	15.38	68.20
bm_so_object.rb	21.97	20.77
bm_so_random.rb	6.269	15.69
bm_so_sieve.rb	1.992	5.476
bm_vm1_block.rb	65.67	98.91
bm_vm1_const.rb	48.05	82.31
bm_vm1_ensure.rb	46.19	75.38
bm_vm1_length.rb	55.62	105.6
bm_vm1_rescue.rb	36.47	80.91
bm_vm1_simplereturn.rb	57.12	88.16
bm_vm1_swap.rb	76.21	85.73
bm_vm2_array.rb	18.64	19.65
bm_vm2_method.rb	33.41	35.32
bm_vm2_poly_method.rb	45.42	47.78
bm_vm2_poly_method_ov.rb	12.81	25.98
bm_vm2_proc.rb	21.54	31.23
bm_vm2_regexp.rb	13.40	52.35
bm_vm2_send.rb	11.87	31.60
bm_vm2_super.rb	13.98	20.25
bm_vm2_unif1.rb	11.46	19.95
bm_vm2_zsuper.rb	15.84	21.92
bm_vm3_thread_create_join.rb	0.120	1.402

The test environment is Intel Pentium M 1G CPU, 1G Memory, Windows XP SP2, Java 1.5.0_09. It may be worth to mention we have done almost nothing for optimization, not even a simple method cache. I think it is quite possible for a JVM based ruby compiler to beat the classic Ruby interpreter on performance, while YARV's number is going to be very hard for us to reach.

On-Ruby interview

Pat Eyler recently interviewed XRuby team, the first episode is now posted on his popular On-Ruby blog: http://on-ruby.blogspot.com/2007/02/serial-xruby-interview-episode-i.html