Rubinius

Use Ruby

http://rubini.us

About me

• Karol Hosiawa

• Working with Ruby since 2005

• rubyonrails.pl maintainer

• Occasional Rubinius committer

• twitter.com/hosiawak

• github.com/hosiawak

Agenda

• What is Rubinius ?

• Compatibility

• Comparison with MRI (Matz Ruby Interpreter)

  • Code

  • Memory management

  • Interpreter / compiler

• Performance summary

• Quiz (Rubinius T-shirts)

• Questions

What is Rubinius ?

• An implementation of the Ruby programming language

• Project started in 2006

• Rubinius breaks through in 2011

Compatibility

• Rubinius aims to be fully compatible with:

  • MRI 1.8 - done

  • MRI 1.9 and 2 - near future

• Uses RubySpec to assert compatibility

Why Rubinius ?

• MRI is good enough for me

• I can work around some of its problems

• You don't have to - we can have it better

Why Rubinius ?

• Rubinius is built from ground up on solid foundations

• Optimized for running Ruby applications

What are the foundations ?

• Code

• Memory management

• Interpreter and compiler

Code - Rubinius - Highlights

• Rubinius VM executes Ruby code

• The VM, GC and JIT compiler are written in C++

• Almost all other code is Ruby

• Ruby is a first class citizen in Rubinius

• The goal is to have as much of the system written in Ruby as possible

Code - MRI - Highlights

• Except for some stdlib classes MRI is all C

• Ruby is a second class citizen

  • it's just a thin layer on top of all that C code

• When you want to make your code run faster the general advice is to write it in C

• eg. a recent rewrite of Date and Pathname in C in MRI 1.9.3

• Ruby should be avoided if it causes problems

Code - Comparison

• Rubinius builds a consistent system

Integer

• class Fixnum < Integer

• 10

• class Bignum < Integer

• 8743674365876

Integer#times

static VALUE
int_dotimes(VALUE num)
{
    RETURN_ENUMERATOR(num, 0, 0);

    if (FIXNUM_P(num)) {
        long i, end;

        end = FIX2LONG(num);
        for (i=0; i<end; i++) {
            rb_yield(LONG2FIX(i));
        }
    }
    else {
        VALUE i = INT2FIX(0);

        for (;;) {
            if (!RTEST(rb_funcall(i, '<', 1, num)))
                break;
            rb_yield(i);
            i = rb_funcall(i, '+', 1, INT2FIX(1));
        }
    }
    return num;
}

def times
  return to_enum(:times) unless block_given?

  i = 0
  while i < self
    yield i
    i += 1
  end
  self
end

Integer#times

• OK, so that MRI code is not very object oriented and clean

• But surely it's FAST because it's C, right ?

Integer#times

• 50_000_000.times {} is 2x faster on Rubinius than on MRI 1.9.3

• Just using C doesn't guarantee a performant dynamic language like Ruby

• Smarter approach is needed

Code - Rubinius

• Almost all core and stdlib classes are written in Ruby

• Some low level operations are implemented as Primitives in C++

• This enables better runtime optimizations

• Simplifies debugging

• Ruby code can be reused by other implementations, eg. jRuby

Mixology

• A gem that allows objects to mixin and unmix modules

• Mixology in MRI

• Mixology in jRuby

• Mixology in Rubinius

Code - It's not just core/stdlib classes

• AST generation (Melbourne::Processor) is written in Ruby

• Bytecode generator/compiler is in Ruby

• Various tools like the profiler and debugger are written mostly in Ruby

Rubinius - very powerful features

• AST transformation

  • Syntax tree macros

  • Compiler transforms (eg. safe math transform)

  • Better/easier mutation testing (eg. Heckle)

Rubinius - very powerful features

def hello
  Rubinius.asm do
    push_literal "hello "
    push_literal "world"
    send :+, 1
  end
end

irb> hello
=> "hello world"

Code in Rubinius

• Future possibilities

  • Better tools built on top of all the Ruby system APIs Rubinius provides

  • Low level machine code generation in Ruby for special purposes (eg. custom float library)

What are the foundations ?

• Code

• Memory management

• Interpreter and compiler

Ruby

• Object oriented programming language

• Ruby means objects (sometimes a lot of objects)

• Garbage collector does automatic object allocation/collection

• You don't have to worry about it

• unless it becomes a problem

Garbage Collector (GC) - MRI 1.8

• Conservative "stop the world" collector

• Mark and sweep

• Can't move objects so can't compact memory

• Memory difficult (impossible) to reclaim

GC - MRI 1.8 - Patches

• MBARI patches

• REE patches

• Kiji patches (Twitter)

GC - MRI 1.9

• Much better than 1.8

• Recognizes normal objects and long lived objects

• Collection is faster because it ignores long lived objects until full GC run

GC - MRI 1.9 - Patches

• Longlife patch

• LazySweep patch (merged into 1.9.3)

• ParallelMarking patch

GC - Rubinius

• Generational:

• It splits objects into groups based on their age and size

• Nursery, Young generation, Mature, Large objects

• and treats each group in a different way

GC - Rubinius

• Freshly hatched objects are more likely to become garbage than older objects that have been around for a while

Rubinius GC - Nursery

Rubinius GC - Young generation

