Loop-aware optimizations in PyPy's tracing JIT

Ardö, Håkan; Bolz, Carl Friedrich; FijaBkowski, Maciej

doi:10.1145/2480360.2384586

Cited by 3 publications

(3 citation statements)

References 15 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Loop optimizations are prevalent in modern compilers such as PyPy [8,9,72], V8 [82], the HotSpot C2 Server Compiler [68], and the GraalVM Compiler [24,52]. Techniques such as loop peeling [10] and loop unrolling [27] utilize duplication to replicate the loop body.…”

Section: Compiler Optimizationsmentioning

confidence: 99%

Control Flow Duplication for Columnar Arrays in a Dynamic Compiler

et al. 2023

View full text Add to dashboard Cite

Columnar databases are an established way to speed up online analytical processing (OLAP) queries. Nowadays, data processing (e.g., storage, visualization, and analytics) is often performed at the programming language level, hence it is desirable to also adopt columnar data structures for common language runtimes.While there are frameworks, libraries, and APIs to enable columnar data stores in programming languages, their integration into applications typically requires developer interference. In prior work, researchers implemented an approach for automated transformation of arrays into columnar arrays in the GraalVM JavaScript runtime. However, this approach suffers from performance issues on smaller workloads as well as on more complex nested data structures. We find that the key to optimizing accesses to columnar arrays is to identify queries and apply specific optimizations to them.In this paper, we describe novel compiler optimizations in the GraalVM Compiler that optimize queries on columnar arrays. At JIT compile time, we identify loops that access potentially columnar arrays and duplicate them in order to specifically optimize accesses to columnar arrays. Additionally, we describe a new approach for creating columnar arrays from arrays consisting of complex objects by performing multi-level storage transformation. We demonstrate our approach via an implementation for JavaScript Date objects.Our work shows that automatic transformation of arrays to columnar storage is feasible even for small workloads and that more complex arrays of objects could benefit from a multi-level transformation. Furthermore, we show how we can optimize methods that handle arrays in different states by the use of duplication. We evaluated our work on microbenchmarks and established data analytics workloads (TPC-H) to demonstrate that it significantly outperforms previous efforts, with speedups of up to 10x for particular queries. Queries additionally benefit from multi-level transformation, reaching speedups of around 2x. Additionally, we show that we do not cause significant overhead on workloads not suitable for storage transformation.We argue that automatically created columnar arrays could aid developers in data-centric applications as an alternative approach to using dedicated APIs on manually created columnar arrays. Via automatic detection and optimization of queries on potentially columnar arrays, we can improve performance of data processing and further enable its use in common-particularly dynamic-programming languages. ACM CCS 2012Software and its engineering → Dynamic compilers; Runtime environments; Interpreters; Information systems → Column based storage;

show abstract

Section: Compiler Optimizationsmentioning

confidence: 99%

Control Flow Duplication for Columnar Arrays in a Dynamic Compiler

et al. 2023

View full text Add to dashboard Cite

show abstract

“…Standard Optimizations RPython's trace optimizer includes a suite of standard compiler optimizations, such as commonsubexpression elimination, copy propagation, constant folding, and many others (Ardö et al 2012). One advantage of trace compilation for optimization is that the linear control-flow graph of a trace is just a straight line.…”

Section: Generic Rpython Optimizationsmentioning

confidence: 99%

“…Loop-invariant code motion Another common compiler optimization is loop-invariant code motion. RPython implements this in a particularly simple way, by peeling off a single iteration of the loop, and then performing its standard suite of forward analyses to optimize the loop further (Ardö et al 2012). 3 Because many loopinvariant computations are performed in the peeled iteration, they can then be omitted the second time, removing them from the actual loop body.…”

Section: Generic Rpython Optimizationsmentioning

confidence: 99%

Pycket: a tracing JIT for a functional language

Bauman

Bolz

Hirschfeld³

et al. 2015

Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming

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