Publications

Here you can find all publications related to GraalVM. If you are doing research related to GraalVM and want us to include your publication, please send us a pull request to add your paper.

Selected Papers

We recommend the following papers as a starting point for learning about Graal:

Language implementations on GraalVM are based on the Truffle framework. User applications are transformed to an abstract syntax tree, which is then partially evaluated. If you want to learn more about how to build Truffle languages, how partial evaluation works, and how the Truffle framework allows you to guide the GraalVM compiler, we recommend reading:

Thomas Würthinger, Christian Wimmer, Christian Humer, Andreas Wöß, Lukas Stadler, Chris Seaton, Gilles Duboscq, Doug Simon, Matthias Grimmer Practical partial evaluation for high-performance dynamic language runtimes In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017)

Truffle language implementations abstract the differences between programming languages, which enables efficient cross-language interoperability. We recommend reading:

Matthias Grimmer, Chris Seaton, Roland Schatz, Würthinger, Hanspeter Mössenböck High-Performance Cross-Language Interoperability in a Multi-Language Runtime In Proceedings of the 11th Dynamic Language Symposium (DLS)

The GraalVM compiler ensures that the languages on top of the GraalVM run at full speed. The core of the compiler is its intermediate representation. We recommend reading:

Gilles Duboscq, Thomas Würthinger, Lukas Stadler, Christian Wimmer, Doug Simon, Hanspeter Mössenböck An intermediate representation for speculative optimizations in a dynamic compiler In Proceedings of the 7th ACM workshop on Virtual machines and intermediate languages (VMIL ‘13)

Speculative assumptions based on profiling information and deoptimizations allow GraalVM heavily optimize dynamically typed languages like JavaScript and ensure native speed. We recommend reading:

Gilles Duboscq, Thomas Würthinger, Hanspeter Mössenböck Speculation without regret: reducing deoptimization meta-data in the Graal compiler In Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java platform: Virtual machines, Languages, and Tools (PPPJ ‘14)

A powerful escape analysis with scalar replacement ensures that all interpreter data structures are removed when optimizing a Truffle AST. We recommend reading:

Lukas Stadler, Thomas Würthinger, Hanspeter Mössenböck Partial Escape Analysis and Scalar Replacement for Java In Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization (CGO ‘14)

Full List of Papers

2019

• Aleksandar Prokopec, Gilles Duboscq, David Leopoldseder, Thomas Wuerthinger An Optimization-Driven Incremental Inline Substitution Algorithm for Just-In-Time Compilers In Proceedings of the 2019 International Symposium on Code Generation and Optimization (CGO 2019)

• Aleksandar Prokopec, Andrea Rosà, David Leopoldseder, Gilles Duboscq, Petr Tůma, Martin Studener, Lubomír Bulej, Yudi Zheng, Alex Villazón, Doug Simon, Thomas Würthinger, Walter Binder Renaissance: benchmarking suite for parallel applications on the JVM In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2019)

2018

• David Leopoldseder, Lukas Stadler, Manuel Rigger, Thomas Würthinger, Hanspeter Mössenböck A Cost Model for a Graph-Based Intermediate-Representation in a Dynamic Compiler In Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages

• Kevin Menard, Chris Seaton, Benoit Daloze Specializing Ropes for Ruby In Proceedings of the 15th International Conference on Managed Languages & Runtimes (ManLang’18)

• B. Daloze, A. Tal, S. Marr, H. Mössenböck, E. Petrank Parallelization of Dynamic Languages: Synchronizing Built-in Collections In Proceedings of the Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2018)

• David Leopoldseder, Roland Schatz, Lukas Stadler, Manuel Rigger, Thomas Wuerthinger, Hanspeter Moessenboeck Fast-Path Loop Unrolling of Non-Counted Loops to Enable Subsequent Compiler Optimizations In Proceedings of the 15th International Conference on Managed Languages & Runtimes, Article No. 2 (ManLang’18)

• David Leopoldseder, Lukas Stadler, Thomas Würthinger, Josef Eisl, Doug Simon, Hanspeter Mössenböck Dominance-based duplication simulation (DBDS): code duplication to enable compiler optimizations In Proceedings of the 2018 International Symposium on Code Generation and Optimization (CGO 2018)

