Managed Runtime Systems

1. Branch Prediction and the Performance of Interpreters - Don’t Trust Folklore – 4624
2. Just-In-Time Compilation on ARM—A Closer Look at Call-Site Code Consistency – 4845
3. Initialize once, start fast: application initialization at build time – 1422
4. One VM to rule them all – 4840
5. Deconstructing the Garbage-First garbage collector – 4440
6. Fray: An Efficient General-Purpose Concurrency Testing Platform for the JVM – 3730 & 4475
7. A Study on Garbage Collection Algorithms for Big Data Environments – 4468 & 4988
8. Rethinking Java Performance Analysis – 4567 & 5072
9. TeraHeap: Reducing Memory Pressure in Managed Big Data Frameworks – Jack Kolokasis
10. Distilling the Real Cost of Production Garbage Collectors – 4960

Below you can find a list of links pointing to material relevant to this course:

• Repository with links to various resources avout the OpenJDK HotSpot JVM
• Crafting Interpreters by Robert Nystrom
• Tutorials about Building/Editing OpenJDK and GraalVM
• Tutorial on configuring/using (G1)
• Which Interpreters are Faster, AST or Bytecode? by Stefan Marr
• Developers disassemble! Use Java and hsdis to see it all by Chris Newland
• Dan Heidinga's Thoughts on Managed Runtimes
• Aleksey Shipilëv's personal web site
• What lies beneath by Dmitry Vyazelenko and Maurice Naftalin (JPrime '19)
• SO: How do I write a correct micro benchmark in java

• See MMTk's open student projects and this tweet
• Better Instruction Scheduling Heuristics for the JIT-centric Cranelift Compiler Backend
• Project Proposal Generational Mark Sweep for MMTk
• Comparative Performance Analysis of Language Implementations in GraalVM vs. Stock Runtime Environments
• Extending Truffle's SimpleLanguage with Array types
• Optimizations Performed by javac Identification of the optimizations performed by javac during compilation to bytecode. The team identified and located the javac's source code responsible for the various optimizations performed by javac and provided source code examples for each optimization that javac optimized.
• Porting Maxine VM to Windows MaxineVM is not working on Windows. This project was about identifying what's needed to make MaxineVM work on Windows and implementing the missing parts. This project resulted in the following pull request on MaxineVM https://github.com/beehive-lab/Maxine-VM/pull/21
• MaxineVM: Support for Trampolines on RISC-V This project was about porting MaxineVM's implementation of trampolines for ARM processors to RISC-V. This project results in the following pull request on MaxineVM https://github.com/beehive-lab/Maxine-VM/pull/19
• Accelerating a Java FFT implementation on a GPU with TornadoVM The source codes of the two implementations are available at https://github.com/gkatev/TornadoFFT and https://gitlab.com/xvurakis/cs446
• MaxineVM: Parallelization of the cross-ISA tests The source code of the implementation is available at https://github.com/Pyrromanis/maxine
• Provide a Java API for an accelerated implementation of the Aho-Corasik algorithm The team provided the java API and evaluated against the standard pattern matching library provided by Java, and a Java implementation of Aho-Corasik.
• Add support for SGX-backed encryption in MaxineVM The team successfully substituted the corresponding OpenJDK methods to provide SGX-backed encryption transparently to the developer/application. They also evaluated their implementation against vanilla MaxineVM and OpenJDK HotSpot. The source code used to be available at https://github.com/dkarnikis/niqqer_vm/
• Testing MaxineVM with AdoptOpenJDK's test scripts This project aimed to use AdoptOpenJDK's test scripts to test MaxineVM. The team studied the scripts and the tests providing a description for each of them. They also modified the scripts to make them work with MaxineVM and provided an evaluation of MaxineVM with pass/fail results and comments.
• A survey about Managed Runtime Systems in rust The team decided to enhance or try and implement (at least partially) a Javascript VM in rust. In their efforts they studied existing VMs and tried extending them
• Hooking Maxine VM with External Disassembler MaxineVM comes with a built-in disassembler. This project aimed to hook MaxineVM with an external disassembler to make it easier to support more architectures without the need to extend the built-in disassembler.
• Evaluation of MaxineVM in comparison to HotSpot The team used the DaCapo benchmark suite to evaluate MaxineVM and compare its performance to HotSpot.
• Implementation of a Mark and Sweep Garbage Collector in a JS-like language
• Extend Java concurrent lib with more concurrent data structures and evaluate them
• Port MaxineVM to RISC-V The source code of the team's implementation is available at https://github.com/mvard/Maxine-VM
• Identifying bottlenecks on MaxineVM
• Evaluation of different Garbage Collectors
• A memory manager implementation for C++ in C++
• Evaluating the Performance of Interpreters Over Various Branch Predictors
• Getting Familiar With Maxsim, A Simulation Platform For Managed Applications
• Evaluation and comparison of Hotspot 1.7, Hotspot 1.8, MaxineVM, CACAO and JikesRVM

Please submit your project proposals by 01/03/2025!

The earlier you submit the more time we will have to discuss and fine tune your proposal.

Your summary should answer the following questions:

1. What is the key point of the paper? (If it is the survey, what are the key techniques it presents?)
2. What did you like the most in the paper?
3. What could be improved in the presentation/content of the paper?
4. Do you have any ideas on how to improve the presented idea/technique?
5. On a scale of 0-5, with 5 being the most positive, how would you rate the paper?

Please submit your summaries through email (in text or PDF format) by sending them to foivos+cs446summary |at| zakkak |dot| net. The email subject should follow the pattern [HY446] Summary: <Paper title>, e.g. [HY446] Summary: Garbage-First Garbage Collection. The summaries must be submitted before the beginning of the lecture where we will discuss the corresponding paper.