Loop Parallelisation for the Jikes RVM

Zhao, Jisheng; Rogers, Ian; Kirkham, Chris; Watson, Ian

doi:10.1109/pdcat.2005.164

Cited by 9 publications

(1 citation statement)

References 5 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Zhao et al [91] use duplication to parallelize loops in a JVM. Their detection of suitable loops is similar to our loop analysis, although with different aims and filter criteria: They inspect the shape of a loop, i.e., the exit criterion and parameter shapes, while we use intrinsics introduced into the language implementation to find targets.…”

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

Safe bounds check annotations

Ronne

Gampe

Niedzielski

et al. 2008

Concurrency and Computation

View full text Add to dashboard Cite

SUMMARYThe semantics of the Java programming language require that the out-of-bounds array accesses be caught at runtime. In general, this requires dynamic checks at the time the array element is accessed. Some of these checks can be eliminated statically during just-in-time (JIT) compilation, but the most precise analyses are too expensive to run in JIT compilers. This paper presents a framework in which thorough static range analyses can be used safely during the less-performance-critical compilation of Java source into machine-independent mobile code. In this framework, the static analysis results are used to derive proofs that certain linear inequality constraints hold. These linear constraints and their proofs are then added to the mobile code as annotations. The annotation framework is designed so that proofs can be verified efficiently. This allows the JIT compiler to safely eliminate array bounds checks during compilation without an expensive runtime analysis. Experiments with a prototype system that can generate and verify these annotations demonstrate that this framework is more precise than prior work and that verification is efficient.

show abstract

Untitled

Michael

Praun

et al. 2009

Concurrency and Computation

View full text Add to dashboard Cite

Loop Parallelisation for the Jikes RVM

Cited by 9 publications

References 5 publications

Control Flow Duplication for Columnar Arrays in a Dynamic Compiler

Control Flow Duplication for Columnar Arrays in a Dynamic Compiler

Safe bounds check annotations

Untitled

Contact Info

Product

Resources

About