• Matthias Grimmer, Roland Schatz, Chris Seaton, Thomas Wuerthinger, Mikel Lujan Cross-Language Interoperability in a Multi-Language Runtime In ACM Transactions on Programming Languages and Systems (TOPLAS), Vol. 40, No. 2, 2018

• Manuel Rigger, Roland Schatz, Jacob Kreindl, Christian Haeubl, Hanspeter Moessenboeck Sulong, and Thanks for All the Fish MoreVMs Workshop on Modern Language Runtimes, Ecosystems, and VMs (MoreVMs 2018)

• Michael Van De Vanter, Chris Seaton, Michael Haupt, Christian Humer, Thomas Würthinger Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools In The Art, Science, and Engineering of Programming, Vol. 2, No. 3, 2018, article 14

2017

• Thomas Würthinger, Christian Wimmer, Christian Humer, Andreas Wöß, Lukas Stadler, Chris Seaton, Gilles Duboscq, Doug Simon, Matthias Grimmer Practical partial evaluation for high-performance dynamic language runtimes In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017)

• Aleksandar Prokopec, David Leopoldseder, Gilles Duboscq, Thomas Würthinger Making collection operations optimal with aggressive JIT compilation In Proceedings of the 8th ACM SIGPLAN International Symposium on Scala (Scala 2017)

• Michael Van De Vanter Building Flexible, Low-Overhead Tooling Support into a High-Performance Polyglot VM (Extended Abstract) MoreVMs Workshop on Modern Language Runtimes, Ecosystems, and VMs

2016

• Benoit Daloze, Stefan Marr, Daniele Bonetta, Hanspeter Mössenböck Efficient and Thread-Safe Objects for Dynamically-Typed Languages Accepted for the Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications 2016 (OOPSLA)

• Manuel Rigger, Matthias Grimmer, Hanspeter Mössenböck Sulong – Execution of LLVM-Based Languages on the JVM In Proceedings of International Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS)

• Josef Eisl, Matthias Grimmer, Doug Simon, Thomas Würthinger, Hanspeter Mössenböck Trace-based Register Allocation in a JIT Compiler In Proceedings of the 13th International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools (PPPJ ‘16)

• Stefan Marr, Benoit Daloze, Hanspeter Mössenböck Cross-language compiler benchmarking: are we fast yet? In Proceedings of the 12th Symposium on Dynamic Languages (DLS 2016)

• Manuel Rigger, Matthias Grimmer, Christian Wimmer, Thomas Würthinger, Hanspeter Mössenböck Bringing low-level languages to the JVM: efficient execution of LLVM IR on Truffle In Proceedings of the 8th International Workshop on Virtual Machines and Intermediate Languages (VMIL 2016)

• Manuel Rigger Sulong: Memory Safe and Efficient Execution of LLVM-Based Languages In Proceedings of the ECOOP 2016 Doctoral Symposium

• Luca Salucci, Daniele Bonetta, Walter Binder Efficient Embedding of Dynamic Languages in Big-Data Analytics In Proceedings of the International Conference on Distributed Computing Systems Workshops (ICDCSW 2016)

• Lukas Stadler, Adam Welc, Christian Humer, Mick Jordan Optimizing R language execution via aggressive speculation In Proceedings of the 12th Symposium on Dynamic Languages (DLS 2016)

• Daniele Bonetta, Luca Salucci, Stefan Marr, Walter Binder GEMs: shared-memory parallel programming for Node.js In Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2016)

• Luca Salucci, Daniele Bonetta, Walter Binder Lightweight Multi-language Bindings for Apache Spark In Proceedings of the European Conference on Parallel Processing (Euro-Par 2016)

• Luca Salucci, Daniele Bonetta, Stefan Marr, Walter Binder Generic messages: capability-based shared memory parallelism for event-loop systems In Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP 2016)

• Stefan Marr, Chris Seaton, Stéphane Ducasse Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2016)

2015

• Matthias Grimmer, Chris Seaton, Thomas Würthinger, Hanspeter Mössenböck Dynamically Composing Languages in a Modular Way: Supporting C Extensions for Dynamic Languages. In Proceedings of the 14th International Conference on Modularity

• Michael Van De Vanter Building Debuggers and Other Tools: We Can “Have it All” (Position Paper) In Proceedings of the 10th Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems Workshop (ICOOOLPS)

