OpenJ9
| Company type | Open source project |
|---|---|
| Industry | Software, Java virtual machine |
| Predecessor | IBM J9 |
| Founded | 2017 |
| Founder | IBM |
Area served | Worldwide |
| Products | Java virtual machine (JVM) |
| Owner | Eclipse Foundation |
| Parent | IBM (originally) |
| Website | www |
Eclipse OpenJ9 (previously known as IBM J9) is a robust, scalable Java virtual machine (JVM) that fully adheres to the Java Virtual Machine Specification. Originally developed by IBM and now overseen by the Eclipse Foundation, OpenJ9 supports a variety of operating systems, including Linux, Windows, and macOS. It is distributed both as open-source code and as precompiled binaries through the IBM Semeru Runtimes initiative.
Serving as a core component of IBM’s Java technology stack, OpenJ9 is embedded within middleware solutions like WebSphere Application Server and WebSphere Liberty, alongside the open-source Open Liberty platform. Its rich set of configuration capabilities allows it to be fine-tuned for a wide range of Java workloads—from large-scale enterprise applications running on mainframes to ephemeral cloud container services—ensuring optimal performance and efficient resource utilization across diverse environments.
History
The origins of OpenJ9 trace back to the ENVY/Smalltalk system developed by Object Technology International (OTI), which IBM acquired in 1996 to leverage its Smalltalk expertise. As Java gained prominence in enterprise computing, the original Smalltalk virtual machine was adapted to execute Java bytecode. The designation J9 was derived from the Smalltalk codebase’s naming pattern, K8, marking the transition from Smalltalk to Java along with enhancements to the VM.
IBM’s J9 JVM became the runtime foundation for numerous enterprise middleware products, earning recognition for its strong performance, scalability, and dependability.
In 2017, the J9 project was contributed to the Eclipse Foundation, rebranded as Eclipse OpenJ9. IBM continues to play an active role in its development and integration across multiple software products. OpenJ9 entered Eclipse as an incubator project, releasing its initial version, v0.8.0, in 2018.
Features
Eclipse OpenJ9 fully implements the Java JVM specification and supports OpenJDK versions 8 and beyond, allowing applications to benefit from its capabilities across multiple Java releases. When compared with the OpenJDK HotSpot VM, OpenJ9 delivers faster startup times and reduced memory consumption while achieving comparable throughput.
Built upon Eclipse OMR, OpenJ9 leverages this framework’s core runtime components designed for multi-language environments. On top of OMR, OpenJ9 adds Java-specific features to provide a comprehensive Java runtime environment.
JIT compiler
The Just-In-Time (JIT) compiler improves Java application efficiency by translating platform-independent bytecode into native machine instructions during execution. OpenJ9 initiates JIT compilation based on how frequently methods are invoked, applying different optimization levels: cold, warm, hot, very hot (with profiling), and scorching. Advanced optimizations such as escape analysis and partial redundancy elimination are employed at higher tiers, which involve greater CPU and memory usage but yield enhanced performance—particularly advantageous for enterprise applications requiring high efficiency.
AOT compiler
Ahead-of-Time (AOT) compilation boosts startup speed by compiling methods into AOT code dynamically during runtime, facilitating quicker JVM application launches. This feature activates automatically when using class data sharing (-Xshareclasses) without necessitating manual tuning. OpenJ9 applies heuristics to determine which methods should be compiled during the startup phase of larger applications. For smaller or transient applications, incorporating the -Xtune:virtualized option further refines AOT-compiled code performance.
Class data sharing
Enhancing start-up performance and minimizing memory consumption across multiple JVM instances is achieved by sharing class data. This approach caches critical initialization classes and allows common classes to be utilized by different JVM processes.
OpenJ9 facilitates this process through a straightforward command-line switch: -Xshareclasses. Activating this option generates a memory-mapped file that holds and shares class information, automatically encompassing both bootstrap classes and application classes loaded via the default system class loader. The cache is maintained dynamically, updating as new classes load without requiring manual user actions.
Furthermore, OpenJ9 provides a publicly accessible Helper API designed for integrating class data sharing with custom class loaders, along with tools to administer active caches efficiently.
Garbage collector
OpenJ9’s garbage collector (GC) is responsible for reclaiming unused objects from the Java heap to avoid memory depletion. It supports various GC policies tailored to different application requirements and performance objectives. The standard Generational Concurrent policy (-Xgcpolicy:gencon) is optimized for transactional workloads characterized by numerous short-lived objects.
Additional GC policies include:
-Xgcpolicy:balanced, ideal for applications using large Java heaps,-Xgcpolicy:metronome, designed for environments demanding consistent response times,-Xgcpolicy:optthruput, targeting scenarios where maximizing throughput is critical.
An optional tuning feature (-XX:+IdleTuningGcOnIdle) initiates garbage collection during idle phases of the application, thereby lowering memory usage—this is particularly advantageous in virtual hosting environments where billing depends on resource consumption.
JIT server
In January 2020, OpenJ9 introduced an experimental capability allowing Just-In-Time compilation to occur remotely on a separate server outside the JVM process.
Diagnostic component
OpenJ9 includes comprehensive tracing and debugging tools designed to facilitate the detection and resolution of runtime problems. Diagnostic information is generated automatically upon certain triggers or can be manually invoked via command-line options, encompassing:
- Java dumps
- Produced when the JVM terminates due to operating system signals, OutOfMemoryError, or user requests; these provide a summary of the JVM’s state at termination.
- Heap dumps
- Captures the live object graph from the Java heap at JVM shutdown caused by OutOfMemoryError or on demand, detailing object locations, types, sizes, and references to assist in memory usage and garbage collection analysis.
- System dumps
- Platform-dependent raw binary dumps of process memory including the entire Java heap; OpenJ9 tools can transform these into human-readable formats for investigation.
- Garbage collection data
- Verbose logs that document every garbage collection event; tracing options enable more detailed examination of GC behavior.
- Trace data
- Facilitates low-overhead tracing of applications, Java methods, or internal JVM operations.
- JIT data
- Upon faults or aborts, the JIT compiler produces binary dumps useful for developer diagnostics.
- Shared classes data
- Runtime verbose options such as printStats provide insights into shared class cache usage.
The diagnostic toolkit also features the DTFJ API, which supports development of utilities capable of processing both system-level and Java-specific dumps.
Adoption
- IBM: The Semeru Runtime community combines OpenJ9 with OpenJDK class libraries, distributing it as IBM Semeru.
- Apache OpenWhisk employs OpenJ9 as the JVM implementation for its Java actions.
- Eclipse IDE offers OpenJDK 8 integrated with OpenJ9 as an officially supported runtime alternative.