Christian Wimmer's research while affiliated with Oracle Corporation and other places

Publications (67)

Article
Full-text available
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 memor...
Conference Paper
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 Ja...
Conference Paper
Full-text available
Most high-performance dynamic language virtual machines duplicate language semantics in the interpreter, compiler, and runtime system. This violates the principle to not repeat yourself. In contrast, we define languages solely by writing an interpreter. The interpreter performs specializations, e.g., augments the interpreted program with type infor...
Article
Full-text available
Most high-performance dynamic language virtual machines duplicate language semantics in the interpreter, compiler, and runtime system. This violates the principle to not repeat yourself. In contrast, we define languages solely by writing an interpreter. The interpreter performs specializations, e.g., augments the interpreted program with type infor...
Conference Paper
A multi-tier virtual machine (VM) deoptimizes and transfers last-tier execution to the first-tier execution when a speculative optimization is invalidated. The first-tier target of deoptimization is either an interpreter or code compiled by a baseline compiler. Because such a first-tier execution uses a fixed stack frame layout, this complicates al...
Conference Paper
Full-text available
Although the Java platform has been used as a multi-language platform, most of the low-level languages (such as C, Fortran, and C++) cannot be executed efficiently on the JVM. We propose Sulong, a system that can execute LLVM-based languages on the JVM. By targeting LLVM IR, Sulong is able to execute C, Fortran, and other languages that can be comp...
Conference Paper
We present an approach to cross-compile Java bytecodes to Java-Script, building on existing Java optimizing compiler technology. Static analysis determines which Java classes and methods are reachable. These are then translated to JavaScript using a re-configured Java just-in-time compiler with a new back end that generates JavaScript instead of ma...
Article
We present an approach to cross-compile Java bytecodes to Java-Script, building on existing Java optimizing compiler technology. Static analysis determines which Java classes and methods are reachable. These are then translated to JavaScript using a re-configured Java just-in-time compiler with a new back end that generates JavaScript instead of ma...
Article
Full-text available
When building a compiler for a high-level language, certain intrinsic features of the language must be expressed in terms of the resulting low-level operations. Complex features are often expressed by explicitly weaving together bits of low-level IR, a process that is tedious, error prone, difficult to read, difficult to reason about, and machine d...
Article
Java uses automatic memory management, usually implemented as a garbage-collected heap. That lifts the burden of manually allocating and deallocating memory, but it can incur significant runtime overhead and increase the memory footprint of applications. We propose a hybrid memory management scheme that utilizes region-based memory management to de...
Patent
Full-text available
A method for a compiler includes receiving, by the compiler and from an interpreter, a representation of a code section having a control path that changes the representation. The representation has profiling data, and the profiling data has a threshold. The method further includes performing, by the compiler and based on the threshold, a partial ev...
Article
We present an empirical study that sheds new light on static analysis results precision by comparing them with runtime collected data. Our motivation is finding additional sources of information that can guide static analysis for increased application performance. This is the first step in formulating an adaptive approach to static analysis that us...
Article
Full-text available
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...
Article
Trace-based Just-In-Time (JIT) compilation generates machine code for frequently executed paths (so-called traces) instead of whole methods. While this has several advantages, it complicates invocation of compiled traces as well as exception handling, so that previous trace-based compilers limited the way in which traces could be invoked. We presen...
Article
Full-text available
Method inlining is one of the most important optimizations in method-based just-in-time (JIT) compilers. It widens the compilation scope and therefore allows optimizing multiple methods as a whole, which increases the performance. However, if method inlining is used too frequently, the compilation time increases and too much machine code is generat...
Conference Paper
Full-text available
Building high-performance virtual machines is a complex and expensive undertaking; many popular languages still have low-performance implementations. We describe a new approach to virtual machine (VM) construction that amortizes much of the effort in initial construction by allowing new languages to be implemented with modest additional effort. The...
Conference Paper
Full-text available
We present a compiler intermediate representation (IR) that allows dynamic speculative optimizations for high-level languages. The IR is graph-based and contains nodes fixed to control flow as well as floating nodes. Side-effecting nodes include a framestate that maps values back to the original program. Guard nodes dynamically check assumptions an...
Conference Paper
Building high-performance virtual machines is a complex and expensive undertaking; many popular languages still have low-performance implementations. We present a new approach to virtual machine (VM) construction that amortizes much of the effort in initial construction by allowing new languages to be implemented with modest additional effort. The...
Conference Paper
Full-text available
Code coverage information is typically recorded by adding instrumentation to an application before or during execution. However, this has the disadvantage that the instrumentation decreases the performance. A high-performance virtual machine (VM), such as Oracle's Java HotSpot VM, is already designed to record profiling data for the executed applic...
Article
Dynamic code evolution is a technique to update a program while it is running. In an object-oriented language such as Java, this can be seen as replacing a set of classes by new versions. We modified an existing high-performance virtual machine to allow arbitrary changes to the definition of loaded classes. Besides adding and deleting fields and me...
Conference Paper
Full-text available
We present an intermediate representation (IR) for a Java just in time (JIT) compiler written in Java. It is a graph-based IR that models both control-flow and data-flow dependencies between nodes. We show the framework in which we developed our IR. Much care has been taken to allow the programmer to focus on compiler optimization rather than IR bo...
Conference Paper
Method inlining is considered to be one of the most important optimizations in a compiler. However, a poor inlining heuristic can lead to significant degradation of a program's running time. Therefore, it is important that an inliner has an effective heuristic that controls whether a method is inlined or not. An important component of any inlining...
Article
syntax tree (AST) interpreter is a simple and natural way to implement a programming language. However, it is also considered the slowest approach because of the high overhead of virtual method dispatch. Language implementers therefore define bytecodes to speed up interpretation, at the cost of introducing inflexible and hard to maintain bytecode f...
Conference Paper
A highly productive platform accelerates the production of research results. The design of a virtual machine (VM) written in the Java programming language can be simplified through exploitation of interfaces, type and memory safety, automated memory management (garbage collection), exception handling, and reflection. Moreover, modern Java IDEs offe...
Conference Paper
An abstract syntax tree (AST) interpreter is a simple and natural way to implement a programming language. However, it is also considered the slowest approach because of the high overhead of virtual method dispatch. Language implementers therefore define bytecodes to speed up interpretation, at the cost of introducing inflexible and hard to maintai...
Conference Paper
We present Truffle, a novel framework for implementing managed languages in Java™. The language implementer writes an AST interpreter, which is integrated in our framework that allows tree rewriting during AST interpretation. Tree rewrites incorporate type feedback and other profiling information into the tree, thus specializing the tree and augmen...
Article
The number and complexity of software attacks is increasing. This growth necessitates proper defense mechanisms. Intrusion detection systems have an im- portant role in detecting and disrupting attacks before they can compromise software. Multi-variant execution is a technique that runs multiple variants or versions of a program and looks for diver...
Article
Method inlining is one of the most important optimizations in method-based just-in-time (JIT) compilers. It widens the compilation scope and therefore allows optimizing multiple methods as a whole, which increases the performance. However, if method inlining is used too frequently, the compilation time increases and too much machine code is generat...
Article
Modularity is a key concept for large and complex applications and an important enabler for collaborative research. In comparison, virtual machines (VMs) are still mostly monolithic pieces of software. Our goal is to significantly reduce to the cost of extending VMs to efficiently host and execute multiple, dynamic languages. We are designing and i...
Article
platform-independent bytecodes that are then executed by a virtual machine (we base this paper on Java, but the idea can be easily applied to other current systems, especially the.NET infrastructure). The structure of the bytecode format is largely inspired by the structure of Java source code. Both share basically the same method structure. Howeve...
Conference Paper
Since their inception, the usage pattern of web browsers has changed substantially. Rather than sequentially navigating static web sites, modern web browsers often manage a large number of simultaneous tabs displaying dynamic web content, each of which might be running a substantial amount of client-side JavaScript code. This environment introduced...
Article
Embedded systems provide limited storage capacity. This limitation conflicts with the demands of modern virtual machine platforms, which require large amounts of library code to be present on each client device. These conflicting requirements are often ...
Article
Optionally typed languages enable direct performance comparisons between untyped and type annotated source code. We present a comprehensive performance evaluation of two different JIT compilers in the context of ActionScript, a production-quality optionally typed language. One JIT compiler is optimized for quick compilation rather than JIT compiled...
Conference Paper
Dynamic updates to running programs improve development productivity and reduce downtime of long-running applications. This feature is however severely limited in current virtual machines for object-oriented languages. In particular, changes to classes often apply only to methods invoked after a class change, but not to active methods on the call s...
Article
The number and complexity of attacks on computer systems are increasing. This growth necessitates proper defense mechanisms. Intrusion detection systems play an important role in detecting and disrupting attacks before they can compromise software. Multivariant execution is an intrusion detection mechanism that executes several slightly different v...
Chapter
Present approaches to software security are to a large extent reactive: when vulnerabilities are discovered, developers scramble to fix the underlying error. The advantage is on the side of the attackers because they only have to find a single vulnerability to exploit all vulnerable systems, while defenders have to prevent the exploitation of all v...
Article
In several Java VMs, strings consist of two separate objects: metadata such as the string length are stored in the actual string object, while the string characters are stored in a character array. This separation causes an unnecessary overhead. Each string method must access both objects, which leads to a bad cache behavior and reduces the executi...
Article
Object fusing is an optimization that embeds certain referenced objects into their referencing object. The order of objects on the heap is changed in such a way that objects that are accessed together are placed next to each other in memory. Their offset is then fixed, that is, the objects are colocated, allowing field loads to be replaced by addre...
Article
Full-text available
Object fusing is an optimization that embeds certain referenced objects into their referencing object. The order of objects on the heap is changed in such a way that objects that are accessed together are placed next to each other in memory. Their offset is then fixed, that is, the objects are colocated, allowing field loads to be replaced by addre...
Conference Paper
Full-text available
Coroutines are non-preemptive lightweight processes. Their advantage over threads is that they do not have to be synchronized because they pass control to each other explicitly and deterministically. Coroutines are therefore an elegant and efficient implementation construct for numerous algorithmic problems. Many mainstream languages and runtime en...
Conference Paper
The linear scan algorithm for register allocation provides a good register assignment with a low compilation overhead and is thus frequently used for just-in-time compilers. Although most of these compilers use static single assignment (SSA) form, the algorithm has not yet been applied on SSA form, i.e., SSA form is usually deconstructed before reg...
Conference Paper
Full-text available
Dynamic code evolution is a technique to update a program while it is running. In an object-oriented language such as Java, this can be seen as replacing a set of classes by new versions. We modified an existing high-performance virtual machine to allow arbitrary changes to the definition of loaded classes. Besides adding and deleting fields and me...
Conference Paper
Trace-based compilation is a technique used in managed language runtimes to detect and compile frequently executed program paths. The goal is to reduce compilation time and improve code quality by only considering "hot" parts of methods for compilation. Trace compilation is well suited for interpreter-based execution environments because the contro...
Article
Software vulnerabilities continue to be a major threat. Although significant advances have been made to reduce such vulnerabilities, there are still vulnerabilities that have eluded these techniques, and unfortunately the attackers have also become more sophisticated, employing more devious methods. Moreover, a huge amount of new code is written ev...
Article
Multi-variant program execution is an application of n-version programming, in which several slightly different instances of the same program are executed in lockstep on a multiproces-sor. These variants are created in such a way that they be-have identically under "normal" operation and diverge when "out of specification" events occur, which may b...
Article
A large array of privacy sensitive applications like banking servers, medical records processors, and legal software are Java applications. Preserving user privacy is a necessary feature in such applications. For example, in a medical records system, only the authorized doctors and medical staff should be allowed access to patient information. Dece...
Conference Paper
Creating an interpreter is a simple and fast way to implement a dynamic programming language. With this ease also come major drawbacks. Interpreters are significantly slower than compiled machine code because they have a high dispatch overhead and cannot perform optimizations. To overcome these limitations, interpreters are commonly combined with j...
Article
Whenever an array element is accessed, Java virtual machines execute a compare instruction to ensure that the index value is within the valid bounds. This reduces the execution speed of Java programs. Array bounds check elimination identifies situations in which such checks are redundant and can be removed. We present an array bounds check eliminat...
Conference Paper
Full-text available
Continuations, or 'the rest of the computation', are a con- cept that is most often used in the context of functional and dynamic programming languages. Implementations of such languages that work on top of the Java virtual ma- chine (JVM) have traditionally been complicated by the lack of continuations because they must be simulated. We propose an...
Conference Paper
Full-text available
The usage of cellular phones, PDAs, and other mobile de- vices has increased dramatically over the past ten years. Java is targeted to be one of the most popular execution environments on such systems. However, since mobile de- vices are inherently limited in terms of local storage capac- ity and Java requires large amounts of library code to be pr...
Conference Paper
Dynamic compilers can optimize application code specifi- cally for observed code behavior. Such behavior does not have to be stable across the entire program execution to be beneficial for optimizations, it must only be stable for a certain program phase. To specialize code for a program phase, it is necessary to detect when the execution behavior...
Conference Paper
Full-text available
Today's web applications are pushing the limits of modern web browsers. The emergence of the browser as the platform of choice for rich client-side applications has shifted the use of in-browser JavaScript from small scripting programs to large computationally intensive application logic. For many web applications, JavaScript performance has become...
Article
Full-text available
Version 6 of Sun Microsystems' Java HotSpot™ VM ships with a redesigned version of the client just-in-time compiler that includes several research results of the last years. The client compiler is at the heart of the VM configuration used by default for interactive desktop applications. For such applications, low startup and pause times are more im...
Conference Paper
Full-text available
The analysis of a compiler’s intermediate data structures helps at debugging complex optimizations. We present a graphical tool for analyzing the program dependence graph of Sun Microsystems’ Java HotSpotTM server compiler. The tool saves snapshots of the graph during the compilation. It displays the graphs and provides filtering mechanisms based o...
Conference Paper
Full-text available
In several Java VMs, strings consist of two separate objects: metadata like the string length are stored in the actual string object, while the string characters are stored in a charac- ter array. This separation causes an unnecessary overhead. Each string method must access both objects, which leads to a bad cache behavior and reduces the executio...
Article
Array inlining expands the concepts of object inlining to arrays. Groups of objects and arrays that reference each other are placed consecutively in memory so that their relative offsets are fixed, i.e. they are colocated. This allows memory loads to be replaced by address arithmetic, which reduces the costs of field and array accesses. We implemen...
Conference Paper
Full-text available
Object inlining is an optimization that embeds certain referenced objects into their referencing object. It reduces the costs of field accesses by eliminating unnecessary field loads. The order of objects in the heap is changed in such a way that objects that are accessed together are placed next to each other in memory so that their offset is fixe...
Conference Paper
Full-text available
Whenever an array element is accessed, Java virtual machines execute a compare instruction to ensure that the index value is within the valid bounds. This reduces the execution speed of Java programs. Array bounds check elimination identifies situations in which such checks are redundant and can be removed. We present an array bounds check eliminat...
Conference Paper
Full-text available
Object colocation is an optimization that reduces memory access costs by grouping together heap objects so that their order in memory matches their access order in the program. We implemented this optimization for Sun Microsystems’ Java HotSpotTM VM. The garbage collector, which moves objects during collection, assigns consecutive addresses to conn...
Conference Paper
Full-text available
We present an optimized implementation of the linear scan register allocation algorithm for Sun Microsystems' Java HotSpot™ client compiler. Linear scan register allocation is especially suitable for just-in-time compilers because it is faster than the common graph-coloring approach and yields results of nearly the same quality.Our allocator improv...
Article
Trace based compilation is a technique used in managed language runtimes to detect and compile frequently executed program paths. The goal is reduced compilation time and improved code quality since only "hot" parts of methods are ever compiled. Trace compilation is well suited for interpreter based runtime environments because the control flow of...
Article
Full-text available
Today's web applications are pushing the limits of modern web browsers. The emergence of the browser as the platform of choice for rich client-side applications has shifted the use of in-browser JavaScript from small scripting programs to large computationally intensive application logic. For many web applications, JavaScript performance has become...

