Below is a list of publications that use Jikes RVM. This list includes both papers written by Jikes RVM developers, as well as users of the system. We strongly encourage authors to utilize the Research Archive to publish source code used in their studies, and thus, allow others to build on their results. When the implementation described in a paper is available in a Jikes RVM release, this is noted with the paper. Information of dissertations relating to the Jikes RVM is available here. If you would like to see a paper listed then please send details to the RVM researchers mailing list.


The Design and Construction of High Performance Garbage Collectors

Work-Stealing Without The Baggage

A Black-box Approach to Understanding Concurrency in DaCapo

Down for the Count? Getting Reference Counting Back in the Ring

Barriers Reconsidered: Friendlier Still!


Fine-Grained Adaptive Biased Locking

Next In Line, Please! Efficiently Estimating and Exploiting the Indirect Benefits of Inlining

SOS: Saving Time in Dynamic Race Detection with Stationary Analysis

A Literate Experimentation Manifesto

Quarantine: A Framework to Mitigate Memory Errors in JNI Applications

A Comprehensive Evaluation of Object Scanning Techniques

LeakChaser: Helping Programmers Narrow Down Causes of Memory Leaks

Magic for the Masses: Safer High-level Low-level Programming through Customizable Static Analyses


Hera-JVM: A System for Heterogeneous Multi-Core Architectures

An Input-Centric Paradigm for Program Dynamic Optimizations

What Can the GC Compute Efficiently? A Language for Heap Assertions at GC Time

Headroom-based pretenuring: dynamically pretenuring objects that live "long enough"

Local redundant polymorphism query elimination

Z-Rays: Divide Arrays and Conquer Speed and Flexibility

Pacer: Proportional Detection of Data Races

Breadcrumbs: Efficient Context Sensitivity for Dynamic Bug Detection Analyses

The Locality of Concurrent Write Barriers

The Economics of Garbage Collection

Efficient, Context-Sensitive Detection of Real-World Semantic Attacks

Automated just-in-time compiler tuning


GC Assertions: Using the Garbage Collector to Check Heap Properties

An Experimental Study of Methods for Executing Test Suites in Memory Constrained Environments

Demystifying Magic: High-level Low-level Programming

Flexible Reference-Counting-Based Hardware Acceleration for Garbage Collection

Laminar: Practical Fine-Grained Decentralized Information Flow Control

Leak Pruning

The Impact of Java Applications at Microarchitectural Level from Branch Prediction Perspective

Mostly-Functional Behavior in Java Programs


Tolerating Memory Leaks

Java Performance Evaluation through Rigorous Replay Compilation

Constraint Based Optimization of Stationary Fields

The PIM: an Innovative Robot Coordination Model based on Java Thread Migration

A Lazy Developer Approach: Building a JVM with Third Party Software

Speculative Improvements to Verifiable Bounds Check Elimination

Wake Up and Smell the Coffee: Evaluation Methodology for the 21st Century

Boot Image Layout for Jikes RVM

Pure Method Analysis within Jikes RVM

Approaches to Reflective Method Invocation

Speculative Multithreading: An Object-Driven Approach

No Bit Left Behind: The Limits of Heap Data Compression

Immix: A Mark-Region Garbage Collector with Space Efficiency, Fast Collection, and Mutator Performance

Adaptive Loop Tiling for a Multi-Cluster CMP

A Study of Java Object Demographics

Phase-based Adaptive Recompilation in a JVM


GC Assertions: Using the Garbage Collector to Check Heap Properties

A Method Specialisation and Virtualised Execution Environment for Java

Dynamic Analysis of Java Program Concepts for Visualization and Profiling

Object Co-location and Memory Reuse for Java Programs


Effective Prefetch for Mark-Sweep Garbage Collection

Decrypting the Java Gene Pool: Predicting Object Lifetimes with Micro-Patterns

Uniqueness Inference for Compile-Time Object Deallocation

Statistically Rigorous Java Performance Evaluation

Using HPM-Sampling to Drive Dynamic Compilation

Intelligent Selection of Application-Specific Garbage Collectors

Probabilistic Calling Context

Tracking Bad Apples: Reporting the Origin of Null and Undefined Value Errors

Java Object Header Elimination for Reduced Memory Consumption in 64-Bit Virtual Machines

Optimizing Chip Multiprocessor Work Distribution using Dynamic Compilation

GCH: Hints for Triggering Garbage Collections

Object-Relative Addressing: Compressed Pointers in 64-Bit Java Virtual Machines

Fast Online Pointer Analysis

Correcting the Dynamic Call Graph Using Control Flow Constraints

Isla Vista Heap Sizing: Using Feedback to Avoid Paging

Transactional Collection Classes

A Scalable, Non-blocking Approach to Transactional Memory

Mobility of Data in Distributed Hybrid Computing Systems

Transactional Memory: The Hardware-Software Interface

Cork: Dynamic Memory Leak Detection for Java


