Welcome to the Maxine VM project

A next generation, highly productive platform for virtual machine research.

Project Overview

In this era of modern, managed languages we demand ever more from our virtual machines: better performance, more scalability, and support for the latest new languages. Research and experimentation is essential but challenging in the context of mature, complex, production VMs written in multiple languages. The Maxine VM is a next generation platform that establishes a new standard of productivity in this area of research. It is written entirely in Java, completely compatible with modern Java IDEs and the standard JDK, features a modular architecture that permits alternate implementations of subsystems such as GC and compilation to be plugged in, and is accompanied by a dedicated development tool (the Maxine Inspector) for debugging and visualizing nearly every aspect of the VM’s runtime state.

As of the 2.0 release, September 2013, Maxine is no longer an active project at Oracle Labs. As of the 2.1 release, April 2017, Maxine VM is actively maintained and developed at the University of Manchester.

We believe that Maxine represents the state of the art in a research VM, and actively encourage community involvement. The Maxine sources, including VM, Inspector, and other supporting tools, are Open Source and are licensed under GPL version 2.0. To obtain the code please visit https://github.com/beehive-lab.

Citation

For Maxine VM >= v2.1 please cite: Christos Kotselidis, et al. Heterogeneous Managed Runtime Systems: A Computer Vision Case Study. In 13th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments (VEE), 2017.

For the original Maxine VM please cite: C. Wimmer et al, “Maxine: An approachable virtual machine for, and in, java”, In ACM TACO 2013.

Getting Started

• Download and build Maxine from source on any of the supported Platform.
• Read the technical report “Maxine: An Approachable Virtual Machine For, and In, Java”
• Send any questions to this mailing list (maxinevm@googlegroups.com).
• Read about the current status of the VM.
• Learn more about the Maxine Inspector, the companion tool for visualizing internal state and debugging the VM: video introduction, video demos, and written documentation.
• Learn more about Virtual Machine Level Analysis, an experimental extension for analysis the behavior of application (and eventually the VM).
• View publications and presentations about Maxine.
• Read the Glossary and FAQ.
• Contact us on the the mailing list (or in private) and tell us about your work.

Features

Some of the features of Maxine that make it a compelling platform for (J)VM research include:

• Nearly all of the code base is written in Java and exploits advanced language features appearing in JDK 5 and beyond: for example annotations, static imports, and generics.
• The VM integrates with openJDK. There’s no need to download (and build) other implementations of the standard Java classes.
• The source code supports development in Eclipse, Netbeans or IntelliJ all of which provide excellent support for cross-referencing and browsing the code. It also means that refactoring can be confidently employed to continuously improve the structure of the code.
• The Maxine Inspector produces visualizations of nearly every aspect of the VM runtime state, and provides advanced, VM-specific debugging.
• The source code is hosted on GitHub making downloading and collaboration easier.

Roadmap

• Implement JVMCI, Upgrade to latest Graal
• Run Truffle on top of Maxine VM/Graal
• Port MMTk to Maxine VM

Contributing to Maxine

Maxine is an open-source project, and we invite researchers and developers to make contributions in the form of bug fixes, performance enhancements, features, documentation, and so forth.

To push your code upstream use pull requests on GitHub. However, note that we are doing most development in a private git tree and we are working on a number of features which are not quite ready for public release. Therefore, we would strongly encourage you to get in touch before starting to work on anything large, to avoid duplication of effort. We can probably expedite our release of any work-in-progress (WIP) features you might be interested in, if you do that

Contributors should adopt the following process once they think their changes are ready to push:

1. Merge the latest changes from the Maxine master branch.
2. Test their code.
3. Make sure the code complies to the coding style of Maxine VM using mx checkstyle.
4. Open a new pull request where they explain their contribution and how it works in case of complex implementations.

The changes will then be reviewed and tested. In case there are no errors, the contribution will be included in the head repository. In any other case the maintainer will be asked to resolve any issues and update his code.

Reporting Bugs

If you think you have found a bug which is not in the list of Known issues, please open a new issue on GitHub. However, note that we have limited time available to investigate and fix bugs which are not affecting the workloads we are using. Therefore, if you can’t pinpoint the cause of the bug yourself, we ask that you provide as many details on how to reproduce it, and preferably provide a statically linked executable which triggers it.

Acknowledgements

This documentation is heavily based on the original wiki pages (by Oracle) that can be found here and here.

Table of Contents

• Status
  • SpecJVM2008
  • DaCapo-9.12-bach
  • Issues