• Josef Eisl Trace register allocation In Companion Proceedings of the 2015 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH Companion 2015)

• Matthias Grimmer, Chris Seaton, Roland Schatz, Thomas Würthinger, Hanspeter Mössenböck High-performance cross-language interoperability in a multi-language runtime In Proceedings of the 11th Symposium on Dynamic Languages (DLS 2015)

• Matthias Grimmer, Roland Schatz, Chris Seaton, Thomas Würthinger, Hanspeter Mössenböck Memory-safe Execution of C on a Java VM In Proceedings of the 10th ACM Workshop on Programming Languages and Analysis for Security (PLAS’15)

• Matthias Grimmer, Chris Seaton, Thomas Würthinger, Hanspeter Mössenböck Dynamically composing languages in a modular way: supporting C extensions for dynamic languages In Proceedings of the 14th International Conference on Modularity (MODULARITY 2015)

• Doug Simon, Christian Wimmer, Bernhard Urban, Gilles Duboscq, Lukas Stadler, Thomas Würthinger Snippets: Taking the High Road to a Low Level ACM Transactions on Architecture and Code Optimization (TACO)

• David Leopoldseder, Lukas Stadler, Christian Wimmer, Hanspeter Mössenböck Java-to-JavaScript translation via structured control flow reconstruction of compiler IR In Proceedings of the 11th Symposium on Dynamic Languages (DLS 2015)

• Codruţ Stancu, Christian Wimmer, Stefan Brunthaler, Per Larsen, Michael Franz Safe and efficient hybrid memory management for Java In Proceedings of the 2015 International Symposium on Memory Management (ISMM’15)

• Gülfem Savrun-Yeniçeri, Michael L. Van de Vanter, Per Larsen, Stefan Brunthaler, Michael Franz An Efficient and Generic Event-based Profiler Framework for Dynamic Languages In Proceedings of the Principles and Practices of Programming on The Java Platform (PPPJ’15)

• Michael L. Van De Vanter Building debuggers and other tools: we can “have it all” In Proceedings of the 10th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS’15)

• Benoit Daloze, Chris Seaton, Daniele Bonetta, Hanspeter Mössenböck Techniques and applications for guest-language safepoints In Proceedings of the 10th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS’15)

2014

• Matthias Grimmer High-performance language interoperability in multi-language runtimes In Proceedings of the companion publication of the 2014 ACM SIGPLAN conference on Systems, Programming, and Applications: Software for Humanity (SPLASH Companion)

• Matthias Grimmer, Manuel Rigger, Roland Schatz, Lukas Stadler, Hanspeter Mössenböck Truffle C: Dynamic Execution of C on the Java Virtual Machine In Proceedings of the International Conference on Principles and Practice of Programming in Java (PPPJ)

• Matthias Grimmer, Thomas Würthinger, Andreas Wöß, Hanspeter Mössenböck An Efficient Approach to Access Native Binary Data from JavaScript In Proceedings of the 9th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS)

• Wei Zhang, Per Larsen, Stefan Brunthaler, Michael Franz Accelerating iterators in optimizing AST interpreters In Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications (OOPSLA’14)

• Matthias Grimmer, Manuel Rigger, Roland Schatz, Lukas Stadler, Hanspeter Mössenböck TruffleC: dynamic execution of C on a Java virtual machine In Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java platform: Virtual machines, Languages, and Tools (PPPJ’14)

• Matthias Grimmer, Thomas Würthinger, Andreas Wöß, Hanspeter Mössenböck An efficient approach for accessing C data structures from JavaScript In Proceedings of the 9th International Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems PLE (ICOOOLPS’14)

• Christian Humer, Christian Wimmer, Christian Wirth, Andreas Wöß, Thomas Würthinger A domain-specific language for building self-optimizing AST interpreters In Proceedings of the 2014 International Conference on Generative Programming: Concepts and Experiences (GPCE 2014)

• Gilles Duboscq, Thomas Würthinger, Hanspeter Mössenböck Speculation without regret: reducing deoptimization meta-data in the Graal compiler In Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java platform: Virtual machines, Languages, and Tools (PPPJ’14)

• Thomas Würthinger Graal and truffle: modularity and separation of concerns as cornerstones for building a multipurpose runtime In Proceedings of the companion publication of the 13th international conference on Modularity (MODULARITY’14)