Lazy Interprocedural Analysis for Dynamic Loop Parallelization

Leveraging strong agent mobility for Aglets with the Mobile JikesRVM framework

Executing Java programs with transactional memory

CRAMM: Virtual Memory Support for Garbage-Collected Applications

Revocation techniques for Java concurrency

JAVANA: A System for Building Customized Java Program Analysis Tools

The DaCapo Benchmarks: Java Benchmarking Development and Analysis

Method-Specific Dynamic Compilation using Logistic Regression

Adapting VM Techniques for Seamless Aspect Support

Efficient Control Flow Quantification

Bell: Bit-Encoding Online Memory Leak Detection

Trace-based automatic parallelization in the Jikes RVM

Enabling Java Mobile Computing on the IBM Jikes Research Virtual Machine

Transparently reconciling transactions with locking for Java synchronization

Architectural Semantics for Practical Transactional Memory

Relative Factors in Performance Analysis of JVMs

Impact of Virtual Execution Environments on Processor Energy Consumption and Hardware Adaptation

Free-Me: A Static Analysis for Automatic Individual Object Reclamation

The Compressor: Concurrent, Incremental, and Parallel Compaction

The Atomos Transactional Programming Language

Parallelizing SPECjbb2000 with Transactional Memory

Reducing generational copy reserve overhead with fallback compaction

Strong Agent Mobility for Aglets based on the IBM JikesRVM

Hybrid Optimizations: Which Optimization Algorithm to Use?

Space-Efficient 64-bit Java Objects through Selective Typed Virtual Addressing

Dynamic Class Hierarchy Mutation

Online Phase Detection Algorithms

The Common Case Transactional Behavior of Multithreaded Programs

64-bit versus 32-bit Virtual Machines for Java

Compiler Techniques for High Performance Sequentially Consistant Java Programs.

Automatic Tuning of Inlining Heuristics


Loop Parallelisation for the Jikes RVM

Continuous Path and Edge Profiling

Garbage Collection Hints

Towards Continuous Usage Control on Grid Computational Services.

A Platform to Use Hardware Performance Counters for Dynamic Compilation

Comparing Low-Level Behavior of SPEC CPU and Java Workloads

Are Patches Cutting it? Structuring Distribution within a JVM using Aspects

Automating Vertical Profiling

Improving Virtual Machine Performance Using a Cross-Run Repository

Quantifying the Performance of Garbage Collection vs. Explicit Memory Management

Quantifying the Performance of Garbage Collection vs.Explicit Memory Management

Runtime Specialization With Optimistic Heap Analysis

Safe Futures for Java

Transactional Execution of Java Programs

Automatic Tuning of Inlining Heuristics

Testing in Resource Constrained Execution Environments

JikesNode and PearColator: A Jikes RVM Operating System and Legacy Code Execution Environment

An Automatic Runtime DOALL Loop Parallelisation Optimization for Java

Characterization of TCC on Chip-Multiprocessors

FPGA-Aware Garbage Collection in Java

Garbage Collection Without Paging

An Execution Layer for Aspect-Oriented Programming Languages

Immutability Specification and its Application

Age-Oriented Concurrent Garbage Collection

An Efficient On-The-Fly Cycle Collection

Jazz: A Tool for Demand-Driven Structural Testing

A Study of Type Analysis for Speculative Method Inlining in a JIT Environment

Using Interprocedural Side-effect Information in JIT Optimizations

Effective Adaptive Computing Environment Management via Dynamic Optimization

Collecting and Exploiting High-Accuracy Call Graph Profiles in Virtual Machines

The Jikes Research Virtual Machine project: Building an open-source research community


Anticipation-Based Partial Redundancy Elimination for Static Single Assignment Form

An Inlining Technique in Jikes RVM to Improve Performance

Finding Your Cronies: Static Analysis for Dynamic Object Colocation

MC2: High-Performance Garbage Collection for Memory-Constrained Environments

Method-Level Phase Behavior in Java Workloads

Program Locality: The Garbage Collection Advantage

Vertical Profiling: Understanding the Behavior of Object-Oriented Applications

Automatic Heap Sizing: Taking Real Memory Into Account

Barriers: Friend or Foe?

Dynamic Object Sampling for Pretenuring

Dynamic Selection of Application-Specific Garbage Collectors

Write Barrier Elision for Concurrent Garbage Collectors

Improving Grid Service Security with Fine Grain Policies

Virtual Machine Support for Aspects with Advice Instance Tables

Micro-Measurements for Dynamic Aspect-Oriented Systems

The Use of Traces for Inlining in Java Programs

Online Impact Analysis via Dynamic Compilation Technology

Partial Redundancy Elimination for Global Value Numbering

Preemption-Based Avoidance of Priority Inversion for Java

Value-Based Partial Redundancy Elimination

Adaptive Tuning of Reserved Space in an Appel Collector

Pointer Analysis in the Presence of Dynamic Class Loading

