- Dev Build
- Native Image
- Build Output
- Build Configuration
- Tracing Agent
- Experimental Agent Options
- Native Image Compatibility and Optimization Guide
- Class Initialization in Native Image
- Static Native Images
- Native Image Options
- Native Image Hosted and Runtime Options
- Native Image Inspection Tool
- Native Image C API
- Implementing Native Methods in Java with Native Image
- LLVM Backend for Native Image
- Debug Info Feature
- Points-to Analysis Reports
- Using System Properties in Native Image
- Profile-Guided Optimizations
- Memory Management at Image Run Time
- Generating Heap Dumps from Native Images
- JDK Flight Recorder with Native Image
- JCA Security Services on Native Image
- Dynamic Proxy on Native Image
- Java Native Interface (JNI) on Native Image
- Reflection on Native Image
- Accessing Resources in Native Images
- Logging on Native Image
- URL Protocols on Native Image
- Native Image ARM64 Support
- GraalVM Updater
- Languages References
- Embedding Reference
- Polyglot Programming
Experimental Agent Options
native-image-agent tool has options which are currently experimental and might be enabled in future releases, but can also be changed or removed entirely.
These options are described here.
Support For Predefined Classes #
Native-image needs all classes to be known at image build time (a “closed-world assumption”).
However, Java has support for loading new classes at runtime.
To emulate class loading, the agent can be told to trace dynamically loaded classes and save their bytecode for later use by the image builder.
This functionality can be enabled by adding
experimental-class-define-support to the agent option string, e.g.:
Apart from the standard configuration files, the agent will create an
agent-extracted-predefined-classes directory in the configuration output directory and write bytecode of newly loaded classes on the go.
The configuration directory can then be used by image builder without additional tweaks,.
The classes will be loaded during the image build, but will not be initialized or made available to the application.
At runtime, if there is an attempt to load a class with the same name and bytecodes as one of the classes encountered during tracing, the predefined class will be supplied to the application.
Known Limitations #
- Native images support “loading” a predefined class only once per execution, by just a single class loader.
- Predefined classes are initialized when they are “loaded” at runtime and cannot be initialized at build time.
- The agent collects all classes which are not loaded by one of the Java VM’s built-in class loaders (with some exceptions), that is, from the class path or module path. This includes classes loaded by any custom class loaders.
- Classes that are generated with varying data in their name or bytecodes, such as sequential or random numbers or timestamps, can generally not be matched to predefined classes at runtime. In these cases, the way such classes are generated needs to be adjusted.
Printing Configuration With Origins #
For debugging, it may be useful to know the origin of certain configuration entries.
experimental-configuration-with-origins to the agent option string, the agent will output configuration files with configuration entries broken down to the calling context (stack trace) they originate from in tree form.
This option should be used in conjunction with
config-output-dir=<path> to tell the agent where to output the configuration files.
An example agent option string:
Omitting Configuration From The Agent’s Output #
The agent can omit traced configuration entries present in existing configuration files. There are two ways to specify these existing configuration files:
- By using configuration files from the class path or module path. When
experimental-omit-config-from-classpathis added to the agent option string, the class path and module path of the running application are scanned for
- By explicitly pointing the agent to an existing configuration file directory using
Generating Conditional Configuration Using The Agent #
The agent can, using a heuristic, generate configuration with reachability conditions on user specified classes. The agent will track configuration origins and try to deduce the conditions automatically. User classes are specified via an agent filter file (for more information on the format, see Agent.md). Additionally, the resulting configuration can further be filtered using another filter file.
Currently, this feature supports two modes:
- Generating conditional configuration in a single run with the agent.
- Generating conditional configuration from multiple runs with the agent and finally merging the collected data.
Generating Conditional Configuration During An Agent Run #
To enable this mode, add
experimental-conditional-config-filter-file=<path> to the agent’s command line, where
<path> points to an agent filter file.
Classes that are considered included by this filter will be designated as user code classes.
To further filter the generated configuration, you can use
<path> is a path to an agent filter file.
Generating Conditional Configuration From Multiple Agent Runs #
Conditional configuration can be generated from multiple agent runs that reach different code paths in the application.
Each agent run produces configuration with metadata.
native-image-configure is then used to merge the collected data and produce a conditional configuration.
To run the agent in this mode, add
experimental-conditional-config-part to the agent’s command line.
Once all the agent runs have finished, you can generate a conditional configuration by invoking:
native-image-configure generate-conditional --user-code-filter=<path-to-filter-file> --class-name-filter=<path-to-filter-file> --input-dir=<path-to-agent-run-output-1> --input-dir=<path-to-agent-run-ouput-2> ... --output-dir=<path-to-resulting-conditional-config>
--user-code-filter=<path-to-filter-file>: path to an agent filter file that specifies user classes
--class-name-filter=<path-to-filter-file>: path to an agent filter file that further filters the generated config
The Underlying Heuristics #
Conditions are generated using the call tree of the application. The heuristics work as follows:
- For each unique method, create a list of all nodes in the call tree that correspond to the method
- For each unique method, if the method has more than one call node in the tree:
- Find common configuration across all call nodes of that method
- For each call node of the method, propagate configuration that isn’t common across these calls to the caller node
- Repeat 2. until an iteration produced no changes in the call tree.
- For each node that contains configuration, generate a conditional configuration entry with the method’s class as the condition.
The primary goal of this heuristic is to attempt to find where a method creates different configuration entries depending on the caller (for example, a method that wraps
This implies that the heuristic will not work well for code that generates configuration through a different dependency (for example, same method returns calls
Class.forName with different class parameters depending on a system property).