Runtime metaprogramming enables many useful applications and is often a convenient solution to solve problems in a generic way, which makes it widely used in frameworks, middleware, and domain-specific languages. However, powerful metaobject protocols are rarely supported and even common concepts such as reflective method invocation or dynamic proxies are not optimized. Solutions proposed in literature either restrict the metaprogramming capabilities or require application or library developers to apply performance improving techniques. For overhead-free runtime metaprogramming, we demonstrate that dispatch chains, a generalized form of polymorphic inline caches common to self-optimizing interpreters, are a simple optimization at the language-implementation level. Our evaluation with self-optimizing interpreters shows that unrestricted metaobject protocols can be realized for the first time without runtime overhead, and that this optimization is applicable for just-in-time compilation of interpreters based on meta-tracing as well as partial evaluation. In this context, we also demonstrate that optimizing common reflective operations can lead to significant performance improvements for existing applications.

1. Zero-Overhead Metaprogramming
Using Self-Optimizing Interpreters to Remove the
Runtime Cost of Reflective Programming
Stefan Marr, INRIA Lille
Research collaboration with Chris Seaton, Oracle Labs
and Stéphane Ducasse, INRIA Lille___
PLDI, June 17, 2015

2. Runtime Metaprogramming
==
Just Another Form of Late Binding
 Optimized as Such
2

3. Zero-Overhead Metaprogramming
Using Self-Optimizing Interpreters to Remove the
Runtime Cost of Reflective Programming
Stefan Marr, INRIA Lille
Research collaboration with Chris Seaton, Oracle Labs
and Stéphane Ducasse, INRIA Lille___
PLDI, June 17, 2015

4. Runtime Metaprogramming
4
class Proxy
def method_missing(name, *args, &block)
target.send(name, *args, &block)
end
end
obj.invoke('foo', [])
obj.getField(idx)
obj.setField(idx, val)
Powerful and Useful
Frameworks, Domain-Specific Languages, …

5. Metaobject Protocol Example
Building a Safe Actor Framework
class ActorDomain : Domain {
fn writeToField(obj, fieldIdx, value) {
if (Domain.current() == this) {
obj.setField(fieldIdx, value);
} else {
throw new IsolationError(obj);
}
}
/* ... */
}
5
http://stefan-marr.de/research/omop/

6. Metaprogramming is slooow!
6
meth.invoke() 0.7x Overhead
Dynamic Proxies 6.5x Overhead

7. Everybody Knows:
Runtime
Metaprogramming is slooow!
7

8. OPTIMIZING REFLECTIVE OPERATIONS
8
obj.invoke('foo', [])
obj.getField(idx)
obj.setField(idx, val)
Method Invocation, Field Accesses, …

9. Reflective Method Invocation
9
cnt.invoke('+', [1])
How to optimize this?

10. Optimize Direct Invocation
10
cnt + 1
Hölzle, Chambers, Ungar, ’91.
cnt.+(1)
is polymorphic
-> Cache at Send Site
Solution: Polymorphic Inline Cache
• Avoids lookup
• Enables JIT to
inline

11. Generalize Polymorphic Inline Caches
to Dispatch Chains
11
cnt 1
invocation
read var literal
+
dispatch chain
dispatch
method
cnt.+(1)
Common Place in Self-Optimizing Interpreters:
Würthinger et al. [2012], Humer et al. [2014], Wöß et al. [2014]
Chain Nodes can have
arbitrary behavior

12. Dispatch Chain for Method Invocation
12
Un
Init
cnt: 0 (Integer object)
+ int ++
check class==int
true
false
Un
Init
Cache
Node
cnt.+(1)
• Avoids lookup
• Enables inlining
int

13. Reflective Method Invocation
13
cnt.invoke('+', [1])
How to optimize this?

14. Optimizing Reflective Method Invocation
14
cnt.invoke('+', [1])
'+
UnIn
Invoke
Node
cnt [1]
dispatch chain
on method name

15. Name
Node
15
UnIn
method
dispatch chain
dispatch
method
dispatch chain
on method name
Optimizing Reflective Method Invocation
cnt.invoke('+', [1])
'+'
Invoke
Node
cnt [1]
'+'
check name=='+'
true
false
nesting of dispatch
chains
resolves variability

16. Simple Metaprogramming Solved!
16
class Proxy
def method_missing(name, *args, &block)
target.send(name, *args, &block)
end
end
obj.invoke('foo', [])
obj.getField(idx)
obj.setField(idx, val) ✔
✔