Rubinius GC - Mature generation

• Mature objects are objects that have been promoted from the Young generation after living past the promotion threshold 'X'

• Autotune is the mechanism that is used to dynamically adjust the GC cycles before mature collection occurs

Rubinius GC - Large objects

• Large objects are born in a birthing tank rather than a nursery

• Any object that exceeds the defined byte size for a large object upon allocation is allocated directly into the large objects space.

• This is done to avoid copying since copying large objects is an expensive operation

What does it all mean in practice ? - MRI 1.8

• MRI 1.8 - likely to experience huge memory consumption when you create huge number of objects

• eg. generating a financial report using millions of temporary objects

• You can't get that memory back

What does it all mean in practice ? - MRI 1.9

• MRI 1.9 - better GC than 1.8 (less memory, better collection)

• Still not generational, there are issues making it so (C extensions for example)

• Still slow compared to Rubinius GC (putting a lot of pressure on your app)

What does it all mean in practice ? - Rubinius GC

• Rubinius GC - enables more optimizations than mark and sweep GC

• GC can compact memory and release it to the OS

• Very fast

• All objects are extremely lightweight (packs ivars for example)

Why is it important ?

• As we are Ruby developers we should not be afraid to create many objects

• MRI is limiting us (1.8 too much memory, 1.9 - slow)

• Rubinius GOT IT ALL SORTED

• jRuby is another good alternative not suffering from GC problems

How much better is Rubinius GC ?

• It all depends on your program BUT:

• Run gist.github.com/1008305

• It creates 10,000,000 objects

• For every 100 objects it saves 1 object

GC bench - https://gist.github.com/1008305

What are the foundations ?

• Code

• Memory management

• Interpreter and compiler

Interpreter - MRI

• MRI 1.8 - naive tree walker, walks the abstract syntax tree and executes code

• MRI 1.9 - bytecode interpreter (YARV)

• Both 1.8 and 1.9 have a Global Interpreter Lock

• You can't use threads to effectively utilize modern mulit-core CPUs

Interpreter - MRI

• MRI 1.9.3 has made the global lock more granular - it helps

• But it's still a locking VM

Interpreter - Rubinius

• Bytecode interpreter

• Just-In-Time compiler

• Fully concurrent native threads

• No GIL

Rubinius - Interpreter/compiler overview

• Parses Ruby code

• Generates AST

• Generates bytecode for every tree node

• Executes bytecode (interpreter)

• Compile some bytecode and optimize (JIT compiler)

Rubinius - Compiler

• Generates AST nodes which are just Ruby objects in a tree structure

"1 + 2".to_ast

SendWithArguments
  @line: 1
  @name: :+
  @privately: false
  @check_for_local: false
  @vcall_style: false
  @block: nil
  @arguments: \
    ActualArguments
      @line: 1
      @splat: nil
      @array: [
        FixnumLiteral [0]
          line: 1
          value: 2
      ]
  @receiver: \
    FixnumLiteral
      @line: 1
      @value: 1

============= :__script__ ==============
Arguments:   0 required, 0 post, 0 total
Arity:       0
Locals:      0
Stack size:  2
Lines to IP: 1: 0..6

0000:  meta_push_1
0001:  meta_push_2
0002:  meta_send_op_plus          :+
0004:  pop
0005:  push_true
0006:  ret
----------------------------------------

Bytecode compiler

• All methods are compiled into CompiledMethods

• They're just Ruby objects you can use, inspect and modify

• They're stored in a CompiledMethods database

Interpreter

• The interpreter executes CompiledMethod's bytecode

• Generates profile data and feeds it into the JIT compiler

• JIT compiler optimizes runtime performance

JIT Compiler - Inlining

./bin/rbx -Xjit.show=true

def simple
  1
end

1_000_000.times { simple }

[[[ JIT finished background compiling  (block) ]]]
[[[ JIT finished background compiling  (method) ]]]

1_000_000.times { 1 }

i = 0
while i < self
  1 # THIS WAS yield i
  i += 1
end

Performance - Approach

JVM

• Do Java programmers rewrite performance ciritical parts in C ?

• Probably not. They have to write in Java and the JVM makes the code run fast

Rubinius - How does it perform ?

• It depends on the code being run

• Microbenchmarks give better speeds than 1.8, some better than 1.9, some things are orders of magnitude faster than 1.9, other things are slower, some are much slower eg. Marshal

• Constant improvement

Array#map

String#split

Hash#merge

Real World - Red Black Tree

Real World - AVI Protobuf

Rubinius - Performance summary

• Constant improvement

• Performance measuring tools (benchmark/ips) and speed.pypy.org (help needed)

• Profiler

• Better interpreter/JIT (multi tiered, better type information, specialization, ASM code generation etc.)

I want to contribute

• Join #rubinius on IRC

• rvm install rbx && rvm use rbx

• Run your app

• Raise and fix issues

I want to contribute

• Read docs at http://rubini.us/doc/en

• Write docs, help with translations

• Write code, RubySpecs

• Have fun!

QUIZ - Question 1

push_int 3
push_int 4
send     :+, 1

QUIZ - Question 2

Should you be afraid of creating a large number of temporary objects in Rubinius ?

Questions ?

Thank you!

http://hosiawak.github.com/rubinius_presentation