September 2024
What is this page?
This page lists works of an author who doesn't have a ResearchGate profile or hasn't added the works to their profile yet. It is automatically generated from public (personal) data to further our legitimate goal of comprehensive and accurate scientific recordkeeping. If you are this author and want this page removed, please let us know.
Publications (71)
June 2024
·
7 Reads
·
1 Citation
Proceedings of the ACM on Programming Languages
Designing a whole-program static analysis requires trade-offs between precision and scalability. While a context-insensitive points-to analysis is often considered a good compromise, it still has non-linear complexity that leads to scalability problems when analyzing large applications. On the other hand, rapid type analysis scales well but lacks precision. We use saturation in a context-insensitive type-based points-to analysis to make it as scalable as a rapid type analysis, while preserving most of the precision of the points-to analysis. With saturation, the points-to analysis only propagates small points-to sets for variables. If a variable can have more values than a certain threshold, the variable and all its usages are considered saturated and no longer analyzed. Our implementation in the points-to analysis of GraalVM Native Image, a closed-world approach to build standalone binaries for Java applications, shows that saturation allows GraalVM Native Image to analyze large Java applications with hundreds of thousands of methods in less than two minutes.
October 2023
·
4 Reads
·
1 Citation
August 2023
·
81 Reads
Whole-program analysis is an essential technique that enables advanced compiler optimizations. An important example of such a method is points-to analysis used by ahead-of-time (AOT) compilers to discover program elements (classes, methods, fields) used on at least one program path. GraalVM Native Image uses a points-to analysis to optimize Java applications, which is a time-consuming step of the build. We explore how much the analysis time can be improved by replacing the points-to analysis with a rapid type analysis (RTA), which computes reachable elements faster by allowing more imprecision. We propose several extensions of previous approaches to RTA: making it parallel, incremental, and supporting heap snapshotting. We present an extensive experimental evaluation of the effects of using RTA instead of points-to analysis, in which RTA allowed us to reduce the analysis time for Spring Petclinic, a popular demo application of the Spring framework, by 64% and the overall build time by 35% at the cost of increasing the image size due to the imprecision by 15%.
October 2021
·
30 Reads
·
8 Citations
October 2021
·
8 Reads
·
10 Citations
June 2021
·
23 Reads
·
5 Citations
February 2020
·
19 Reads
·
16 Citations
October 2019
·
1,176 Reads
·
55 Citations
Proceedings of the ACM on Programming Languages
Arbitrary program extension at run time in language-based VMs, e.g., Java's dynamic class loading, comes at a startup cost: high memory footprint and slow warmup. Cloud computing amplifies the startup overhead. Microservices and serverless cloud functions lead to small, self-contained applications that are started often. Slow startup and high memory footprint directly affect the cloud hosting costs, and slow startup can also break service-level agreements. Many applications are limited to a prescribed set of pre-tested classes, i.e., use a closed-world assumption at deployment time. For such Java applications, GraalVM Native Image offers fast startup and stable performance. GraalVM Native Image uses a novel iterative application of points-to analysis and heap snapshotting, followed by ahead-of-time compilation with an optimizing compiler. Initialization code can run at build time, i.e., executables can be tailored to a particular application configuration. Execution at run time starts with a pre-populated heap, leveraging copy-on-write memory sharing. We show that this approach improves the startup performance by up to two orders of magnitude compared to the Java HotSpot VM, while preserving peak performance. This allows Java applications to have a better startup performance than Go applications and the V8 JavaScript VM.
September 2017
·
99 Reads
·
5 Citations
While Java is a statically-typed language, some of its features make it behave like a dynamically-typed language at run time. This includes Java's boxing of primitive values as well as generics, which rely on type erasure. This paper investigates how runtime technology for dynamically-typed languages such as JavaScript and Python can be used for Java bytecode. Using optimistic optimizations, we specialize bytecode instructions that access references in such a way, that they can handle primitive data directly and also specialize data structures in order to avoid boxing for primitive types. Our evaluation shows that these optimizations can be successfully applied to a statically-typed language such as Java and can also improve performance significantly. With this approach, we get an efficient implementation of Java's generics, avoid changes to the Java language, and maintain backwards compatibility, allowing existing code to benefit from our optimization transparently.
Citations (61)
... It is present as a strategy to improve code quality and consequently optimize the Code Review process [7,8,9]. It is part of steps of modern compilers such as GraalVM [10], being necessary for the generation of optimized native code. It is present in popular tools like Github, which stores hundreds of millions of source code repositories and receives more than 1,000 pushes per minute, from more than 65 million developers. ...
- Citing Conference Paper
October 2021
... Truffle [39,85,88] is a language implementation framework that enables guestlanguage integration via AST interpretation. At run time, the guest-language ASTs are partially evaluated and optimized based on profiling information accumulated during interpretation [42,50,87,89] and are subsequently compiled using the GraalVM Compiler. Truffle furthermore provides a standardized object storage model [86] that can be used across all language implementations. ...
- Citing Conference Paper
October 2021
... Since then, multiple optimization methods were introduced, attempting to reduce the negative performance effect of object-orientation, including inline caching [13], object specialization [2,36], object inlining [6,14,15,39], devirtualization [23], semantic inlining [41], method specialization [33], object combining [37], object fusing [40], elimination of lambdas [28], and value fields inlining [5]. However, even though some of these optimizations were implemented in HotSpot [30], Java object methods are still slower than static methods, as it was demonstrated in Section 2. It is possible that they will never be equally fast due to fundamental differences between object-oriented and procedural programming paradigms [21]. ...
- Citing Conference Paper
June 2021
... GraalVM [53,54,77] is a virtual machine and compiler infrastructure providing a shared platform for language implementations. It allows for dynamic optimizations where nodes in an AST structure may rewrite themselves during interpretation, alongside speculative optimization and deoptimization [78]. ...
- Citing Article
January 2013
ACM SIGPLAN Notices
... GraalVM is a high-performance JDK distribution that makes it possible to build and run applications implemented in a wide range of high-level languages (e.g., Java, Scala, JavaScript, Clojure, Kotlin, etc.). Montsalvat leverages a GraalVM tool named Native Image supporting ahead-of-time (AoT) compilation of applications into native executables, called native images [18,35,57], which do not require a JVM at runtime. GraalVM native-image AoT compiles only reachable application methods, classes and fields, thereby excluding any redundant application logic from the final executable. ...
- Citing Conference Paper
February 2020
... Specifically, there is a surge in the popularity of ahead-of-time (AOT) compilation. GraalVM [9] introduced a component: Native Image [10], which is a compiler for Java bytecode that uses a combination of points-to analysis, AOT compilation, and class initialization at build time to create self-contained binaries which start quickly and execute with a lower memory footprint compared to running on the Java Virtual Machine (JVM). These capabilities make it a perfect prospective for cloud environments. ...
- Citing Article
- Full-text available
October 2019
Proceedings of the ACM on Programming Languages
... Partial evaluators have been developed for numerous languages [Alpuente et al. 1998;Andersen 1992;Elphick et al. 2003;Komorowski 1982;Lloyd and Shepherdson 1991;Meyer 1991] and for different domains [Berlin 1990;Berlin and Weise 1990;Futamura 1971]. The purpose of partial evaluation is to specialize code based on values known at partial-evaluation time in order to do less work at execution time, hopefully improving performance [Jones 1996;Würthinger et al. 2017]. Partial evaluation can be broken into online and offline techniques with [Jones 1996] explaining the differences the best. ...
- Citing Article
- Full-text available
June 2017
ACM SIGPLAN Notices
... Specifically, our evaluation with a set of wellknown benchmarks shows significant reductions by up to 9x in program warm-up given that OSR is applicable. Note that our approach can be used by other Truffle bytecodebased implementations lacking high-level loop information, including GraalSqueak [19], Truffle Java [11] and Truffle CIL. Furthermore, it is applicable in any compiler with a background system which provides means for establishing mappings between extracted control flow. ...
- Citing Conference Paper
September 2017
... In the last decades, little progress has been made improving the encoding of floats, with most implementations either using boxed floats or suffering from the overhead of NaN-tagging on pointers. Thus, more general strategies that use data flow analysis [14,22,27,31] and partial evaluation [35] have been developed to find locations where the type of a value is known across its lifecycle. This allows the generation of specialized code that safely handles fully unboxed, untagged values. ...
Reference:
Float Self-Tagging
- Citing Conference Paper
- Full-text available
June 2017
... If the dynamic typecheck fails, the code is either deoptimized, or the execution gets continued in baseline compiled code, which does not inline equals, but is less efficient [55]. ...
- Citing Conference Paper
February 2017