Eclipse OpenJ9 Glossary
This glossary provides definitions for technical terms used throughout the Eclipse OpenJ9™ documentation.
Main Glossary
| Term | Definition | Used In Topics |
|---|---|---|
| Agent | A component loaded into a VM to perform tasks like monitoring, profiling, or diagnostics. | |
| Allocate Space | A subdivision of the nursery area in the gencon GC policy where new objects are initially created. |
|
| Allocator | Manages pools of free memory and allocates storage in the Java heap for objects that are requested by applications, libraries, or the VM. | |
| AOT (Ahead-Of-Time) Compiler | A compiler that dynamically compiles Java methods into native code at runtime and stores them in the shared classes cache for faster subsequent application starts. This compilation and storage improves startup performance for subsequent runs by avoiding interpretation. See AOT Compiler. | |
| Application Throughput | The amount of useful work an application completes per unit of time. | |
| Area-based Heap | Divides the heap into nursery and tenure areas to optimize garbage collection based on object lifespan. | |
| Arraylet | A representation technique for large arrays that cannot be contained in a single region, where arrays are split into smaller pieces (Used in balanced GC policy before the 0.53.0 release. Still in use for the metronome policy). Consists of a spine and leaves to help avoid contiguous memory allocation. See Arraylets. | |
| Attach API | Java API that allows a running VM to be connected to by another VM to load agents for monitoring or diagnostics. |
|
| Balanced GC Policy | A garbage collection policy that divides the heap into multiple regions of equal size to even out pause times and reduce overhead of operations like compaction. See -Xgcpolicy:balanced. |
|
| Bootstrap Classes | Core Java classes loaded by the bootstrap class loader, typically from the JDK's core libraries. | |
| Bytecode | Platform-neutral Java code that is interpreted or compiled by the VM. | |
| Cache Utility | Tools invoked by -Xshareclasses suboptions to manage shared classes caches (display info, adjust size, create snapshots, troubleshoot, remove caches). |
|
| Class Data Sharing (CDS) | A feature that improves startup performance and reduces memory footprint by sharing class data and metadata between VM instances through a shared classes cache. See Introduction to class data sharing. | |
Classpath (-classpath) |
Specifies the search path for application classes and resources. | |
| Cold Optimization | The lowest JIT optimization level, used during startup for large applications to achieve best compiled code speed for many methods. See Optimization levels. | |
| Compact/Compaction | A GC operation that moves objects together to eliminate fragmentation and create larger contiguous free memory areas. | |
| Compressed References | A memory optimization technique that stores object references in 32-bit format on 64-bit systems if total heap size doesn't exceed 64 GB, reducing memory footprint. See Compressed references. | |
| Concurrent Mark | A GC operation that marks live objects while application threads continue to run, reducing pause times. | |
| Concurrent Scavenge | A special mode of gencon policy that collects garbage from the nursery area in parallel with running application threads. See Concurrent Scavenge. | |
| Copy Forward | A GC operation that copies live objects from one region to another, used in balanced GC policy. | |
| CPU Entitlement | The percentage of CPU resources available to the VM process. | |
| CRIU (Checkpoint/Restore In Userspace) | Linux tool for checkpointing and restoring processes that run by using OpenJ9. | |
| CUDA (Compute Unified Device Architecture) | NVIDIA's parallel computing platform that allows Java apps to offload tasks to GPUs. | |
| CUDA4J | A technology or API within OpenJ9 that facilitates GPU acceleration for Java applications by using NVIDIA's CUDA platform. It allows Java programs to offload compute-intensive tasks to GPUs. | |
| DTFJ (Diagnostic Tool Framework for Java) | An API that allows custom applications to access information in system dumps or Java dumps. See Diagnostic Tool Framework for Java. | |
| Dump | A file containing diagnostic information about the VM state, including Java dumps, heap dumps, system dumps, JIT dumps, and snap dumps. See -Xdump. |
|
| Dynamic Agent Loading | Loading agents into a running VM without restarting it, controlled through the -XX:+EnableDynamicAgentLoading option. |
|
| Eden Space | In balanced GC, a set of regions containing the newest allocated objects. | |
| Evacuate | The process of copying reachable objects during a scavenge operation from one area to another. | |
| Flat Heap | A simple heap configuration consisting of a single area of memory, used by optavgpause, optthruput, and nogc policies. | |
| GC (Garbage Collection) | The automatic process of reclaiming memory occupied by objects that are no longer reachable by the application. See Garbage collection policies. | |
| GC Cycle | A repeatable process involving a set of GC operations that process all or parts of the Java heap. | |
| GC Policy | A strategy for garbage collection designed around different application workloads, including gencon, balanced, optavgpause, optthruput, metronome, and nogc. See -Xgcpolicy. |
|
| Generation | A grouping of objects by age; generational GC policies separate objects into different areas based on how long they've survived. | |
| Gencon (Generational Concurrent) Policy | The default GC policy best suited for transactional applications with many short-lived objects, dividing the heap into nursery and tenure areas. See -Xgcpolicy:gencon. |
|
| Global GC Cycle | A GC cycle that processes the entire Java heap, typically involving mark, sweep, and optionally compact operations. | |
| GS (Guarded Storage) Facility | Hardware support on IBM z14™ and later mainframes that enables efficient concurrent scavenge by detecting stale object references. | |
| Health Center | IBM tool for monitoring Java applications by using the Attach API. | |
| Heap | The area of memory where Java objects are allocated and managed by the garbage collector. | |
| Heap Configuration | Defines the structure of the Java heap, which can be flat or divided into areas or regions. | |
| Heap Expansion and Contraction | The VM grows or shrinks the heap based on memory needs and GC activity, which is controlled by options, such as -Xminf and -Xmaxf. |
|
| Heap Lock | A synchronization mechanism to prevent concurrent threads from accessing the same memory area during allocation. | |
| Heap Sizing | Refers to setting initial and maximum heap sizes by using options, such as -Xms and -Xmx, with finer tuning for specific areas. |
|
| Hot Optimization | A higher JIT optimization level applied to methods that consume more than 1% of execution time. See Optimization levels. | |
| Incremental GC | A GC approach that divides collection work into smaller increments to reduce maximum pause times. | |
| Inlining | A JIT optimization that replaces a method call with the actual method code to eliminate call overhead. | |
| Invocation Threshold | The number of times a method must be called before JIT compilation is triggered. | |
| Java Dump | A comprehensive diagnostic file containing information about the system, VM environment, memory usage, threads, and more. See Java dump. | |
| JFR (JDK Flight Recorder) | A profiling tool that collects application-level and JVM-level metrics with minimal overhead. See -XX:[+|-]FlightRecorder. | |
| JIT (Just-In-Time) Compiler | A component that improves performance by compiling Java bytecode into native machine code at runtime. See The JIT compiler. | |
| JIT Data | Profiling data and compilation hints stored in the shared classes cache to help subsequent VMs start and run faster. | |
| JITServer | Technology that offloads JIT compilation to a remote server to reduce resource consumption on client VMs. See JITServer technology. | |
| JVMTI (Java Virtual Machine Tool Interface) | A standard interface for monitoring and diagnostic tools to interact with the VM. See Java Virtual Machine Tool Interface. | |
| Large Object Area (LOA) | A section of the tenure area set aside for objects greater than 64 KB to minimize fragmentation. Its size is dynamically adjusted to avoid allocation failures. See -Xloa. |
|
| Layer Cache | A shared classes cache that builds on top of another cache, allowing different applications to share a common base. See Creating layer caches. | |
| Mark | A GC operation that identifies which objects are still reachable (live) by tracing references from root objects. | |
| Memory Footprint | The total amount of memory used by an application and VM. | |
| Metronome Policy | An incremental, deterministic GC policy with short pause times, designed for applications requiring precise response times. See -Xgcpolicy:metronome. |
|
| Native Code | Machine-specific compiled code that runs directly on the processor. | |
| Non-persistent Cache | A shared classes cache that exists in shared memory and is automatically removed when the OS restarts. | |
| Nursery | In gencon policy, the area of the heap where new objects are created, subdivided into allocate and survivor spaces. | |
| Offheap | In balanced GC (from 0.53.0), a separate area for storing large array data that is larger than a region size. | |
| OpenJ9 | Eclipse Foundation's open source VM optimized for performance and memory efficiency. | |
| OpenSSL | The cryptographic library that is used in OpenJ9 builds for secure communication and acceleration. | |
| Optavgpause Policy | A GC policy that optimizes for pause time using concurrent mark-sweep operations on a flat heap. See -Xgcpolicy:optavgpause. |
|
| Optimization Level | The degree of optimization applied by the JIT compiler (cold, warm, hot, very hot, scorching). See Optimization levels. | |
| Optthruput Policy | A GC policy that optimizes for throughput using stop-the-world mark-sweep operations on a flat heap. See -Xgcpolicy:optthruput. |
|
| Orphan Class | A class from a custom class loader that doesn't implement the shared classes cache API but can still be shared. See -XX:+ShareOrphans. |
|
| OutOfMemoryError | An exception thrown when the VM cannot allocate memory due to insufficient heap space. | |
| Partial GC Cycle | A GC cycle that processes only part of the heap, typically the nursery area in gencon or selected regions in balanced. | |
| Pause Time | The duration that application threads are stopped during GC operations. | |
| Persistent Cache | A shared classes cache written to memory-mapped files that remains after system reboot. | |
| POSIX (Portable Operating System Interface) | Standards specified by the IEEE Computer Society to maintain compatibility between operating systems. Enables the portability of software across different UNIX-like operating systems and other POSIX-compliant systems. | |
| POSIX File Permissions | UNIX file access control standard used to secure Attach API directories. | |
| Region | In balanced GC, one of many equal-sized divisions of the heap (typically 512 KB to a few MB) that serves as the basic unit of GC operations. | |
| Region-based Heap | Divides the heap into many equal-sized regions to manage object generations. Used by balanced and metronome GC policies. |
|
| Scavenge | A GC operation that reclaims memory from the nursery area by copying live objects and clearing dead ones. | |
| Scorching Optimization | The highest JIT optimization level, applied to methods consuming more than 12.5% of execution time. See Optimization levels. | |
| Shared Classes Cache | A memory area that stores and shares class data, AOT code, and JIT data between multiple VM processes to enable faster application startup. See Introduction to class data sharing. | |
| Small Object Allocation | The process of allocating memory for objects that are typically smaller than 64 KB in a designated part of the heap called the Small Object Area (SOA). | |
| Small Object Area (SOA) | The main section of the tenure area where new objects are allocated (objects smaller than 64 KB). Allocation failures here trigger garbage collection. | |
| Snapshot | A saved copy of a non-persistent shared classes cache that can be restored after system reboot. See Saving a non-persistent shared classes cache. | |
| Stale Class | A class in the shared cache that has been updated on the file system and is marked for potential invalidation. | |
| Startup Time | The time required for an application to initialize and begin processing. | |
| Sticky Bit | UNIX permission setting that restricts deletion or renaming of files in a directory to the file owner or root. | |
| STW (Stop-The-World) | A GC pause during which all application threads are halted to give GC operations exclusive access to the heap. | |
| Survivor Space | A subdivision of the nursery area in gencon policy where objects are copied during scavenge operations. | |
| Sweep | A GC operation that reclaims memory occupied by unmarked (dead) objects. | |
| System Temporary Directory | Directory that is used by Attach API to store temporary files for communication between VMs. | |
| Taxation Threshold | In balanced GC, a predetermined threshold that triggers a partial GC cycle when the eden space region count is reached. | |
| Tenure | The process of moving an object from the nursery to the tenure area after it has survived multiple scavenge cycles. | |
| Tenure Age | The number of times an object has been copied between allocate and survivor spaces (range 1-14). | |
| Tenure Area | In gencon policy, the area of the heap where longer-lived objects are stored after surviving multiple scavenge cycles. | |
| Thread Local Heap (TLH) | A thread-specific memory cache that allows memory allocation without acquiring the heap lock, thus improving performance. | |
| Tilting | A technique that dynamically adjusts the boundary between allocate and survivor spaces based on survival rates. | |
| Tilt Ratio | The proportion of the nursery area allocated to the allocate space versus the survivor space. | |
| Tracepoint | A logging point in the VM code that records information about operations and exceptional conditions. See -Xtrace. |
|
| Verbose GC Log | A detailed log file containing GC metrics and operations, useful for performance analysis and tuning. See Verbose GC logs. | |
| Very Hot Optimization | A high JIT optimization level with profiling, used before scorching compilation to collect detailed profile data. See Optimization levels. | |
| VM (Virtual Machine) | The runtime environment that executes Java bytecode and manages application resources. | |
| Warm Optimization | The standard JIT optimization level used after startup for most methods that reach the invocation threshold. See Optimization levels. | |
| Write Barrier | A mechanism that tracks object reference modifications to support concurrent GC operations. |
Command-Line Options & Configuration
For a complete list of all command-line options, see:
- Standard command-line options - Options starting with
-X - Non-standard command-line options - Options starting with
-XX: