Maxine Inspector: Overview

The Maxine Inspector is a all-in-one tool that is specialized to support development of the Maxine Virtual Machine, a new meta-circular VM for experimentation and fast prototyping. The Maxine Inspector plays many roles:

• object, class, and method code browser;
• low-level debugger (imagine gdb or dbx);
• intermediate representation debugger;
• source-level Java debugger (eventually); and
• serviceability agent (eventually).

This short (5 minute) video describes the goals of the inspector and highlights some of the ways in which it makes Maxine VM development highly productive. More discussion and more detailed documentation follows below.

Downloading and Building

Both the Maxine VM and Inspector can be downloaded, built, and run in most Java Interactive Development Environments. In the instructions for building and running Maxine you will also find instructions for running the Maxine Inspector.

Background and Rationale

Debugging virtual machines (VMs) presents unique challenges, expecially for a meta-circular VM such as Maxine, which is written in the same language it implements. Making sense of Maxine's runtime state requires interaction simultaneously at the source, bytecode, and machine code abstraction levels, and it must leverage deep knowledge of the VM's design. Specific issues include:

• Maxine VM code must be largely optimized statically, not only for ordinary performance reasons, but also in order to be able to bootstrap the VM at all.
• The VM further optimizes itself at runtime, along with dynamic optimization of application code.
• Mapping optimized code locations back to bytecode and source locations is not generally possible without onerous limitations.
• Dynamically de-optimizing code for debugging can be effective for application code, but only when the VM can be assumed correct.
• Debugging the VM itself, however, requires scrutinizing its lowest-level, most optimized code representations and runtime machine state.
• Finally, good debugging support is paramount for a VM intended for experimentation and fast prototyping.

The Maxine Inspector addreses these concerns, supporting comprehensive inspection and interactionat all program representation levels.

Furthermore, the Inspector's design exploits the fact that it is implemented in the same language that the VM implements and is implemented in; this gives rise to many unavailable code reuse opportunities. For example, the same mechanisms used by the VM's binary image generator, which allow the creation of objects in the binary runtime format for a potentially different platform, can be used by the Inspector to examine binary runtime state for a potentially different platform than the Inspector's host.

An Introduction to Maxine Inspector Features

The following pages, which include screen snapshots and selected short video demonstrations, present more detail about specific features of the Maxine Inspector. These pages have navigational links that make it possible to take a tour through them from beginning to end.

• Boot Image Configuration
• Memory
• Memory Word Values
• Memory Regions
• Heap Objects
• Disassembled Target Code
• Disassembled Bytecodes
• Multi-code Method Views
• Threads
• Thread Local Memory
• Registers
• Stack
• Breakpoints
• Watchpoints
• Debugging
• User Preferences

Finally, please note that the Inspector is very much a work in progress, as is the Maxine VM itself. The two have co-evolved and will continue to do so as the design of the VM matures and the concerns of the developers expand. Functionality is constantly being improved and extended, so there are already places where the current system differs from what you will find here.