Transactional Monitors for Concurrent Objects

Visualization and Analysis of Phased Behavior in Java Programs

Myths and Reality: The Performance Impact of Garbage Collection

Adaptive Code Unloading for Resource-Constrained JVMs

Inducing Heuristics to Decide Whether to Schedule

Oil and Water: High Performance Garbage Collection in Java with MMTk

Towards Dynamic Interprocedural Analysis in JVMs

Using Hardware Performance Monitors to Understand the Behavior of Java Application

JVM Independent Replay in Java

A Semantic Framework for Designer Transactions

Virtual Machine Support for Dynamic Join Points


The Metronome: A Simpler Approach to Garbage Collection in Real-time Systems

Ulterior Reference Counting: Fast Garbage Collection without a Long Wait

An On-the-Fly Mark and Sweep Garbage Collector Based on Sliding Views

MarkCopy: Fast Copying GC with Less Space Overhead

Connectivity-Based Garbage Collection

How Java Programs Interact with Virtual Machines at the Microarchitectural Level

Transparent Fault-Tolerant Java Virtual Machine

JToe: A Java API for Object Exchange

High-performance Java code for computation fluid dynamics

Detecting Malicious Java Code Using Virtual Machine Auditing

Controlling Fragmentation and Space Consumption in the Metronome, a Real-time Garbage Collector for Java

Designing a Distributed JVM on a Cluster

Integrating Generations with Advanced Reference Counting Garbage Collectors

Just-In-Time Aspects: Efficient Dynamic Weaving for Java

Design, Implementation and Evaluation of Adaptive Recompilation with On-Stack Replacement

Adaptive Online Context-Sensitive Inlining

Coupling On-Line and Off-Line Profile Information to Improve Program Performance

A Real-time Garbage Collector with Low Overhead and Consistent Utilization

Using the SafeTSA Representation to Boost the Performance of an Existing Java Virtual Machine


Online Feedback-Directed Optimization of Java

Creating and Preserving Locality of Java Applications at Allocation and Garbage Collection Times

GCspy: An Adaptable Heap Visualisation Framework

Immutability Specification and its Applications

Experiences Porting the Jikes RVM to Linux/IA32

Automatic Implementation of Programming Language Consistency Models

In or Out? Putting Write Barriers in Their Place

An Adaptive, Region-based Allocator for Java

Understanding the Connectivity of Heap Objects

When to Use a Compilation Service?

Beltway: Getting Around Garbage Collection Gridlock

Static Load Classification for Improving the Value Predictability of Data-Cache Misses

Efficient and Precise Datarace Detection for Multithreaded Object-Oriented Programs

Older-first Garbage Collection in Practice: Evaluation in a Java Virtual Machine

Error-Free Garbage Collection Traces: How To Cheat and Not Get Caught

Using Adaptive Optimization Techniques to Teach Mobile Java Computing

Thin Guards: A Simple and Effective Technique for Reducing the Penalty of Dynamic Class Loading.

Atomic Instructions in Java

Space- and Time-Efficient Implementation of the Java Object Model

The Pensieve Project: A Compiler Infrastructure for Memory Models

Exploiting Prolific Types for Memory Management and Optimizations


Efficient Implementation of Java Interfaces: Invokeinterface Considered Harmless

Pretenuring for Java

Dynamic Optimistic Interprocedural Analysis: A Framework and an Application

Efficient Dependence Analysis For Java Arrays

A Comparative Evaluation of Parallel Garbage Collectors

A Framework for Reducing the Cost of Instrumented Code

Java without the Coffee Breaks: A Non-intrusive Multiprocessor Garbage Collector

Program Analysis for Safety Guarantees in a Java Virtual Machine Written in Java.

Concurrent Cycle Collection in Reference Counted Systems

Characterizing the Memory Behavior of Java Workloads: A Structured View and Opportunities for Optimizations

High-Performance Java Codes for Computational Fluid Dynamics

Dynamic Type Checking in Jalapeño


Reducing the Overhead of Dynamic Compilation

Adaptive Optimization in the Jalapeño JVM: The Controller's Analytical Model

Adaptive Optimization in the Jalapeño JVM

Quasi-Static Compilation for Java

Debugging by Remote Reflection

An Empirical Study of Selective Optimization

Unified Analysis of Array and Object References in Strongly Typed Languages

ABCD: Eliminating Array Bounds Checks on Demand

A Framework for Interprocedural Analysis and Optimization in the Presence of Dynamic Class Loading

Optimizing Java Programs in the Presence of Exceptions

The Jalapeño Virtual Machine

A Comparative Study of Static and Profile-Based Heuristics for Inlining


Implementing Jalapeño in Java

Efficient and Precise Modeling of Exceptions for the Analysis of Java Programs

Dependence Analysis for Java

The Jalapeño Dynamic Optimizing Compiler for Java

Jalapeño — a Compiler-supported Java Virtual Machine for Servers