Accelerating iterators in optimizing AST interpreters

ZhangWei,; LarsenPer,; BrunthalerStefan,; FranzMichael,

doi:10.1145/2714064.2660223

Cited by 4 publications

(3 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Complex language constructs can also be optimized. For instance Zhang et al [2014] demonstrate how to optimize Python's generators based on AST specialization and peeling of generators. Similarly, Kalibera et al [2014] use views on R vectors to realize R's complex data semantics with good performance.…”

Section: Self-optimizing Interpretersmentioning

confidence: 99%

Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises

Marr

Seaton

Ducasse

2015

Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

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.

show abstract

Section: Self-optimizing Interpretersmentioning

confidence: 99%

Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises

Marr

Seaton

Ducasse

2015

Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

show abstract

“…Kalibera et al [20] discussed the challenges of a self-optimizing interpreter for the R language to address the dynamic and lazy nature of R. They detail a number of structural optimizations similar to the ones discussed here, dynamic operation and variable specialization, inline caching, data type specializations, as well as a profiling-based optimization of R's view feature, which is a complex language feature that has different tradeoffs depending on the size of vectors it is used on. A similarly complex language feature that has been optimized in this context is Python's generators [30].…”

Section: Related Workmentioning

confidence: 99%

Tracing vs. partial evaluation: comparing meta-compilation approaches for self-optimizing interpreters

MarrStefan¹,

DucasseStéphane²

2015

SIGPLAN Not.

View full text Add to dashboard Cite

Tracing and partial evaluation have been proposed as metacompilation techniques for interpreters to make just-in-time compilation language-independent. They promise that programs executing on simple interpreters can reach performance of the same order of magnitude as if they would be executed on state-of-the-art virtual machines with highly optimizing just-in-time compilers built for a specific language. Tracing and partial evaluation approach this metacompilation from two ends of a spectrum, resulting in different sets of tradeoffs.This study investigates both approaches in the context of self-optimizing interpreters, a technique for building fast abstract-syntax-tree interpreters. Based on RPython for tracing and Truffle for partial evaluation, we assess the two approaches by comparing the impact of various optimizations on the performance of an interpreter for SOM, an objectoriented dynamically-typed language. The goal is to determine whether either approach yields clear performance or engineering benefits. We find that tracing and partial evaluation both reach roughly the same level of performance. SOM based on meta-tracing is on average 3x slower than Java, while SOM based on partial evaluation is on average 2.3x slower than Java. With respect to the engineering, tracing has however significant benefits, because it requires language implementers to apply fewer optimizations to reach the same level of performance.

show abstract

“…Besides the JavaScript implementation described in this paper, Truffle DSL is used in the open-source Python implementation ZipPy [33], the open-source R implementation FastR [15], in a Smalltalk interpreter [4], and in an experimental interpreter for JRuby [9]. They show on different use-cases similarly promising results as Truffle JavaScript.…”

Section: Current Use Of Truffle Dslmentioning

confidence: 99%

A domain-specific language for building self-optimizing AST interpreters

Humer¹,

Wimmer

Wirth³

et al. 2014

Proceedings of the 2014 International Conference on Generative Programming: Concepts and Experiences

View full text Add to dashboard Cite

Self-optimizing AST interpreters dynamically adapt to the provided input for faster execution. This adaptation includes initial tests of the input, changes to AST nodes, and insertion of guards that ensure assumptions still hold. Such specialization and speculation is essential for the performance of dynamic programming languages such as JavaScript. In traditional procedural and objectoriented programming languages it can be tedious to write selfoptimizing AST interpreters, as those languages fail to provide constructs that would specifically support that.This paper introduces a declarative domain-specific language (DSL) that greatly simplifies writing self-optimizing AST interpreters. The DSL supports specialization of operations based on types of the input and other properties. It can then use these specializations directly or chain them to represent the operation with the minimum amount of code possible. The DSL significantly reduces the complexity of expressing specializations for those interpreters. We use it in our high-performance implementation of JavaScript, where 274 language operations have an average of about 4 and a maximum of 190 specializations. In addition, the DSL is used in implementations of Ruby, Python, R, and Smalltalk.

show abstract

Accelerating iterators in optimizing AST interpreters

Cited by 4 publications

References 16 publications

Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises

Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises

Tracing vs. partial evaluation: comparing meta-compilation approaches for self-optimizing interpreters

A domain-specific language for building self-optimizing AST interpreters

Contact Info

Product

Resources

About