Are We There Yet?: Simple Language Implementation Techniques for the 21st Century

Marr, Stefan; Pape, Tobias; Meuter, Wolfgang De

doi:10.1109/ms.2014.98

Cited by 10 publications

(6 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Often language implementations sacrifice the clarity of simple abstract machines for lower-level runtime models-with a meta-tracing JIT such as RPython, the high-level approach can perform well. More generally, Pycket demonstrates the value of the RPython infrastructure (Marr et al 2014): We have built in one year and 12,000 LOC a compiler competitive with existing mature systems. We encourage other implementors to consider if RPython can provide them with the same leverage.…”

Section: Resultsmentioning

confidence: 99%

Pycket: a tracing JIT for a functional language

Bauman

Bolz

Hirschfeld³

et al. 2015

SIGPLAN Not.

Self Cite

View full text Add to dashboard Cite

We present Pycket, a high-performance tracing JIT compiler for Racket. Pycket supports a wide variety of the sophisticated features in Racket such as contracts, continuations, classes, structures, dynamic binding, and more. On average, over a standard suite of benchmarks, Pycket outperforms existing compilers, both Racket's JIT and other highly-optimizing Scheme compilers. Further, Pycket provides much better performance for proxies than existing systems, dramatically reducing the overhead of contracts and gradual typing. We validate this claim with performance evaluation on multiple existing benchmark suites.The Pycket implementation is of independent interest as an application of the RPython meta-tracing framework (originally created for PyPy), which automatically generates tracing JIT compilers from interpreters. Prior work on meta-tracing focuses on bytecode interpreters, whereas Pycket is a high-level interpreter based on the CEK abstract machine and operates directly on abstract syntax trees. Pycket supports proper tail calls and first-class continuations. In the setting of a functional language, where recursion and higher-order functions are more prevalent than explicit loops, the most significant performance challenge for a tracing JIT is identifying which control flows constitute a loop-we discuss two strategies for identifying loops and measure their impact.

show abstract

Section: Resultsmentioning

confidence: 99%

Pycket: a tracing JIT for a functional language

Bauman

Bolz

Hirschfeld³

et al. 2015

SIGPLAN Not.

Self Cite

View full text Add to dashboard Cite

show abstract

“…In combination with the Graal JIT compiler [24], selfoptimizing interpreters can reach performance of the same order of magnitude as Java on top of HotSpot [13]. To reach this performance, Truffle applies partial evaluation on the specialized ASTs to determine the compilation unit that corresponds to a relevant part of a guest-language's program, which is then optimized and compiled to native code by Graal using classic compiler optimizations, inlining, and escape analysis.…”

Section: Truffle and Graalmentioning

confidence: 99%

Building efficient and highly run-time adaptable virtual machines

Chari

Garbervetsky

Marr³

2016

Proceedings of the 12th Symposium on Dynamic Languages

Self Cite

View full text Add to dashboard Cite

Programming language virtual machines (VMs) realize language semantics, enforce security properties, and execute applications efficiently. Fully Reflective Execution Environments (EEs) are VMs that additionally expose their whole structure and behavior to applications. This enables developers to observe and adapt VMs at run time. However, there is a belief that reflective EEs are not viable for practical usages because such flexibility would incur a high performance overhead.To refute this belief, we built a reflective EE on top of a highly optimizing dynamic compiler. We introduced a new optimization model that, based on the conjecture that variability of low-level (EE-level) reflective behavior is low in many scenarios, mitigates the most significant sources of the performance overheads related to the reflective capabilities in the EE. Our experiments indicate that reflective EEs can reach peak performance in the order of standard VMs. Concretely, that a) if reflective mechanisms are not used the execution overhead is negligible compared to standard VMs, b) VM operations can be redefined at language-level without incurring in significant overheads, c) for several software adaptation tasks, applying the reflection at the VM level is not only lightweight in terms of engineering effort, but also competitive in terms of performance in comparison to other ad-hoc solutions.

show abstract

“…In previous work, we studied whether both approaches deliver on their performance promise [21]. However, we compared a bytecode-based with a self-optimizing AST interpreter limiting the explanatory value of the results.…”

Section: Related Workmentioning

confidence: 99%

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

MarrStefan¹,

DucasseStéphane²

2015

SIGPLAN Not.

Self Cite

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

Are We There Yet?: Simple Language Implementation Techniques for the 21st Century

Cited by 10 publications

References 11 publications

Pycket: a tracing JIT for a functional language

Pycket: a tracing JIT for a functional language

Building efficient and highly run-time adaptable virtual machines

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

Contact Info

Product

Resources

About