Managed Runtime Systems


The aim of this course is to introduce students to the world of managed runtime systems. Managed runtime systems are the ones responsible for executing managed programming languages, such as Python, Java, etc.

In this course we study how managed programming languages are implemented in the managed runtime systems. The course is mainly focused on the Java programming language and the Java Virtual Machine (JVM).


Lectures will take place every Tuesday and Thursday 10:00-12:00 at A.113, and tutorials will take place on Fridays 10:00-12:00 at A.125 according to the schedule below.

Please note that the schedule is subject to change.

Week # Tuesday Thursday Friday Assignment
05/02/2024 1 Course Intro Lecture (VMs Intro)
12/02/2024 2 Lecture (The JVM) Lecture (GC Intro)
19/02/2024 3 Lecture (JIT 1) Paper (Interpreters) <Project Proposal Deadline> Reading: (Interpreters)
26/02/2024 4 Lecture (GC Intro 2) Lecture (JIT 2)
04/03/2024 5 <no-class> Paper (Call-site patching) Reading: (Call-site patching)
11/03/2024 6 Lecture (Metacircularity and Native Compilation) Paper (Deconstructing G1) Reading: (Deconstructing G1)
18/03/2024 7 <no-class> <no-class>
25/03/2024 8 Lecture (Truffle) Paper (Maxine VM) Reading: (Maxine VM) and (GraalVM Native)
01/04/2024 9 Lecture (Advanced GC) Paper (One VM to Rule Them All) Paper (GraalVM Native) Reading: (One VM to Rule Them All)
08/04/2024 10 Lecture (Performance) <no-class>
15/04/2024 11 Lecture (Java Concurrency & Concurrency) Paper (TeraHeap) Reading: (Big Data GC) and (TeraHeap)
22/04/2024 12 Paper (Performance) Paper (Big Data GC) Paper (GC Performance Impact) Reading: (Performance) and (GC Performance Impact)
29/04/2024 - <Easter Break> <Easter Break> <Easter Break>
06/05/2024 - <Easter Break> <Easter Break> <Easter Break>
13/05/2024 13 Project Presentations Project Presentations Project Presentations

Paper assignments

  1. The structure and performance of efficient interpreters – 1337
  2. Just-In-Time Compilation on ARM—A Closer Look at Call-Site Code Consistency – 1349
  3. Deconstructing the Garbage-First garbage collector - 1322
  4. Maxine: An approachable virtual machine for, and in, java – Argyros
  5. Initialize once, start fast: application initialization at build time – 4577
  6. One VM to rule them all – 4171
  7. TeraHeap: Reducing Memory Pressure in Managed Big Data Frameworks – Guest: Jack Kolokasis
  8. A Study on Garbage Collection Algorithms for Big Data Environments – 1360
  9. Statistically Rigorous Java Performance Evaluation – 4047
  10. Myths and Realities: The Performance Impact of Garbage Collection – 4623 (tentative)

Marking Scheme

Paper Presentation 15%
Paper Abstracts 15%
Class participation 20%
Project 50%
Midterm 0%
Final exam 0%


You can contact me directly via e-mail (foivos+cs446 |at| zakkak |dot| net) or through the course's mailing list 2024 |at|

To subscribe send an email to: 2024+subscribe |at| or visit

Material / Slides

The slides of the course are available as clickable links from the syllabus.


Guest lectures

  • 2019 – I kindly thank Dr. Heinz Kabutz for sharing his deep knowledge on Java threading and demoing how the JIT compiler can make Java programs behave in a "weird" way, while not breaking the Java Memory Model.
  • 2018 – I kindly thank Dr. Christos Kotselidis for his insightful presentation regarding "The Art of Java Performance" and the exciting live demo.

Inspiration and Material

  1. I would like to thank Mario Wolczko for sharing his material and experiences from a similar course he taught at UC Berkeley.

The original material of his course can be found here.

  1. I would like to thank Aleksey Shipilёv for the creation of the "JVM Anatomy Park" that provides a set of great examples and anecdotes to toy around in tutorials.


You can either work alone or form a team of two. For your project you can either focus on JIT compilation or Garbage Collection.

You shall choose and propose a project on your own. The project proposal should answer the following questions:

  1. What do you find interesting in the project?
  2. What do you expect to learn through this project implementation?
  3. How are you going to demonstrate the success of your project?

You are strongly encouraged to work on OpenJDK or Graal VM for your project, but projects on other VMs (even non-Java VMs) will be also accepted.

Projects will be developed on github and will be based on the latest release of the corresponding VM you will chose to work on.

Project Ideas / Past projects

  • See MMTk's open student projects and this tweet
  • 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
  • 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
  • Accelerating a Java FFT implementation on a GPU with TornadoVM The source codes of the two implementations are available at and
  • MaxineVM: Parallelization of the cross-ISA tests The source code of the implementation is available at
  • 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
  • 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
  • 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

Project proposal deadline

Please submit your project proposals by 04/03/2022!

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

Reading Assignments

During this course you will be asked to read a number of scientific papers covering the topics at hand.

We will discuss each paper in the classroom to better understand them and answer any questions you might come up with. Each of you will prepare and deliver a presentation for one of those papers, while the rest will be assigned to deliver a short summary for each of the papers they do not present.

Summary format

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?

Summary Submission

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.