• Build and Usage Instructions
  • Platform
  • Structure of the Source Code
  • Environment variables
  • Building Maxine
  • Running
  • Debugging
  • Profiling
• Developing Maxine on IDEs
  • Eclipse
  • Netbeans
  • IntelliJ
• Debugging
  • Inspector
  • Testing Maxine
  • Logging and Tracing
  • Debugging Maxine Java Tasks
  • Core dump
• The Maxine Project: Frequently Asked Questions
  • Does Maxine support the GNU classpath libraries?
  • How modular is the Maxine VM architecture?
  • What kind of GC does the Maxine VM use?
  • How much optimization does the baseline compiler do?
  • Does the Maxine VM use Green Threads?
  • Can I use my favorite debugger?
  • What kind of development environment do I need to build and run the Maxine VM?
  • How does Maxine relate to the Project Maxwell Assembler System?
  • Are there other attempts to bootstrap the Java programming language?
  • Can I suspend and resume VM execution?
  • Does the Maxine VM have an interpreter?
  • Why am I getting an error message about “hosted” being missing when trying to build an image?
  • Why was the Grip abstraction from the original VM design removed?
  • How does the Inspector process communicate with the inspected Maxine VM process?
  • What happened to the “primordial thread”?
• Glossary of Maxine terminology and concepts
  • Alias
  • Annotations
  • Boot heap
  • Bootstrap
  • Graal Compiler
  • Immortal memory
  • Injected fields
  • Maxine packages
  • Metacircular VM
  • package-info.java
  • Package.java
  • ReferenceMapInterpreter
  • Stop positions
  • T1X compiler
  • Target method
  • Trampoline
• Actors
  • Actors and their JDK counterparts
  • Flags
  • The Actor types
• JDK interoperation
  • Aliases
  • Method substitution
  • Field injection
• VM Boot Image
  • Boot image contents
  • Inspecting the boot image
  • BOOT image generation
  • Extending the boot image
  • Static Extension
  • Dynamic Extension
• Meta-circularity and memory management
• Maxine’s current Generational GC
• Maxine’s semi-space GC
• Next generation GC in Maxine
• Management of Code Dependencies
  • Overall Architecture
  • Analysing Dependencies
  • Dependencies Visitor
  • Defining a new Dependency Processor
• Code Eviction in the Maxine VM
  • Baseline Code Cache Management
  • Code Eviction Workflow
  • Tracing and Logging
• Object representation in the Maxine VM
  • Heap
  • Object layout
  • Object representation
  • Actors
  • Hubs
  • Static tuples
• Schemes: Interfaces for Maxine VM Configuration
  • VM configuration
  • Scheme Initialization
  • Object Layout (LayoutScheme)
  • Object References (ReferenceScheme)
  • Heap allocation and garbage collection (HeapScheme)
  • Thread Synchronization (MonitorScheme)
  • VM startup sequence (RunScheme)
  • Compiler strategy (CompilationBroker)
• Snippets in the Maxine VM
  • VM feature isolation
  • IR Notation
  • Using snippets
  • Bootstrapping snippets
  • Annotations
  • Evaluation
• Stack Walking in the Maxine VM
  • Stack walk purpose 1: Exception handling
  • Stack walk purpose 2: Stack reference map preparation
  • Stack walk purpose 3: Stack inspection
• Threads in the Maxine VM
  • The main thread
  • Thread local memory
  • Safepoints
  • Stack overflow detection
  • Thread local allocation buffer (TLAB)
• Type-based Logging
  • VMLogger
  • Inspector Integration
  • VMLog
  • VMLog Flushing
• Virtual Machine Level Analysis
  • Architecture
  • Building a VMA-enabled image
  • Running a VMA-enabled image
  • Standard Handlers
  • Specifying handlers
  • Instrumenting JDK classes in the Boot Image
  • VMA and Handler Initialization
  • Analysis Tools
• VM Operations
  • Implementation Details
  • Suspend and Resume Thread Operations
• VMTI
• JVMTI
• JJVMTI
• The Maxine Inspector
  • Goals
  • Background and Rationale
  • Downloading and Building the Inspector
  • A Tour Through The Maxine Inspector
• How the Inspector interacts with the Maxine VM
  • Low-level VM Interaction
  • Passive VM support
  • Active VM support
  • Inspector evolution
• Papers and Presentations
• The Maxine Project: Contributors
  • The University of Manchester
  • Oracle Labs

Indices and tables

• Index
• Module Index
• Search Page