This document discusses various aspects of the Rubinius programming language implementation including: - Rubinius version 1.0 has been released with improvements to performance, compatibility, and new features like an object space profiler and debugger. - Benchmark results show Rubinius can be over 100x faster than Ruby 1.8 for some operations due to just-in-time compilation and method inlining. However, comparisons to Java and C implementations still show slower core performance for Ruby code. - Future releases will focus on continued performance improvements, compatibility fixes, and getting to a full 1.0 release with regular monthly release candidates. Overall expectations are that Rubinius will provide faster execution for most Ruby programs while maintaining

1. Rubinius
1.0 and more!

2. X
Phoeni
factors

3. Rubinius
Much more!

4. 1.0
Finally out!
12,206 commits

5. 1.0
1.8.7 compatible

6. 1.0
Good Performance

7. 1.0
Good Performance
20x faster than MRI sometimes

8. 1.0
Good Performance
10x slower in sometimes

9. 1.0
Good Performance
Tools to help

10. Rubinius
Why bother?

11. Rubinius
Dogfood

12. Rubinius
Ruby is currency

13. Rubinius
C is opaque

14. Rubinius
JIT loves Ruby

15. DataMapper
Now Supported!

16. DataMapper
Now Supported!

17. Information
Geographics
Now Supported!

18. NfoG
Now Supported!

19. o/~ Data in your maps yo.
Information Geo. o/~

20. NotImplementedError

21. NotImplementedError

22. Implemented

23. Implemented
ObjectSpace

24. Implemented
ObjectSpace
_id2ref

25. Implemented
ObjectSpace
_id2ref - Slow

26. Implemented
ObjectSpace
_id2ref - Searches Heap

27. Implemented
ObjectSpace
each_object

28. Implemented
ObjectSpace
find_object([:kind_of, what], block)

29. Implemented
ObjectSpace
More Powerful API

30. Performance
A “Hot” Topic

31. Performance
Measure

32. Performance
Measure
Measure, measure, measure

33. Performance
Measure
Benchmark.measure

34. Performance
Measure
-Xprofile (1.0.1)

35. Performance
Measure
Sampling Profiler (1.1)

36. Performance
Measure
Demo

37. Debugger
New / Old Feature

38. Debugger
Inspect code

39. Debugger
Inspect Code
Code Split

40. Debugger
Inspect Code
VM integration

41. CompiledMethod#set_breakpoint
Thread#set_debugger_thread
Location#variables

42. Debugger
Inspect Code
debugger.rb

43. Debugger
Inspect Code
Write your own!

44. Memory Profiler
(1.1)

45. Memory
C-API hooks

46. Memory
C-API hooks
Write a memory profiler

47. Query Agent
Know thy self

48. Query Agent
know thy self
VM API

49. Query Agent
know thy self
Export VM internal data

50. Query Agent
know thy self
Invaluable debugging tool

51. Query Agent
know thy self
Demo

53. Compliance
C-API
syck, nokogiri, etc.

54. Compliance
C-API
A few gotchas...

55. C Extension
Do’s and Don’ts

56. Do
prefer a function over an
R*() macro

57. Rubinius
RBASIC(obj)->class
rb_obj_class(obj)

58. 1.9 / Rubinius
ROBJECT(obj)->iv_tbl
rb_ivar_[get|set](obj, ...)

59. 1.9 / Rubinius
Don’t
use the “re.h” header

60. 1.9 / Rubinius
Don’t
use the “env.h” header
ruby_frame ruby_dyna_vars
ruby_scope ruby_in_eval
ruby_class

61. Try your gem

62. Report your
problems!

63. http://github.com/
evanphx/rubinius/
issues

64. Performance

65. Performance
The Two Fronts

66. Performance
Why We Fight
What We Write

67. (0..10).to_a.each do |i|
ary << i
end

68. 0.upto(10) do |i|
ary << i
end

69. Performance
The Two Fronts
How We Run It

70. Performance
Benchmarking

71. Performance
Benchmarking
Expectations vs. Reality

72. Performance
Benchmarking
Lies, Damned Lies, and Statistics

73. Benchmarks

74. 114
Times faster than 1.8
100
86
71
57
43
29
14
0
ruby 1.9 jruby macruby rubinius

75. 57
Times faster than 1.8
50
43
36
29
21
14
7
0
ruby 1.9 jruby macruby rubinius

76. impl 1.8 1.9 jruby macruby rbx
ms 309304 51113 113824 70580 24232
x faster 1.0 6.0 2.7 4.3 12.7

77. Benchmarks
12x faster!

78. Benchmarks
12x faster!
On these benchmarks!

79. Benchmarks
12x faster!
In general?

