Charles Nutter, profile picture
Uploaded byCharles Nutter
KEY, PPTX8,989 views

High Performance Ruby - Golden Gate RubyConf 2012

Hotspot optimizes the first loop in the benchmark and inlines the method calls. When the second loop with different method calls is encountered, Hotspot's assumptions change and performance is negatively impacted. Monitoring the JVM's optimization activities like JIT compilation and inlining is needed to better understand benchmark results, as small code behaves differently than large code during optimization.

Embed presentation

Download as KEY, PPTX
1 / 120
2 / 120
3 / 120
4 / 120
5 / 120
6 / 120
7 / 120
8 / 120
9 / 120
10 / 120
11 / 120
12 / 120
13 / 120
14 / 120
15 / 120
16 / 120
17 / 120
18 / 120
19 / 120
20 / 120
21 / 120
22 / 120
23 / 120
24 / 120
25 / 120
26 / 120
27 / 120
28 / 120
29 / 120
30 / 120
31 / 120
32 / 120
33 / 120
34 / 120
35 / 120
36 / 120
37 / 120
38 / 120
39 / 120
40 / 120
41 / 120
42 / 120
43 / 120
44 / 120
45 / 120
46 / 120
47 / 120
48 / 120
49 / 120
50 / 120
51 / 120
52 / 120
53 / 120
54 / 120
55 / 120
56 / 120
57 / 120
58 / 120
59 / 120
60 / 120
61 / 120
62 / 120
63 / 120
64 / 120
65 / 120
66 / 120
67 / 120
68 / 120
69 / 120
70 / 120
71 / 120
72 / 120
73 / 120
74 / 120
75 / 120
76 / 120
77 / 120
78 / 120
79 / 120
80 / 120
81 / 120
82 / 120
83 / 120
84 / 120
85 / 120
86 / 120
87 / 120
88 / 120
89 / 120
90 / 120
91 / 120
92 / 120
93 / 120
94 / 120
95 / 120
96 / 120
97 / 120
98 / 120
99 / 120
100 / 120
101 / 120
102 / 120
103 / 120
104 / 120
105 / 120
106 / 120
107 / 120
108 / 120
109 / 120
110 / 120
111 / 120
112 / 120
113 / 120
114 / 120
115 / 120
116 / 120
117 / 120
118 / 120
119 / 120
120 / 120
HIGH PERFORMANCE RUBY
Hiya • Charles Oliver Nutter • headius@headius.com • @headius • JVM language guy at Red Hat (JBoss)
Performance? • Writing code • Man hours more expensive than CPU hours • Developer contentedness • Running code • Straight line
High Performance? • Faster than... • ...other Ruby impls? • ...other language runtimes? • ...unmanaged languages, like C? • ...you need it to be?
“Fast Enough” • 1.8.7 was fast enough • 1.9.3 is fast enough • Unless it’s not fast enough • Does it matter?
Performance Wall • Move to a different runtime • Move to a different language • ...in whole or part
If you’re not writing perf- sensitive code in Ruby, you’re giving up too easily.
Native Extensions • Not universally bad • Just bad in MRI • Invasive • Pointers • Few guarantees
What We Want • Faster execution • Better GC • Parallel execution • Big data
What We Can’t Have • Faster execution • Better GC • Parallel execution • Big data
Different Approach • Build our own runtime? • YARV, Rubinius, MacRuby • Use an existing runtime? • JRuby, MagLev, MacRuby, IronRuby
Build or Buy • Making a new VM is “easy” • Making it competitive is really hard • I mean really, really, really hard
JVM • 15+ years of engineering by whole teams • FOSS • Fastest VM available • Best GCs available • Full parallel threading with guarantees • Broad platform support
But Java is Slow! • Java is very, very fast • Literally, C fast in many cases • Java applications can be slow • Oh hey, just like Ruby? • The way you write code is more important than the language you use.
JRuby • Java (and Ruby) impl of Ruby on JVM • Same memory, threading model • JRuby JITs to JVM bytecode • End of story, right?
Long, Hard Road • Interpreter optimization • JVM bytecode compiler • Optimizing core class methods • Lather, rinse, and repeat
Align with JVM • Individual arguments on call stack • JVM local variables • Avoid artificial framing • Avoid inter-call goo • Eliminate unnecessary work
Unnecessary Work • Modules are maps • Name to method • Name to constant • Name to class var • Instance variables as maps • Wasted cycles without caching
Method Lookup • Inside a class/module • Current class’s methods (a map) • Methods retrieved from class + ancestors • Serial or switch indicates staleness • Weak list of child classes • Class mutation cascades down hierarchy
Thing Person Place obj.to_s Rubyist Other
Method lookups go up-hierarchy Thing Person Place obj.to_s Rubyist Other
to_s Method lookups go up-hierarchy Thing Person Place obj.to_s Rubyist Other
to_s Method lookups go up-hierarchy Thing Lookup target caches result Person Place obj.to_s Rubyist Other
Method lookups go up-hierarchy Thing Lookup target caches result Person Place to_s obj.to_s Rubyist Other
Method lookups go up-hierarchy Thing Lookup target caches result Modification cascades down Person Place to_s obj.to_s Rubyist Other
Method lookups go up-hierarchy Thing to_s Lookup target caches result Modification cascades down Person Place to_s obj.to_s Rubyist Other
Constant Lookup • Cache at lookup site • Global serial/switch indicates staleness • Complexities of lookup, etc • Joy of Ruby interfering with Joy of Opto • Modifying constants triggers invalidation
Instance Vars • Class holds a table of offsets • Object holds array of values • Call site caches offset plus class ID • Same class, no lookup cost • Can be polymorphically chained
Optimizing Ruby • Make calls fast • Make constants free • Make instance variables cheap • Make closures lightweight • TODO
What is invokedynamic?
Invoke?
Invoke? That’s one use, but there are many others
Dynamic?
Dynamic? Dynamic typing is a common reason, but there are many others
JVM 101
JVM 101 200 opcodes
JVM 101 200 opcodes Ten (or 16) “data endpoints”
JVM 101 200 opcodes Ten (or 16) “data endpoints” Invocation invokevirtual invokeinterface invokestatic invokespecial
JVM 101 200 opcodes Ten (or 16) “data endpoints” Invocation Field Access invokevirtual getfield invokeinterface setfield invokestatic getstatic invokespecial setstatic
JVM 101 200 opcodes Ten (or 16) “data endpoints” Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic
JVM 101 200 opcodes Ten (or 16) “data endpoints” Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic All Java code revolves around these endpoints Remaining ops are stack, local vars, flow control allocation, and math/boolean/bit operations
JVM Opcodes
JVM Opcodes Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic
JVM Opcodes Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic Stack Local Vars Flow Control Allocation Boolean and Numeric
JVM Opcodes Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic Stack Local Vars Flow Control Allocation Boolean and Numeric
JVM Opcodes Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic Stack Local Vars Flow Control Allocation Boolean and Numeric
In Detail • JRuby generates code with indy calls • JVM at first call asks JRuby what to do • JRuby provides function pointers to code • Pointers include guards, invalidation logic • JRuby and JVM cooperate on optimizing
invokedynamic bytecode
invokedynamic bytecode bo ot stra p m et ho d
invokedynamic bytecode bo ot stra p m et ho d method handles
invokedynamic bytecode target method bo ot stra p m et ho d method handles
invokedynamic bytecode target method bo ot stra p m et ho d method handles
invokedynamic bytecode target method bo ot stra p m et ho d method handles
Dynamic Invocation Target Object associated with obj.foo() JVM Method Table def foo ... def bar ...
Dynamic Invocation VM Operations Target Object associated with obj.foo() JVM Method Table Call Site def foo ... def bar ...
Dynamic Invocation VM Operations Target Object associated with obj.foo() JVM Method Table Call Site def foo ... def bar ...
Dynamic Invocation VM Operations Method Lookup Target Object associated with obj.foo() JVM Method Table Call Site def foo ... def foo ... def bar ...
Dynamic Invocation VM Operations Method Lookup Target Branch Object associated with obj.foo() JVM Method Table Call Site def foo ... def foo ... def bar ...
Dynamic Invocation VM Operations Method Lookup Target Branch Method Cache Object associated with obj.foo() JVM def foo ... Method Table Call Site def foo ... def bar ...
Constants JVM Constant MY_CONST Lookup Call Site
Constants VM Operations JVM Constant MY_CONST Lookup Call Site
Constants VM Operations JVM Constant MY_CONST Lookup Call Site
Constants VM Operations Lookup Value JVM Constant MY_CONST value Lookup Call Site
Constants VM Operations Lookup Value Bind Permanently JVM Constant MY_CONST value Lookup Call Site
Instance Variables Target Object associated with @bar JVM Offset Table “@foo” => 0 “@bar” => 1
Instance Variables VM Operations Target Object associated with @bar JVM Offset Table Access Site “@foo” => 0 “@bar” => 1
Instance Variables VM Operations Instance Var Lookup Target Object associated with @bar JVM Offset Table Access Site “@foo” => 0 “@bar” => 1
Instance Variables VM Operations Instance Var Lookup Target Offset Cache Object associated with @bar JVM 1 Offset Table Access Site “@foo” => 0 “@bar” => 1
Instance Variables VM Operations Instance Var Lookup Target Offset Cache Access Object Object associated with @bar JVM 1 Offset Table Access Site “@foo” => 0 “@bar” => 1
Instance Variables VM Operations Instance Var Lookup Target Offset Cache Access Object Object associated with @bar JVM 1 Offset Table Access Site “@foo” => 0 “@bar” => 1
InvokeDynamic lets JRuby teach the JVM how Ruby works
How Do We Know We’ve Succeeded? • Benchmarking • Monitoring • User reports
Benchmarking is Hard • Runtimes may improve over time • Optimizer may eliminate useless code • Small systems are completely different • Know how your runtime optimizes!
bench_empty_method def foo; self; end i = 0 while i < 10_000_000 foo; foo; foo; foo; foo i += 1 end
Ruby 1.9.3 JRuby JRuby + indy 4s 3s 2s 1s 0s ZOMG 40X FA STER!
Observations
One slow runtime screws up the table
...do comparisons as ratios against a norm
JRuby calls empty methods really fast!!!
InvokeDynamic does not do much for us?
Ruby 1.9.3 JRuby JRuby + indy 4s 3s 2s 1s 0s
JVM Opto 101 • JITs code bodies after 10k calls • No 10k calls, no JIT (generally) • Inlines up to two targets • Optimistic • Early decisions may be wrong • Small code looks drastically different
SMALL CODE IS DIFFERENT THAN LARGE CODE
Inlining • Call site in method A and method B match • JVM treats them as though B lived in A • No call overhead • Variables visible across call boundary • More complete view for optimization
Optimistic • Say we have a system... • The only method dynamically called is “foo” • All logic for dyncall revolves around “foo” • Hotspot thinks all dyncalls will be “foo”
bench_empty_method2 def foo; self; end def bar1; self; end def bar2; self; end i = 0 while i < 10_000_000 bar1; bar1; bar1; bar1; bar1 bar2; bar2; bar2; bar2; bar2 i += 1 end ...
bench1 bench2 bench1 + indy bench2 + indy 0.7s 0.525s 0.35s 0.175s 0s
bench1 + rbx bench2 + rbx bench1 + indy bench2 + indy 0.4s 0.3s 0.2s 0.1s 0s
What Happened? • An unrelated change slowed our bench? • Not really unrelated • Hotspot optimizes early loop first • Later loop is different...calls “foo” • Assumptions change, perf looks different
Benchmarking is Not Enough • Need to monitor runtime optimization • JIT compilation • Inlining • Eventual native code (x86 ASM) • Fun?
1711 4 % bench_empty_method::block_0$RUBY$__file__ @ 56 (171 bytes) @ 59 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot) @ 16 java.lang.invoke.MethodHandle::invokeExact (5 bytes) inline (hot) @ 1 sun.invoke.util.ValueConversions::identity (2 bytes) inline (hot) @ 12 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 29 java.lang.invoke.MethodHandle::invokeExact (35 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (7 bytes) inline (hot) @ 3 org.jruby.runtime.invokedynamic.InvocationLinker::testMetaclass (17 bytes) inline (hot) @ 5 org.jruby.RubyBasicObject::getMetaClass (5 bytes) inline (hot) @ 14 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 31 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 6 bench_empty_method::method__0$RUBY$foo (2 bytes) inline (hot) @ 68 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot)
1711 4 % bench_empty_method::block_0$RUBY$__file__ @ 56 (171 bytes) @ 59 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot) @ 16 java.lang.invoke.MethodHandle::invokeExact (5 bytes) inline (hot) @ 1 sun.invoke.util.ValueConversions::identity (2 bytes) inline (hot) @ 12 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 29 java.lang.invoke.MethodHandle::invokeExact (35 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (7 bytes) inline (hot) @ 3 org.jruby.runtime.invokedynamic.InvocationLinker::testMetaclass (17 bytes) inline (hot) @ 5 org.jruby.RubyBasicObject::getMetaClass (5 bytes) inline (hot) @ 14 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 31 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 6 bench_empty_method::method__0$RUBY$foo (2 bytes) inline (hot) @ 68 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot)
1711 4 % bench_empty_method::block_0$RUBY$__file__ @ 56 (171 bytes) @ 59 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot) @ 16 java.lang.invoke.MethodHandle::invokeExact (5 bytes) inline (hot) @ 1 sun.invoke.util.ValueConversions::identity (2 bytes) inline (hot) @ 12 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 29 java.lang.invoke.MethodHandle::invokeExact (35 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (7 bytes) inline (hot) @ 3 org.jruby.runtime.invokedynamic.InvocationLinker::testMetaclass (17 bytes) inline (hot) @ 5 org.jruby.RubyBasicObject::getMetaClass (5 bytes) inline (hot) @ 14 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 31 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 6 bench_empty_method::method__0$RUBY$foo (2 bytes) inline (hot) @ 68 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot)
Decoding compiled method 0x000000010549d7d0: Code: [Entry Point] [Verified Entry Point] [Constants] # {method} 'method__0$RUBY$foo' '(Lbench_empty_method;Lorg/jruby/runtime/ThreadContext;Lorg/jruby/ runtime/builtin/IRubyObject;Lorg/jruby/runtime/Block;)Lorg/jruby/runtime/builtin/IRubyObject;' in 'bench_empty_method' # parm0: rsi:rsi = 'bench_empty_method' # parm1: rdx:rdx = 'org/jruby/runtime/ThreadContext' # parm2: rcx:rcx = 'org/jruby/runtime/builtin/IRubyObject' # parm3: r8:r8 = 'org/jruby/runtime/Block' # [sp+0x20] (sp of caller) 0x000000010549d900: sub $0x18,%rsp 0x000000010549d907: mov %rbp,0x10(%rsp) ;*synchronization entry ; - bench_empty_method::method__0$RUBY$foo@-1 (line 3) 0x000000010549d90c: mov %rcx,%rax 0x000000010549d90f: add $0x10,%rsp 0x000000010549d913: pop %rbp 0x000000010549d914: test %eax,-0xe9f91a(%rip) # 0x00000001045fe000 ; {poll_return} 0x000000010549d91a: retq
Decoding compiled method 0x000000010549d7d0: Code: [Entry Point] [Verified Entry Point] [Constants] # {method} 'method__0$RUBY$foo' '(Lbench_empty_method;Lorg/jruby/runtime/ThreadContext;Lorg/jruby/ runtime/builtin/IRubyObject;Lorg/jruby/runtime/Block;)Lorg/jruby/runtime/builtin/IRubyObject;' in 'bench_empty_method' # parm0: rsi:rsi = 'bench_empty_method' # parm1: rdx:rdx = 'org/jruby/runtime/ThreadContext' # parm2: rcx:rcx = 'org/jruby/runtime/builtin/IRubyObject' # parm3: r8:r8 = 'org/jruby/runtime/Block' # [sp+0x20] (sp of caller) 0x000000010549d900: sub $0x18,%rsp 0x000000010549d907: mov %rbp,0x10(%rsp) ;*synchronization entry ; - bench_empty_method::method__0$RUBY$foo@-1 (line 3) 0x000000010549d90c: mov %rcx,%rax 0x000000010549d90f: add $0x10,%rsp 0x000000010549d913: pop %rbp 0x000000010549d914: test %eax,-0xe9f91a(%rip) # 0x00000001045fe000 ; {poll_return} 0x000000010549d91a: retq
Decoding compiled method 0x000000010549d7d0: Code: [Entry Point] [Verified Entry Point] [Constants] # {method} 'method__0$RUBY$foo' '(Lbench_empty_method;Lorg/jruby/runtime/ThreadContext;Lorg/jruby/ runtime/builtin/IRubyObject;Lorg/jruby/runtime/Block;)Lorg/jruby/runtime/builtin/IRubyObject;' in 'bench_empty_method' # parm0: rsi:rsi = 'bench_empty_method' # parm1: rdx:rdx = 'org/jruby/runtime/ThreadContext' # parm2: rcx:rcx = 'org/jruby/runtime/builtin/IRubyObject' # parm3: r8:r8 = 'org/jruby/runtime/Block' # [sp+0x20] (sp of caller) 0x000000010549d900: sub $0x18,%rsp 0x000000010549d907: mov %rbp,0x10(%rsp) ;*synchronization entry ; - bench_empty_method::method__0$RUBY$foo@-1 (line 3) 0x000000010549d90c: mov %rcx,%rax 0x000000010549d90f: add $0x10,%rsp 0x000000010549d913: pop %rbp 0x000000010549d914: test %eax,-0xe9f91a(%rip) # 0x00000001045fe000 ; {poll_return} 0x000000010549d91a: retq
bench_empty_method3 def invoker1 i = 0 while i < 1000 foo; foo; foo; foo; foo i+=1 end end ... i = 0 while i < 10000 invoker1 i+=1 end
bench1 + indy bench2 + indy bench3 + indy 0.15s 0.113s 0.075s 0.038s 0s
Moral • Benchmarks are synthetic • Every system is different • Do your own testing
bench_red_black • Pure-Ruby red/black tree impl • Build a 100k tree of rand(999_999) • Delete all nodes • Build it again • Search for elements • In-order walks, min, max
Ruby 1.9.3 JRuby - indy JRuby + indy bench_red_black 5s 3.75s 2.5s 1.25s 0s
bench_fractal bench_flipflop_fractal • Mandelbrot generator • Integer loops • Floating-point math • Julia generator using flip-flops • I don’t really understand it.
def fractal_flipflop w, h = 44, 54 c = 7 + 42 * w a = [0] * w * h g = d = 0 f = proc do |n| a[c] += 1 o = a.map {|z| " :#"[z, 1] * 2 }.join.scan(/.{#{w * 2}}/) puts "f" + o.map {|l| l.rstrip }.join("n") d += 1 - 2 * ((g ^= 1 << n) >> n) c += [1, w, -1, -w][d %= 4] end 1024.times do !!(!!(!!(!!(!!(!!(!!(!!(!!(true... f[0])...f[1])...f[2])... f[3])...f[4])...f[5])... f[6])...f[7])...f[8]) end end
def fractal_flipflop w, h = 44, 54 c = 7 + 42 * w a = [0] * w * h g = d = 0 f = proc do |n| a[c] += 1 o = a.map {|z| " :#"[z, 1] * 2 }.join.scan(/.{#{w * 2}}/) puts "f" + o.map {|l| l.rstrip }.join("n") d += 1 - 2 * ((g ^= 1 << n) >> n) c += [1, w, -1, -w][d %= 4] end 1024.times do !!(!!(!!(!!(!!(!!(!!(!!(!!(true... f[0])...f[1])...f[2])... f[3])...f[4])...f[5])... f[6])...f[7])...f[8]) end end
Ruby 1.9.3 JRuby - indy JRuby + indy bench_fractal 1.5s 1.125s 0.75s 0.375s 0s
Ruby 1.9.3 JRuby - indy JRuby + indy bench_flipflop_fractal 1.5s 1.125s 0.75s 0.375s 0s
Rails?
Rails Perf • Mixed bag right now...some fast some slow • JVM JIT limits need to be bumped up • Significant gains for some folks • Long warmup times for so much code • Work continues!
What Next?
Expand Opto • Mixed-arity (ADD SLIDES ABOUT WHAT WE OPTIMIZE TODAY) • Super calls • Much, much lighter-weight closures • Then what?
Wacky Stuff • define_method methods? • method_missing call-throughs? • respond_to??? • proc tables? • All possible...but worth it?
The Future • JRuby will continue to get faster • Indy improvements at VM-level • Compiler improvements at Ruby level • If you can’t compete with JVM... • Still FOSS from top to bottom • Don’t be afraid!
Q/A

More Related Content

PDF
March2004-CPerlRun
bytutorialsruby
 
PPTX
Ruby3x3: How are we going to measure 3x
byMatthew Gaudet
 
PDF
Spring one2gx2010 spring-nonrelational_data
byRoger Xia
 
PDF
Improve extension API: C++ as better language for extension
byKouhei Sutou
 
PDF
What is new and cool j2se & java
byEugene Bogaart
 
PPT
What lies beneath the beautiful code?
byNiranjan Sarade
 
PDF
Experiments in Sharing Java VM Technology with CRuby
byMatthew Gaudet
 
PDF
Lifting The Veil - Reading Java Bytecode During Lunchtime
byAlexander Shopov
 
March2004-CPerlRun
bytutorialsruby
 
Ruby3x3: How are we going to measure 3x
byMatthew Gaudet
 
Spring one2gx2010 spring-nonrelational_data
byRoger Xia
 
Improve extension API: C++ as better language for extension
byKouhei Sutou
 
What is new and cool j2se & java
byEugene Bogaart
 
What lies beneath the beautiful code?
byNiranjan Sarade
 
Experiments in Sharing Java VM Technology with CRuby
byMatthew Gaudet
 
Lifting The Veil - Reading Java Bytecode During Lunchtime
byAlexander Shopov
 

What's hot

PDF
Lifting The Veil - Reading Java Bytecode
byAlexander Shopov
 
KEY
Opal compiler
byJorge Ressia
 
ODP
I Know Kung Fu - Juggling Java Bytecode
byAlexander Shopov
 
PDF
Gemification for Ruby 2.5/3.0
byHiroshi SHIBATA
 
PDF
IronSmalltalk
byESUG
 
PDF
Rsltollvm
bySyoyo Fujita
 
PDF
Ruby 4.0 To Infinity and Beyond at Ruby Conference Kenya 2017 by Bozhidar Batsov
byMichael Kimathi
 
PDF
In Vogue Dynamic
byAlexander Shopov
 
PDF
南宁会议 Metadata
byShanghai Library
 
PDF
Groovy Up Your Code
byPaulo Traça
 
PDF
Intro to J Ruby
byFrederic Jean
 
PDF
PHP.next: Traits
byStefan Marr
 
PPTX
Natural Intelligence ICCS 2010
byfmguler
 
PDF
Building DSLs with Xtext - Eclipse Modeling Day 2009
byHeiko Behrens
 
PDF
Introduction to Ruby
bykim.mens
 
PDF
Distributed Key-Value Stores- Featuring Riak
bysamof76
 
PDF
ZF2 Presentation @PHP Tour 2011 in Lille
byZend by Rogue Wave Software
 
PDF
Apache Con Us2007 Jcr In Action
byday
 
Lifting The Veil - Reading Java Bytecode
byAlexander Shopov
 
Opal compiler
byJorge Ressia
 
I Know Kung Fu - Juggling Java Bytecode
byAlexander Shopov
 
Gemification for Ruby 2.5/3.0
byHiroshi SHIBATA
 
IronSmalltalk
byESUG
 
Rsltollvm
bySyoyo Fujita
 
Ruby 4.0 To Infinity and Beyond at Ruby Conference Kenya 2017 by Bozhidar Batsov
byMichael Kimathi
 
In Vogue Dynamic
byAlexander Shopov
 
南宁会议 Metadata
byShanghai Library
 
Groovy Up Your Code
byPaulo Traça
 
Intro to J Ruby
byFrederic Jean
 
PHP.next: Traits
byStefan Marr
 
Natural Intelligence ICCS 2010
byfmguler
 
Building DSLs with Xtext - Eclipse Modeling Day 2009
byHeiko Behrens
 
Introduction to Ruby
bykim.mens
 
Distributed Key-Value Stores- Featuring Riak
bysamof76
 
ZF2 Presentation @PHP Tour 2011 in Lille
byZend by Rogue Wave Software
 
Apache Con Us2007 Jcr In Action
byday
 

Similar to High Performance Ruby - Golden Gate RubyConf 2012

KEY
InvokeDynamic - You Ain't Seen Nothin Yet
byCharles Nutter
 
PDF
Invokedynamic / JSR-292
byytoshima
 
PDF
Optimizing JavaScript and Dynamic Languages on the JVM
byMarcus Lagergren
 
PDF
Invoke dynamic your api to hotspot
byBoundary
 
KEY
Have Your Cake and Eat It Too: Meta-Programming Techniques for Java
byHoward Lewis Ship
 
PDF
JRuby and Invokedynamic - Japan JUG 2015
byCharles Nutter
 
PDF
Ola Bini Evolving The Java Platform
bydeimos
 
PDF
Message in a bottle
byKonstantin Haase
 
PPTX
Mastering Java Bytecode - JAX.de 2012
byAnton Arhipov
 
PDF
Jvm internals
byLuiz Fernando Teston
 
PDF
Invokedynamic in 45 Minutes
byCharles Nutter
 
PDF
Java Bytecode for Discriminating Developers - JavaZone 2011
byAnton Arhipov
 
PDF
Quick Intro To JRuby
byFrederic Jean
 
PDF
Introduction to the Java bytecode - So@t - 20130924
byyohanbeschi
 
PPTX
Metaprogramming Techniques In Groovy And Grails
byzenMonkey
 
PDF
Synthesizing API Usage Examples
byRay Buse
 
PDF
JRuby @ Boulder Ruby
byNick Sieger
 
PPTX
Java 10, Java 11 and beyond
byRafael Winterhalter
 
PDF
Practical Domain-Specific Languages in Groovy
byGuillaume Laforge
 
PDF
Mixing Source and Bytecode: A Case for Compilation By Normalization (OOPSLA 2...
bylennartkats
 
InvokeDynamic - You Ain't Seen Nothin Yet
byCharles Nutter
 
Invokedynamic / JSR-292
byytoshima
 
Optimizing JavaScript and Dynamic Languages on the JVM
byMarcus Lagergren
 
Invoke dynamic your api to hotspot
byBoundary
 
Have Your Cake and Eat It Too: Meta-Programming Techniques for Java
byHoward Lewis Ship
 
JRuby and Invokedynamic - Japan JUG 2015
byCharles Nutter
 
Ola Bini Evolving The Java Platform
bydeimos
 
Message in a bottle
byKonstantin Haase
 
Mastering Java Bytecode - JAX.de 2012
byAnton Arhipov
 
Jvm internals
byLuiz Fernando Teston
 
Invokedynamic in 45 Minutes
byCharles Nutter
 
Java Bytecode for Discriminating Developers - JavaZone 2011
byAnton Arhipov
 
Quick Intro To JRuby
byFrederic Jean
 
Introduction to the Java bytecode - So@t - 20130924
byyohanbeschi
 
Metaprogramming Techniques In Groovy And Grails
byzenMonkey
 
Synthesizing API Usage Examples
byRay Buse
 
JRuby @ Boulder Ruby
byNick Sieger
 
Java 10, Java 11 and beyond
byRafael Winterhalter
 
Practical Domain-Specific Languages in Groovy
byGuillaume Laforge
 
Mixing Source and Bytecode: A Case for Compilation By Normalization (OOPSLA 2...
bylennartkats
 

More from Charles Nutter

PDF
The Year of JRuby - RubyC 2018
byCharles Nutter
 
PDF
Down the Rabbit Hole: An Adventure in JVM Wonderland
byCharles Nutter
 
PDF
Ruby Performance - The Last Mile - RubyConf India 2016
byCharles Nutter
 
PDF
JRuby 9000 - Optimizing Above the JVM
byCharles Nutter
 
PDF
JRuby 9000 - Taipei Ruby User's Group 2015
byCharles Nutter
 
PDF
Fast as C: How to Write Really Terrible Java
byCharles Nutter
 
PDF
Open Source Software Needs You!
byCharles Nutter
 
PDF
InvokeBinder: Fluent Programming for Method Handles
byCharles Nutter
 
PDF
Over 9000: JRuby in 2015
byCharles Nutter
 
PDF
Doing Open Source the Right Way
byCharles Nutter
 
PDF
JRuby: The Hard Parts
byCharles Nutter
 
PDF
Bringing Concurrency to Ruby - RubyConf India 2014
byCharles Nutter
 
PDF
Beyond JVM - YOW! Sydney 2013
byCharles Nutter
 
PDF
Beyond JVM - YOW! Brisbane 2013
byCharles Nutter
 
PDF
Beyond JVM - YOW Melbourne 2013
byCharles Nutter
 
PDF
Down the Rabbit Hole
byCharles Nutter
 
PDF
The Future of JRuby - Baruco 2013
byCharles Nutter
 
PDF
High Performance Ruby - E4E Conference 2013
byCharles Nutter
 
PDF
Invokedynamic: Tales from the Trenches
byCharles Nutter
 
KEY
Why JRuby? - RubyConf 2012
byCharles Nutter
 
The Year of JRuby - RubyC 2018
byCharles Nutter
 
Down the Rabbit Hole: An Adventure in JVM Wonderland
byCharles Nutter
 
Ruby Performance - The Last Mile - RubyConf India 2016
byCharles Nutter
 
JRuby 9000 - Optimizing Above the JVM
byCharles Nutter
 
JRuby 9000 - Taipei Ruby User's Group 2015
byCharles Nutter
 
Fast as C: How to Write Really Terrible Java
byCharles Nutter
 
Open Source Software Needs You!
byCharles Nutter
 
InvokeBinder: Fluent Programming for Method Handles
byCharles Nutter
 
Over 9000: JRuby in 2015
byCharles Nutter
 
Doing Open Source the Right Way
byCharles Nutter
 
JRuby: The Hard Parts
byCharles Nutter
 
Bringing Concurrency to Ruby - RubyConf India 2014
byCharles Nutter
 
Beyond JVM - YOW! Sydney 2013
byCharles Nutter
 
Beyond JVM - YOW! Brisbane 2013
byCharles Nutter
 
Beyond JVM - YOW Melbourne 2013
byCharles Nutter
 
Down the Rabbit Hole
byCharles Nutter
 
The Future of JRuby - Baruco 2013
byCharles Nutter
 
High Performance Ruby - E4E Conference 2013
byCharles Nutter
 
Invokedynamic: Tales from the Trenches
byCharles Nutter
 
Why JRuby? - RubyConf 2012
byCharles Nutter
 

Recently uploaded

PDF
China to Europe Import Solutions for European Clients
byIreland in China
 
PPTX
The Power and Future of Artificial Intelligence.pptx
bymhradic
 
PDF
Your Guide to Purchasing Verified OnlyFans Accounts ....pdf
bysl9erqxqn
 
PDF
HOW to Buy Verified Coinbase Accounts Secure, Fast &amp
bytopusapvait
 
PDF
AQUATHEA – Innovative Water & Energy Technologies for a Sustainable Future
byflegras
 
DOCX
Top 3 Places to Buy Verified Binance Account Instantly.docx
bybusiness Guige Usaallhub
 
DOCX
Buy Verified Western Union Accounts 2025.docx
byusatrustacc3
 
PPTX
Business management and practices unit 1
byVinuthPaul
 
PDF
India’s Most Impactful Personalities to Follow in 2025 (2).pdf
bybusinessworldeurekad
 
PDF
Shiff - Focused Execution Webinar Presentation
byChristopherVicGamuya
 
PDF
Management Handbook by Yawar Hassan .pdf
byhseofficer1987
 
PDF
How to buy verified Venmo accounts this year from ....pdf
bypvatop service
 
PPTX
28th World Ethanol & Biofuels Conference
byTOFPIK
 
PDF
B,uy Self Bank Account in usa all country 2025.pdf
bysl9erqxqn
 
PDF
Bank Accounts & Customers in usa all country sells .pdf
bysl9erqxqn
 
PPTX
Business Management and practices unit 3,4,5.pptx
byVinuthPaul
 
PDF
business-leader-letter-to-the-chancellor-06-11-2025_v2.pdf
byHenry Tapper
 
DOCX
Buy Old Gmail Account 2010-2025 Mix Country.docx
byMarketing Tips
 
PDF
Your Guide to Purchasing Verified OnlyFans Accounts ....pdf
bysl9erqxqn
 
PPT
Business Management and Preactices - BMP - Unit Two.ppt
byVinuthPaul
 
China to Europe Import Solutions for European Clients
byIreland in China
 
The Power and Future of Artificial Intelligence.pptx
bymhradic
 
Your Guide to Purchasing Verified OnlyFans Accounts ....pdf
bysl9erqxqn
 
HOW to Buy Verified Coinbase Accounts Secure, Fast &amp
bytopusapvait
 
AQUATHEA – Innovative Water & Energy Technologies for a Sustainable Future
byflegras
 
Top 3 Places to Buy Verified Binance Account Instantly.docx
bybusiness Guige Usaallhub
 
Buy Verified Western Union Accounts 2025.docx
byusatrustacc3
 
Business management and practices unit 1
byVinuthPaul
 
India’s Most Impactful Personalities to Follow in 2025 (2).pdf
bybusinessworldeurekad
 
Shiff - Focused Execution Webinar Presentation
byChristopherVicGamuya
 
Management Handbook by Yawar Hassan .pdf
byhseofficer1987
 
How to buy verified Venmo accounts this year from ....pdf
bypvatop service
 
28th World Ethanol & Biofuels Conference
byTOFPIK
 
B,uy Self Bank Account in usa all country 2025.pdf
bysl9erqxqn
 
Bank Accounts & Customers in usa all country sells .pdf
bysl9erqxqn
 
Business Management and practices unit 3,4,5.pptx
byVinuthPaul
 
business-leader-letter-to-the-chancellor-06-11-2025_v2.pdf
byHenry Tapper
 
Buy Old Gmail Account 2010-2025 Mix Country.docx
byMarketing Tips
 
Your Guide to Purchasing Verified OnlyFans Accounts ....pdf
bysl9erqxqn
 
Business Management and Preactices - BMP - Unit Two.ppt
byVinuthPaul
 

High Performance Ruby - Golden Gate RubyConf 2012

  • 1.
  • 2.
    Hiya • Charles OliverNutter • [email protected] • @headius • JVM language guy at Red Hat (JBoss)
  • 3.
    Performance? • Writing code • Man hours more expensive than CPU hours • Developer contentedness • Running code • Straight line
  • 4.
    High Performance? • Fasterthan... • ...other Ruby impls? • ...other language runtimes? • ...unmanaged languages, like C? • ...you need it to be?
  • 5.
    “Fast Enough” • 1.8.7was fast enough • 1.9.3 is fast enough • Unless it’s not fast enough • Does it matter?
  • 6.
    Performance Wall • Moveto a different runtime • Move to a different language • ...in whole or part
  • 7.
    If you’re notwriting perf- sensitive code in Ruby, you’re giving up too easily.
  • 8.
    Native Extensions • Notuniversally bad • Just bad in MRI • Invasive • Pointers • Few guarantees
  • 9.
    What We Want •Faster execution • Better GC • Parallel execution • Big data
  • 10.
    What We Can’tHave • Faster execution • Better GC • Parallel execution • Big data
  • 11.
    Different Approach • Buildour own runtime? • YARV, Rubinius, MacRuby • Use an existing runtime? • JRuby, MagLev, MacRuby, IronRuby
  • 12.
    Build or Buy •Making a new VM is “easy” • Making it competitive is really hard • I mean really, really, really hard
  • 13.
    JVM • 15+ yearsof engineering by whole teams • FOSS • Fastest VM available • Best GCs available • Full parallel threading with guarantees • Broad platform support
  • 14.
    But Java isSlow! • Java is very, very fast • Literally, C fast in many cases • Java applications can be slow • Oh hey, just like Ruby? • The way you write code is more important than the language you use.
  • 15.
    JRuby • Java (andRuby) impl of Ruby on JVM • Same memory, threading model • JRuby JITs to JVM bytecode • End of story, right?
  • 16.
    Long, Hard Road •Interpreter optimization • JVM bytecode compiler • Optimizing core class methods • Lather, rinse, and repeat
  • 18.
    Align with JVM •Individual arguments on call stack • JVM local variables • Avoid artificial framing • Avoid inter-call goo • Eliminate unnecessary work
  • 19.
    Unnecessary Work • Modulesare maps • Name to method • Name to constant • Name to class var • Instance variables as maps • Wasted cycles without caching
  • 20.
    Method Lookup • Insidea class/module • Current class’s methods (a map) • Methods retrieved from class + ancestors • Serial or switch indicates staleness • Weak list of child classes • Class mutation cascades down hierarchy
  • 21.
    Thing Person Place obj.to_s Rubyist Other
  • 22.
    Method lookups goup-hierarchy Thing Person Place obj.to_s Rubyist Other
  • 23.
    to_s Method lookups goup-hierarchy Thing Person Place obj.to_s Rubyist Other
  • 24.
    to_s Method lookups goup-hierarchy Thing Lookup target caches result Person Place obj.to_s Rubyist Other
  • 25.
    Method lookups goup-hierarchy Thing Lookup target caches result Person Place to_s obj.to_s Rubyist Other
  • 26.
    Method lookups goup-hierarchy Thing Lookup target caches result Modification cascades down Person Place to_s obj.to_s Rubyist Other
  • 27.
    Method lookups goup-hierarchy Thing to_s Lookup target caches result Modification cascades down Person Place to_s obj.to_s Rubyist Other
  • 28.
    Constant Lookup • Cacheat lookup site • Global serial/switch indicates staleness • Complexities of lookup, etc • Joy of Ruby interfering with Joy of Opto • Modifying constants triggers invalidation
  • 29.
    Instance Vars • Classholds a table of offsets • Object holds array of values • Call site caches offset plus class ID • Same class, no lookup cost • Can be polymorphically chained
  • 30.
    Optimizing Ruby • Makecalls fast • Make constants free • Make instance variables cheap • Make closures lightweight • TODO
  • 31.
  • 32.
  • 33.
    Invoke? That’s one use,but there are many others
  • 34.
  • 35.
    Dynamic? Dynamic typing isa common reason, but there are many others
  • 36.
  • 37.
  • 38.
    JVM 101 200 opcodes Ten (or 16) “data endpoints”
  • 39.
    JVM 101 200 opcodes Ten (or 16) “data endpoints” Invocation invokevirtual invokeinterface invokestatic invokespecial
  • 40.
    JVM 101 200 opcodes Ten (or 16) “data endpoints” Invocation Field Access invokevirtual getfield invokeinterface setfield invokestatic getstatic invokespecial setstatic
  • 41.
    JVM 101 200 opcodes Ten (or 16) “data endpoints” Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic
  • 42.
    JVM 101 200 opcodes Ten (or 16) “data endpoints” Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic All Java code revolves around these endpoints Remaining ops are stack, local vars, flow control allocation, and math/boolean/bit operations
  • 43.
  • 44.
    JVM Opcodes Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic
  • 45.
    JVM Opcodes Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic Stack Local Vars Flow Control Allocation Boolean and Numeric
  • 46.
    JVM Opcodes Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic Stack Local Vars Flow Control Allocation Boolean and Numeric
  • 47.
    JVM Opcodes Invocation Field Access Array Access invokevirtual getfield *aload invokeinterface setfield *astore invokestatic getstatic b,s,c,i,l,d,f,a invokespecial setstatic Stack Local Vars Flow Control Allocation Boolean and Numeric
  • 49.
    In Detail • JRubygenerates code with indy calls • JVM at first call asks JRuby what to do • JRuby provides function pointers to code • Pointers include guards, invalidation logic • JRuby and JVM cooperate on optimizing
  • 51.
  • 52.
    invokedynamic bytecode bo ot stra p m et ho d
  • 53.
    invokedynamic bytecode bo ot stra p m et ho d method handles
  • 54.
    invokedynamic bytecode target method bo ot stra p m et ho d method handles
  • 55.
    invokedynamic bytecode target method bo ot stra p m et ho d method handles
  • 56.
    invokedynamic bytecode target method bo ot stra p m et ho d method handles
  • 57.
    Dynamic Invocation Target Object associated with obj.foo() JVM Method Table def foo ... def bar ...
  • 58.
    Dynamic Invocation VM Operations Target Object associated with obj.foo() JVM Method Table Call Site def foo ... def bar ...
  • 59.
    Dynamic Invocation VM Operations Target Object associated with obj.foo() JVM Method Table Call Site def foo ... def bar ...
  • 60.
    Dynamic Invocation VM Operations Method Lookup Target Object associated with obj.foo() JVM Method Table Call Site def foo ... def foo ... def bar ...
  • 61.
    Dynamic Invocation VM Operations Method Lookup Target Branch Object associated with obj.foo() JVM Method Table Call Site def foo ... def foo ... def bar ...
  • 62.
    Dynamic Invocation VM Operations Method Lookup Target Branch Method Cache Object associated with obj.foo() JVM def foo ... Method Table Call Site def foo ... def bar ...
  • 63.
    Constants JVM Constant MY_CONST Lookup Call Site
  • 64.
    Constants VM Operations JVM Constant MY_CONST Lookup Call Site
  • 65.
    Constants VM Operations JVM Constant MY_CONST Lookup Call Site
  • 66.
    Constants VM Operations Lookup Value JVM Constant MY_CONST value Lookup Call Site
  • 67.
    Constants VM Operations Lookup Value Bind Permanently JVM Constant MY_CONST value Lookup Call Site
  • 68.
    Instance Variables Target Object associated with @bar JVM Offset Table “@foo” => 0 “@bar” => 1
  • 69.
    Instance Variables VM Operations Target Object associated with @bar JVM Offset Table Access Site “@foo” => 0 “@bar” => 1
  • 70.
    Instance Variables VM Operations InstanceVar Lookup Target Object associated with @bar JVM Offset Table Access Site “@foo” => 0 “@bar” => 1
  • 71.
    Instance Variables VM Operations InstanceVar Lookup Target Offset Cache Object associated with @bar JVM 1 Offset Table Access Site “@foo” => 0 “@bar” => 1
  • 72.
    Instance Variables VM Operations InstanceVar Lookup Target Offset Cache Access Object Object associated with @bar JVM 1 Offset Table Access Site “@foo” => 0 “@bar” => 1
  • 73.
    Instance Variables VM Operations InstanceVar Lookup Target Offset Cache Access Object Object associated with @bar JVM 1 Offset Table Access Site “@foo” => 0 “@bar” => 1
  • 74.
    InvokeDynamic lets JRuby teachthe JVM how Ruby works
  • 75.
    How Do WeKnow We’ve Succeeded? • Benchmarking • Monitoring • User reports
  • 76.
    Benchmarking is Hard •Runtimes may improve over time • Optimizer may eliminate useless code • Small systems are completely different • Know how your runtime optimizes!
  • 77.
    bench_empty_method def foo; self;end i = 0 while i < 10_000_000 foo; foo; foo; foo; foo i += 1 end
  • 78.
    Ruby 1.9.3 JRuby JRuby + indy 4s 3s 2s 1s 0s ZOMG 40X FA STER!
  • 79.
  • 80.
  • 82.
  • 84.
  • 85.
  • 86.
    Ruby 1.9.3 JRuby JRuby + indy 4s 3s 2s 1s 0s
  • 87.
    JVM Opto 101 •JITs code bodies after 10k calls • No 10k calls, no JIT (generally) • Inlines up to two targets • Optimistic • Early decisions may be wrong • Small code looks drastically different
  • 88.
    SMALL CODE IS DIFFERENTTHAN LARGE CODE
  • 89.
    Inlining • Call sitein method A and method B match • JVM treats them as though B lived in A • No call overhead • Variables visible across call boundary • More complete view for optimization
  • 90.
    Optimistic • Say wehave a system... • The only method dynamically called is “foo” • All logic for dyncall revolves around “foo” • Hotspot thinks all dyncalls will be “foo”
  • 91.
    bench_empty_method2 def foo; self;end def bar1; self; end def bar2; self; end i = 0 while i < 10_000_000 bar1; bar1; bar1; bar1; bar1 bar2; bar2; bar2; bar2; bar2 i += 1 end ...
  • 92.
    bench1 bench2 bench1 + indy bench2 + indy 0.7s 0.525s 0.35s 0.175s 0s
  • 93.
    bench1 + rbx bench2 + rbx bench1 + indy bench2 + indy 0.4s 0.3s 0.2s 0.1s 0s
  • 94.
    What Happened? • Anunrelated change slowed our bench? • Not really unrelated • Hotspot optimizes early loop first • Later loop is different...calls “foo” • Assumptions change, perf looks different
  • 95.
    Benchmarking is Not Enough • Need to monitor runtime optimization • JIT compilation • Inlining • Eventual native code (x86 ASM) • Fun?
  • 96.
    1711 4 % bench_empty_method::block_0$RUBY$__file__ @ 56 (171 bytes) @ 59 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot) @ 16 java.lang.invoke.MethodHandle::invokeExact (5 bytes) inline (hot) @ 1 sun.invoke.util.ValueConversions::identity (2 bytes) inline (hot) @ 12 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 29 java.lang.invoke.MethodHandle::invokeExact (35 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (7 bytes) inline (hot) @ 3 org.jruby.runtime.invokedynamic.InvocationLinker::testMetaclass (17 bytes) inline (hot) @ 5 org.jruby.RubyBasicObject::getMetaClass (5 bytes) inline (hot) @ 14 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 31 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 6 bench_empty_method::method__0$RUBY$foo (2 bytes) inline (hot) @ 68 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot)
  • 97.
    1711 4 % bench_empty_method::block_0$RUBY$__file__ @ 56 (171 bytes) @ 59 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot) @ 16 java.lang.invoke.MethodHandle::invokeExact (5 bytes) inline (hot) @ 1 sun.invoke.util.ValueConversions::identity (2 bytes) inline (hot) @ 12 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 29 java.lang.invoke.MethodHandle::invokeExact (35 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (7 bytes) inline (hot) @ 3 org.jruby.runtime.invokedynamic.InvocationLinker::testMetaclass (17 bytes) inline (hot) @ 5 org.jruby.RubyBasicObject::getMetaClass (5 bytes) inline (hot) @ 14 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 31 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 6 bench_empty_method::method__0$RUBY$foo (2 bytes) inline (hot) @ 68 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot)
  • 98.
    1711 4 % bench_empty_method::block_0$RUBY$__file__ @ 56 (171 bytes) @ 59 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot) @ 16 java.lang.invoke.MethodHandle::invokeExact (5 bytes) inline (hot) @ 1 sun.invoke.util.ValueConversions::identity (2 bytes) inline (hot) @ 12 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 29 java.lang.invoke.MethodHandle::invokeExact (35 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (7 bytes) inline (hot) @ 3 org.jruby.runtime.invokedynamic.InvocationLinker::testMetaclass (17 bytes) inline (hot) @ 5 org.jruby.RubyBasicObject::getMetaClass (5 bytes) inline (hot) @ 14 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 31 java.lang.invoke.MethodHandle::invokeExact (10 bytes) inline (hot) @ 6 bench_empty_method::method__0$RUBY$foo (2 bytes) inline (hot) @ 68 java.lang.invoke.MethodHandle::invokeExact (33 bytes) inline (hot) @ 5 java.lang.invoke.MethodHandle::invokeExact (20 bytes) inline (hot) @ 2 java.lang.invoke.MethodHandle::invokeExact (9 bytes) inline (hot) @ 2 java.lang.invoke.MutableCallSite::getTarget (5 bytes) inline (hot)
  • 99.
    Decoding compiled method0x000000010549d7d0: Code: [Entry Point] [Verified Entry Point] [Constants] # {method} 'method__0$RUBY$foo' '(Lbench_empty_method;Lorg/jruby/runtime/ThreadContext;Lorg/jruby/ runtime/builtin/IRubyObject;Lorg/jruby/runtime/Block;)Lorg/jruby/runtime/builtin/IRubyObject;' in 'bench_empty_method' # parm0: rsi:rsi = 'bench_empty_method' # parm1: rdx:rdx = 'org/jruby/runtime/ThreadContext' # parm2: rcx:rcx = 'org/jruby/runtime/builtin/IRubyObject' # parm3: r8:r8 = 'org/jruby/runtime/Block' # [sp+0x20] (sp of caller) 0x000000010549d900: sub $0x18,%rsp 0x000000010549d907: mov %rbp,0x10(%rsp) ;*synchronization entry ; - bench_empty_method::method__0$RUBY$foo@-1 (line 3) 0x000000010549d90c: mov %rcx,%rax 0x000000010549d90f: add $0x10,%rsp 0x000000010549d913: pop %rbp 0x000000010549d914: test %eax,-0xe9f91a(%rip) # 0x00000001045fe000 ; {poll_return} 0x000000010549d91a: retq
  • 100.
    Decoding compiled method0x000000010549d7d0: Code: [Entry Point] [Verified Entry Point] [Constants] # {method} 'method__0$RUBY$foo' '(Lbench_empty_method;Lorg/jruby/runtime/ThreadContext;Lorg/jruby/ runtime/builtin/IRubyObject;Lorg/jruby/runtime/Block;)Lorg/jruby/runtime/builtin/IRubyObject;' in 'bench_empty_method' # parm0: rsi:rsi = 'bench_empty_method' # parm1: rdx:rdx = 'org/jruby/runtime/ThreadContext' # parm2: rcx:rcx = 'org/jruby/runtime/builtin/IRubyObject' # parm3: r8:r8 = 'org/jruby/runtime/Block' # [sp+0x20] (sp of caller) 0x000000010549d900: sub $0x18,%rsp 0x000000010549d907: mov %rbp,0x10(%rsp) ;*synchronization entry ; - bench_empty_method::method__0$RUBY$foo@-1 (line 3) 0x000000010549d90c: mov %rcx,%rax 0x000000010549d90f: add $0x10,%rsp 0x000000010549d913: pop %rbp 0x000000010549d914: test %eax,-0xe9f91a(%rip) # 0x00000001045fe000 ; {poll_return} 0x000000010549d91a: retq
  • 101.
    Decoding compiled method0x000000010549d7d0: Code: [Entry Point] [Verified Entry Point] [Constants] # {method} 'method__0$RUBY$foo' '(Lbench_empty_method;Lorg/jruby/runtime/ThreadContext;Lorg/jruby/ runtime/builtin/IRubyObject;Lorg/jruby/runtime/Block;)Lorg/jruby/runtime/builtin/IRubyObject;' in 'bench_empty_method' # parm0: rsi:rsi = 'bench_empty_method' # parm1: rdx:rdx = 'org/jruby/runtime/ThreadContext' # parm2: rcx:rcx = 'org/jruby/runtime/builtin/IRubyObject' # parm3: r8:r8 = 'org/jruby/runtime/Block' # [sp+0x20] (sp of caller) 0x000000010549d900: sub $0x18,%rsp 0x000000010549d907: mov %rbp,0x10(%rsp) ;*synchronization entry ; - bench_empty_method::method__0$RUBY$foo@-1 (line 3) 0x000000010549d90c: mov %rcx,%rax 0x000000010549d90f: add $0x10,%rsp 0x000000010549d913: pop %rbp 0x000000010549d914: test %eax,-0xe9f91a(%rip) # 0x00000001045fe000 ; {poll_return} 0x000000010549d91a: retq
  • 102.
    bench_empty_method3 def invoker1 i = 0 while i < 1000 foo; foo; foo; foo; foo i+=1 end end ... i = 0 while i < 10000 invoker1 i+=1 end
  • 103.
    bench1 + indy bench2 + indy bench3 + indy 0.15s 0.113s 0.075s 0.038s 0s
  • 104.
    Moral • Benchmarks aresynthetic • Every system is different • Do your own testing
  • 105.
    bench_red_black • Pure-Ruby red/blacktree impl • Build a 100k tree of rand(999_999) • Delete all nodes • Build it again • Search for elements • In-order walks, min, max
  • 106.
    Ruby 1.9.3 JRuby - indy JRuby + indy bench_red_black 5s 3.75s 2.5s 1.25s 0s
  • 107.
    bench_fractal bench_flipflop_fractal • Mandelbrot generator • Integer loops • Floating-point math • Julia generator using flip-flops • I don’t really understand it.
  • 109.
    def fractal_flipflop w, h = 44, 54 c = 7 + 42 * w a = [0] * w * h g = d = 0 f = proc do |n| a[c] += 1 o = a.map {|z| " :#"[z, 1] * 2 }.join.scan(/.{#{w * 2}}/) puts "f" + o.map {|l| l.rstrip }.join("n") d += 1 - 2 * ((g ^= 1 << n) >> n) c += [1, w, -1, -w][d %= 4] end 1024.times do !!(!!(!!(!!(!!(!!(!!(!!(!!(true... f[0])...f[1])...f[2])... f[3])...f[4])...f[5])... f[6])...f[7])...f[8]) end end
  • 110.
    def fractal_flipflop w, h = 44, 54 c = 7 + 42 * w a = [0] * w * h g = d = 0 f = proc do |n| a[c] += 1 o = a.map {|z| " :#"[z, 1] * 2 }.join.scan(/.{#{w * 2}}/) puts "f" + o.map {|l| l.rstrip }.join("n") d += 1 - 2 * ((g ^= 1 << n) >> n) c += [1, w, -1, -w][d %= 4] end 1024.times do !!(!!(!!(!!(!!(!!(!!(!!(!!(true... f[0])...f[1])...f[2])... f[3])...f[4])...f[5])... f[6])...f[7])...f[8]) end end
  • 112.
    Ruby 1.9.3 JRuby - indy JRuby + indy bench_fractal 1.5s 1.125s 0.75s 0.375s 0s
  • 113.
    Ruby 1.9.3 JRuby - indy JRuby + indy bench_flipflop_fractal 1.5s 1.125s 0.75s 0.375s 0s
  • 114.
  • 115.
    Rails Perf • Mixedbag right now...some fast some slow • JVM JIT limits need to be bumped up • Significant gains for some folks • Long warmup times for so much code • Work continues!
  • 116.
  • 117.
    Expand Opto • Mixed-arity(ADD SLIDES ABOUT WHAT WE OPTIMIZE TODAY) • Super calls • Much, much lighter-weight closures • Then what?
  • 118.
    Wacky Stuff • define_methodmethods? • method_missing call-throughs? • respond_to??? • proc tables? • All possible...but worth it?
  • 119.
    The Future • JRubywill continue to get faster • Indy improvements at VM-level • Compiler improvements at Ruby level • If you can’t compete with JVM... • Still FOSS from top to bottom • Don’t be afraid!
  • 120.

Editor's Notes