Citations

... Авторы [26] представили алгоритм CompGen, который сокращает время JIT-компиляции в GraalVM. Этот алгоритм основывается на идеи генерации компилятора по интерпретатору. ...
... In this paper, we experimentally implement an object graph generation system based on the proposed method using Graal/Truffle [6], [7], a language implementation framework, and GraalJS, a JavaScript interpreter implemented with the framework. The application with multiple languages is beyond the scope of this paper because we implement the system on the assumption of using GraalJS. ...
... Tai-e provides facilities to abstract them and access their origins, which eases the development of various heap abstraction techniques for pointer analysis [13,19,29,75]. ...
... • Integration of materialization frequency metrics (Section 3.2) into an existing optimization-driven incremental inlining algorithm [35] used in GraalVM Native Image, yielding a single point of accountability for inlining (Section 3.3). • A production-ready implementation in state-of-the-art optimizing compiler Graal [15,16], in ahead-of-time compilation mode on GraalVM Native Image [56]. • A comprehensive performance evaluation that consists of peak-performance, allocation-rate, code-size and compile-time analysis on DaCapo [6], Scalabench [47], and Renaissance benchmark suites [39][40][41], as well as the extensive tuning of the proposed heuristics. ...
... A language implementation framework [6], [9] is a toolchain that generates virtual machines with an efficient memory model, a high-performance garbage collector, and a fast JIT compiler. It is used to implement PyPy [9] and TruffleRuby [10], both of which show higher performance than CPython and CRuby, respectively. ...
... 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. ...
... The Truffle framework generates glue code for each AST node that dispatches to specialized methods according to the datatypes of the arguments. An AST interpreter written in the Truffle DSL is executed by a Java VM with a special just-in-time (JIT) compiler [24]. The JIT compiler inlines the execution method of a child node into the execution method of its parent node, which eliminates type-based dispatch code for the child node. ...
... 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]. ...
... Their idea is to implement an interpreter with some specific hint annotations to expand the loop of an application program. Sulong has already demonstrated the same idea [32], and it was applied for implementing Squeak/Smalltalk VM. ...
... Reconstruction of high-level control flow Leopoldseder et al. [17] described an approach to reconstruct high-level language constructs from compiler IR. They compiled Java bytecode to JavaScript by first translating it to Graal IR [6] and then reconstructing high-level constructs. ...