Research
Making compilers
do more.
An optimization can improve the code a compiler produces while increasing compilation time or code size. My research studies how to choose and implement transformations with those trade-offs in view.
The papers below connect transformation design with cost models and evaluation. They cover code duplication and loop unrolling, reuse of work during partial evaluation, and benchmarking of modern JVM workloads.
Questions behind the work
- When is duplication worthwhile?
- Duplicating code can expose optimizations while making a program larger. DBDS simulates the optimizations a duplication would enable; fast-path loop unrolling applies this idea to loops with multiple exits.
- What can a compiler reuse?
- Repeated compilation need not repeat every step. Partial-evaluation templates reuse pre-compiled graphs for recurring patterns and are evaluated in Graal and GraalWasm.
- What do benchmarks reveal?
- Compiler results depend on the workloads used to measure them. Renaissance brings modern concurrent JVM applications into that evaluation, alongside work on compiler cost models and compilation behaviour.
Selected research
Paper 2026
Partial-Evaluation Templates: Accelerating Partial Evaluation with Pre-compiled Templates
Summary
Reusable compiler graphs capture work that a bytecode interpreter would otherwise repeat during partial evaluation. Integrated into GraalVM and GraalWasm, the templates specialize to static inputs, reducing compilation work and warmup time while preserving peak performance in the reported evaluation.
Paper 2019
Renaissance: Benchmarking Suite for Parallel Applications on the JVM
Summary
Renaissance supplies JVM workloads built around modern concurrency and parallel programming. The paper compares Graal and HotSpot C2 and uses the suite to identify and evaluate compiler optimizations whose effects were less visible in established benchmarks.
Paper 2018
Dominance-Based Duplication Simulation (DBDS): Code Duplication to Enable Compiler Optimizations
Summary
Code duplication can expose optimizations across control-flow merges, but it also increases code size and compilation cost. DBDS simulates candidate duplications before applying them, allowing a cost model to weigh the expected optimization benefits against those costs. The approach is implemented and evaluated in GraalVM.
Paper 2018
Fast-Path Loop Unrolling of Non-Counted Loops to Enable Subsequent Compiler Optimizations
Summary
Unrolling a loop with an unknown iteration count is useful when it enables further optimization. This work simulates candidate transformations and separates hot paths from slower paths to guide that choice. Its GraalVM evaluation examines execution performance alongside code-size and compilation-time costs.