• Lukas Stadler, Thomas Würthinger, Hanspeter Mössenböck Partial Escape Analysis and Scalar Replacement for Java In Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization (CGO’14)

• Christian Häubl, Christian Wimmer, Hanspeter Mössenböck Trace transitioning and exception handling in a trace-based JIT compiler for java ACM Transactions on Architecture and Code Optimization (TACO)

• Chris Seaton, Michael L. Van De Vanter, Michael Haupt Debugging at Full Speed In Proceedings of the Workshop on Dynamic Languages and Applications (Dyla’14)

• Andreas Wöß, Christian Wirth, Daniele Bonetta, Chris Seaton, Christian Humer, Hanspeter Mössenböck An object storage model for the truffle language implementation framework In Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java platform: Virtual machines, Languages, and Tools (PPPJ’14)

• Codruţ Stancu, Christian Wimmer, Stefan Brunthaler, Per Larsen, Michael Franz Comparing points-to static analysis with runtime recorded profiling data In Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java platform: Virtual machines, Languages, and Tools (PPPJ’14)

2013

• Thomas Würthinger, Christian Wimmer, Andreas Wöß, Lukas Stadler, Gilles Duboscq, Christian Humer, Gregor Richards, Doug Simon, Mario Wolczko One VM to Rule Them All In Proceedings of the 2013 ACM international symposium on New ideas, new paradigms, and reflections on programming & software (Onward! 2013)

• Matthias Grimmer, Manuel Rigger, Lukas Stadler, Roland Schatz, Hanspeter Mössenböck An efficient native function interface for Java In Proceedings of the International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools (PPPJ)

• Matthias Grimmer Runtime Environment for the Truffle/C VM Master’s thesis, Johannes Kepler University Linz, November 2013

• Gilles Duboscq, Thomas Würthinger, Lukas Stadler, Christian Wimmer, Doug Simon, Hanspeter Mössenböck An intermediate representation for speculative optimizations in a dynamic compiler In Proceedings of the 7th ACM workshop on Virtual machines and intermediate languages (VMIL’13)

• Lukas Stadler, Gilles Duboscq, Hanspeter Mössenböck, Thomas Würthinger, Doug Simon An experimental study of the influence of dynamic compiler optimizations on Scala performance In Proceedings of the 4th Workshop on Scala (SCALA ‘13)

• Gilles Duboscq, Lukas Stadler, Thomas Würthinger, Doug Simon, Christian Wimmer, Hanspeter Mössenböck Graal IR: An Extensible Declarative Intermediate Representation In Proceedings of the Asia-Pacific Programming Languages and Compilers Workshop, 2013

• Christian Häubl, Christian Wimmer, Hanspeter Mössenböck Context-sensitive trace inlining for Java Special issue on the Programming Languages track at the 27th ACM Symposium on Applied Computing Computer Languages, Systems & Structures

• Christian Wimmer, Stefan Brunthaler ZipPy on truffle: a fast and simple implementation of python In Proceedings of the 2013 companion publication for conference on Systems, programming, & applications: software for humanity (SPLASH’13)

• Christian Häubl, Christian Wimmer, Hanspeter Mössenböck Deriving code coverage information from profiling data recorded for a trace-based just-in-time compiler In Proceedings of the 2013 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools (PPPJ’13)

2012

• Thomas Würthinger, Andreas Wöß, Lukas Stadler, Gilles Duboscq, Doug Simon, Christian Wimmer Self-optimizing AST interpreters In Proceedings of the 8th symposium on Dynamic languages (DLS’12)

• Christian Wimmer, Thomas Würthinger Truffle: a self-optimizing runtime system In Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity (SPLASH’12)

• Lukas Stadler, Gilles , Hanspeter Mössenböck, Thomas Würthinger Compilation queuing and graph caching for dynamic compilers In Proceedings of the 6th ACM workshop on Virtual machines and intermediate languages (VMIL’12’)

• Christian Häubl, Christian Wimmer, Hanspeter Mössenböck Evaluation of trace inlining heuristics for Java In Proceedings of the 27th Annual ACM Symposium on Applied Computing (SAC’12)

If you are interested in deeper collaboration with us, please send us an email.