Research Projects
Trace Compilation
since 2008, with Michael Bebenita, Mason Chang, Marcelo Cintra, Karthik Manivannan, Andreas Gal, Michael Franz
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. We implement trace compilation for the Maxine VM and for other dynamic language virtual machines.
Multi Variant Execution (Orchestra)
since 2008, with Babak Salamat, Todd Jackson, Gregor Wagner, Andreas Gal, Michael Franz
Orchestra is a system that can detect at run-time when buffer-overflow and similar software vulnerabilities are exploited, enabling us to stop cyber-attacks before they can cause damage. The key idea is to generate several slightly different variants of the same software and then run these variants simultaneously and in lock-step on different cores of a multiprocessor.
Information Flow for Dynamic Languages
since 2008, with Eric Hennigan, Alex Yermolovich, Andreas Gal, Michael Franz
We seek to solve common website and browser vulnerabilities through the use of information flow techniques. Vulnerability classes including injection attacks such as XSS and SQL, confused deputy attacks such as XSRF, and covert-flow attacks such as the CSS-history leak, are all addressed within a new end-to-end security framework.
Continuations for Java
since 2008, with Lukas Stadler, Hanspeter Mössenböck
Continuations, or 'the rest of the computation', are a concept 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 machine (JVM) have traditionally been complicated by the lack of continuations because they must be simulated. We implement continuations for the Java HotSpot™ VM with a lazy or on-demand approach. It is part of the Da Vinci Machine project.
Tail Calls
2008–2009, with Arnold Schwaighofer, Hanspeter Mössenböck
Tail calls are necessary when compiling functional languages, like Scheme, to Java bytecodes. It guarantees that no stack frame is created for recursive calls and thus no stack overflow occurs. We implemented tail calls for the Java HotSpot™ VM. Tail calls are supported in the interpreter, the client compiler, and the server compiler. It is part of the Da Vinci Machine project.
Optimization of Strings
2007–2008, with Christian Häubl, Hanspeter Mössenböck
We implemented an optimization for the Java HotSpot™ VM that fuses the string object with its character array that holds the actual content. An optimized string object is significantly smaller than the old string and its character array. This eliminates field loads, reduces the memory pressure, and the time necessary for garbage collection.
Ideal Graph Visualizer
since 2006, with Thomas Würthinger, Hanspeter Mössenböck
The Java HotSpot™ server compiler uses a single intermediate representation in all compiler phases, called ideal graph. The tool saves snapshots of the graph during the compilation. It displays the graphs and provides filtering mechanisms based on customizable JavaScript code and regular expressions. Source code available from http://kenai.com/projects/igv/.
Array Bounds Check Elimination
2006–2007, with Thomas Würthinger, Hanspeter Mössenböck
We added a fast algorithm for array bounds check elimination to the Java HotSpot™ client compiler that optimizes frequently used patterns of array accesses and uses the deoptimization facilities of the Java HotSpot™ VM.
Client Compiler Visualizer
since 2005, with Thomas Würthinger, Stefan Loidl, Alexander Reder, Bernhard Stiftner, Hanspeter Mössenböck
Visualization tool for the internal data structures of the Java HotSpot™ client compiler. The tool shows the high-level and the low-level intermediate representations as well as the lifetime intervals used for register allocation. Additionally, the bytecodes of the compiled methods can be shown. Both textual and graphical views are available. Source code available from https://c1visualizer.dev.java.net.
Automatic Object Inlining
2005–2008, with Hanspeter Mössenböck
Object inlining reduces the costs of field accesses by combining referenced objects with their referencing object. The order of objects on the heap is changed by the garbage collector so that they are placed next to each other. We designed a feedback-directed optimization system for object inlining and array inlining that utilizes the just-in-time compiler and the garbage collector.
SSA Form and Linear Scan Register Allocation
2003–2006, with Hanspeter Mössenböck
We changed the high-level intermediate representation of Sun Microsystems' Java HotSpot™ client compiler to use static single assignment (SSA) form, which simplifies global optimizations. Additionally, we implemented a global register allocator that uses the linear scan algorithm. This work is part of the production version since Java 6. Source code available from http://openjdk.java.net.