17. Metaobject Protocol Example
Building a Safe Actor Framework
class ActorDomain : Domain {
fn writeToField(obj, fieldIdx, value) {
if (Domain.current() == this) {
obj.setField(fieldIdx, value);
} else {
throw new IsolationError(obj);
}
}
/* ... */
}
17
http://stefan-marr.de/research/omop/

18. An Actor Example
18
actor.fieldA := 1
actor
.fieldA :=
1
temp variable
read
literal
field write semantic depends
on metaobject

19. Dispatch Chains to Resolve Variability
19
field write
UnIn
dispatch chain
on metaobject
CacheMObj.fieldA := ActorDomain.
writeToField()
Intercession
handler

20. Dispatch Chains to Resolve Variability
20
field write
UnIn
dispatch chain
on metaobject
CacheMObj.fieldA :=
Shortcut for standard semantics
ActorDomain.
writeToField()
Intercession
handler
StdDomain StdWrite
Standard
direct write

21. DOES IT WORK?
Is it fast?
21

22. Evaluation: Self-Optimizing Interpreters
Academic “Simplicity”
Verify idea independent of
compilation technique
• Meta-Tracing (RPython)
• Partial Evaluation (Truffle)
Industrial “Sophistication”
High-Performance Truffle Backend
for JRuby
• Case Study with Production
Code
22
http://som-st.github.io
+Truffle
https://github.com/jruby/jruby/wiki/Truffle

23. Simple Metaprogramming: Zero Overhead
23
http://stefan-marr.de/papers/pldi-marr-et-al-zero-overhead-metaprogramming-artifacts/

24. Production Code: Image Processing
24
●
●
●
●
●
10.0
12.5
15.0
17.5
20.0
ComposeColorBurn
ComposeColorDodge
ComposeDarken
ComposeDifference
ComposeExclusion
ComposeHardLight
ComposeHardMix
ComposeLighten
ComposeLinearBurn
ComposeLinearDodge
ComposeLinearLight
ComposeMultiply
ComposeNormal
ComposeOverlay
ComposePinLight
ComposeScreen
ComposeSoftLight
ComposeVividLight
Speedupoverunoptimized
(higherisbetter)
+Truffle
Speedupoverunoptimized
(higherisbetter)

25. OMOP Overhead
25
meta-tracing partial evaluation
Overhead: 4% (min. -1%, max. 19%) Overhead: 9% (min. -7%, max. 38%)
●
●
●●●●
●
●
●●
●
●●
●
●
●
●●●●●
●
●
●●
●●
●●
●
●●●●●●
●●
●●●●●
●
●●●●●●
●●●●
●●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●●●
●
●●●
●●
●●●●
●
●●●
●
●●●●
●●●●
●
●
●
●●●●●●
●●●
●●●
●
●●●●●
●●●
●●●
●●●●
●●●●
●
●●●●
●●
●●
●
●
●●
●
●
●●●
1.00
1.05
1.10
1.15
1.20
Bounce
BubbleSort
Dispatch
Fannkuch
Fibonacci
FieldLoop
IntegerLoop
List
Loop
Permute
QuickSort
Recurse
Storage
Sum
Towers
TreeSort
WhileLoop
DeltaBlue
Mandelbrot
NBody
Richards
RuntimeRatiotorunwithoutOMOP
SOMMT
●●●●●●●●●●●●●●●●●●●●●●●●●●
●
●●●●●●●●●●●●●●●●●●●●●●
0.8
1.0
1.2
1.4
Bounce
BubbleSort
Dispatch
Fannkuch
Fibonacci
FieldLoop
IntegerLoop
List
Loop
Permute
QuickSort
Recurse
Storage
Sum
Towers
TreeSort
WhileLoop
DeltaBlue
Mandelbrot
NBody
Richards
RuntimeRatiotorunwithoutOMOP
SOMPE

26. Open Research Questions
• Do programs with MOPs have classic trimodal
distribution of send-site polymorphism?
– i.e. does basic PIC hypothesis apply?
– Same polymorphism degree, inlining limits, …
• How to implement dispatch chains efficiently
in classic tier JIT compilers?
26

27. Dispatch Chains: A Generalization of PICs
• Complete removal of reflective overhead
–Simple and sufficient
–For meta-tracing and partial evaluation
• Enables
–Zero-Overhead Metaprogramming
–efficient MOPs for smarter DSLs
27
dispatch chain
dispatch
method

28. Runtime Metaprogramming
==
Just Another Form of Late Binding
 Optimized as Such
28
+Truffle
http://stefan-marr.de/papers/pldi-marr-et-al-zero-overhead-metaprogramming/