80. Benchmarks
What did we benchmark?

81. Calling a method.
Empty while loop.
Creating a block.
Accessing ivars.
Performing ‘not’.
Calling a polymorphic method.
Calling super.

82. Benchmarks
Why these things?

83. Benchmarks
Why these things?
How do these results translate?

84. Analogy

85. Dishonest?

86. Rubinius
Ruby performance
begets
core performance

87. 1.8
Ruby performance
begets
?

88. Benchmarks
Need more/better data

89. def foo()
ary = []
100.times { |i| ary << i }
end
300,000
times

90. Seconds
8
7.82
6
4 4.24
3.91
3.26
2.60
2
0
1.8 1.9 macruby jruby rbx

91. def foo()
hsh = {}
100.times { |i| hsh[i] = 0 }
end
100,000
times

92. Seconds
11
10.5
8.25
7.62
5.5
4.77 4.7
2.75
1.67
0
1.8 1.9 macruby jruby rbx

93. def foo()
hsh = { 47 => true }
100.times { |i| hsh[i] }
end
100,000
times

94. Seconds
4
3.64
3
2.61 2.6
2 2.12
1.75
1
0
1.8 1.9 macruby jruby rbx

95. Benchmarking
Conclusion

96. Benchmarking
Conclusion
Rubinius is awesome at ruby code

97. Benchmarking
Conclusion
Comparing C/Java to Ruby

98. More Ruby

99. More Ruby
Burden of our own devising

100. More Ruby
Fast compliance

101. More Ruby
Slower core performance

102. More Ruby
Slower core performance
Ruby vs. C/Java

103. More Ruby
The upside...

104. 114
Times faster than 1.8
100
86
71
57
43
29
14
0
ruby 1.9 jruby macruby rubinius

105. 114
Times faster than 1.8
100
86
71
57
43
29
14
0
ruby 1.9 jruby macruby rubinius

106. def m; nil; end
def Bench.run
i=0
while i < 15_000_000
i+=1
m; m; m; m; m; m; m; m
end
end

107. impl 1.8 1.9 jruby macruby rbx
ms 21361 6316 10101 3295 186
x faster 1.0 3.4 2.1 6.5 114.8

108. impl 1.8 1.9 jruby macruby rbx
ms 21361 6316 10101 3295 186
x faster 1.0 3.4 2.1 6.5 114.8

109. impl 1.8 1.9 jruby macruby rbx
ms 21361 6316 10101 3295 186
x faster 1.0 3.4 2.1 6.5
114.8

110. impl 1.8 1.9 jruby macruby rbx
ms 21361 6316 10101 3295 186
x faster 1.0 3.4 2.1
114.8
6.5

111. impl 1.8 1.9 jruby macruby rbx
ms 21361 6316 10101 3295 186
x faster 1.0 3.4
114.8
2.1 6.5

112. impl 1.8 1.9 jruby macruby rbx
114.8
ms 21361 6316 10101 3295 186
x faster 1.0 3.4 2.1 6.5

113. Bug

114. Bug
right?

115. Bug

116. def m; nil; end
def Bench.run
i=0
while i < 15_000_000
i+=1
m; m; m; m; m; m; m; m
end
end

117. Year 4
JIT
Method Inlining

118. def m; nil; end
def Bench.run
i=0
while i < 15_000_000
i+=1
m; m; m; m; m; m; m; m
end
end

119. bin/rbx
-Xjit.inline.debug
0/bm_vm2_method.rb

120. JIT: compiling Object#run
inlining: primitive fixnum_lt into run.
inlining: Object#m into run (<metaclass>)
inlining: Object#m into run (<metaclass>)
inlining: Object#m into run (<metaclass>)
inlining: Object#m into run (<metaclass>)
inlining: Object#m into run (<metaclass>)
inlining: Object#m into run (<metaclass>)
inlining: Object#m into run (<metaclass>)
inlining: Object#m into run (<metaclass>)

121. def m; nil; end
def Bench.run
i=0
while i < 15_000_000
i+=1
nil;nil;nil;nil;nil;nil;nil;nil
end
end

122. def m; nil; end
def Bench.run
i=0
while i < 15_000_000
i+=1
end
end

123. Performance

124. Performance
Many programs, much faster

125. Performance
Many programs, a little slower

126. Performance
Some programs, a lot slower

127. Releases

128. Releases
0.13

129. Releases
0.13
JIT by default

130. Releases
0.13
Lots of fixes

131. 1.0rc1

132. Next Week!

133. Expectations

134. Expectations
Runs rails 3

135. Expectations
Performance improvements

136. Expectations
One RC every month

137. Expectations
One RC every month
Until 1.0 is out.