Command-Line Options

Disables intrinsic for BigInteger::multiplyToLen()

Disables intrinsic for BigInteger::squareToLen()

Disables intrinsic for BigInteger::mulAdd()

Implements BigInteger.montgomeryMultiply intrinsic.

Implements BigInteger.squareMultiply intrinsic.

Enables intrinsic for log4j StackLocator.getCallerClass().

Use BASE64 intrinsics on AVX2-capable hardware.

Flag to indicate the level of resources available in the environment where Zing runs. VMFootprintLevel is a "master" option which results in tuning of a number of internal options.

Check Analyzing and Tuning Warmup for more information on VMFootprintlevel and which settings are specifically changed using this option.

Enables or disables Extended NMT mode. Disabling this option tells Zing to run NMT in a Zulu-like mode.

Enables or disables checks on allocations.

Enables output of the Native Memory Tracking statistics.

Specifies the level of tracking output. Note that enabling this will cause 5-10% performance overhead.

To extend the functionality in versions 23.02.0.0 through 23.05.0.0, it is necessary to use LD_PRELOAD. To enable this extended tracking, set the environment variable pointing to libnmt_hooks.so included in the Prime package. From version 23.06.0.0, the libnmt_hooks.so library is linked by default.

 
LD_PRELOAD=$JAVA_HOME/etc/zing/lib/libnmt_hooks.so

Enables periodic NMT logging and specifies the directory where logs are periodically dumped. This is a diagnostic feature and requires -XX:+UnlockDiagnosticVMOptions.

Specifies the interval for printing the NMT logs to the specified directory.

Enables defensive heap shrinking.

The maximum amount by which you can lower the Java heap, as a percentage of Xmx.

The maximum NewGC duty cycle, under which the heap is allowed to be reduced.

If NewGC duty cycle (time percentage) goes above this value, defensive heap shrinking isn’t applied.

The amount of free and available memory you want the machine to try to maintain in the container, as a percent of total Xmx.

Includes inactive file cache when computing available memory for new allocations, used with elastic heaps and defensive heap shrinking.

Allocate code cache and related data structures at virtual address within 2 GB. The maximum supported code cache size while this option is disabled is 1758 MB.

Disables emergency code cache flushing. Emergency flushing starts removing unused blobs only when more than 85% of code cache space is consumed. Before that it "sleeps" and does nothing. This option is enabled by default.

When code cache flushing is enabled, enables Tier 1 code cache flushing after the emergency threshold has been reached. This option takes precedent over -XX:+EnableC1Flushing.

When code cache flushing is enabled, enables Tier 2 code cache flushing after the emergency threshold has been reached. This option takes precedent over -XX:+EnableTier2Flushing.

Enables regular code cache flushing. Unlike emergency flushing, regular flushing triggers unused blobs removal during the whole lifetime of Zing, i.e., it never waits for reaching 85% of code cache utilization. This option can be helpful when the code cache memory is being exhausted despite UseEmergencyCodeCacheFlushing was enabled. This option is disabled by default.

When incremental code cache flushing is enabled, -XX:+UseIncrementalCodeCacheFlushing, sets the maximum interval, in seconds, before the old garbage collector is asked to re-enable flushing of code blobs.

Turns off flushing of unused code blobs generated by the Tier 1 compiler. This option takes effect only if -XX:+UseIncrementalCodeCacheFlushing is set to true.

Turns off flushing of unused code blobs generated by the Tier 2 compiler. This option takes effect only if -XX:+UseIncrementalCodeCacheFlushing is set to true.

Reserves the specified amount of space for code other than code compiled methods.

Sets the initial size of the elastic table used internally by the VM to store information about object references that reside in the code cache. The maximum value is 64 MB.

Specifies the maximum size of the code cache. The minimum value is a minimum of 6% of Xmx and 256 MB. The maximum value is 4 GB.

Specifies the initial size of the code cache. The minimum value is a minimum of 3% of Xmx and 64 MB. The maximum value is the value of ReservedCodeCacheSize.

Locks code cache in memory, preventing it from being paged out or swapped out. The option is not applicable to the ZST mode.

Decides whether code cache is accounted under C heap or under Java heap.

Specifies the initial size of the monitor cache. Units can be specified in kilobytes (K or k), megabytes (M or m), or gigabytes (G or g).

Specifies the maximum size of the monitor cache. Units can be specified in kilobytes (K or k), megabytes (M or m), or gigabytes (G or g).

Allows choosing between C heap and Java heap memory for MonitorCache. Using monitor cache elasticity is not recommended when monitors are in Java heap and, by default, InitialCodeCacheSize is set to ReservedCodeCacheSize when the flag is disabled.

Locks memory (mlock) to prevent monitor cache pages from being swapped out.

Minimum allowed size of the thread local allocation buffer (in bytes).

When true, uses a single 2 MB page as a fixed size TLAB.

Specifies maximum TLAB waste at a refill (internal fragmentation).

Sets the size of the thread local allocation buffer.

Determines the percentage of the threshold of the TLAB when the object size is larger than a threshold, the TLAB is retired, and the object is allocated inside a new TLAB.

Enables Zing to use large (2M pages) if the system is properly configured. Before trying to use large pages, read Using Huge Pages with Zing for system configuration steps.

Enables Zing to use Transparent Huge Pages (THP) in shared memory madvise mode if the system is properly configured. Before trying to use large pages, read Using Huge Pages with Zing for system configuration steps. To enable, use -XX:-UseTransparentHugePages. Transparent Huge Pages (THP) in shared memory madvise mode is available in Linux kernel version 4.12.10 and above.

Use Transparent Huge Pages (THP) for code cache provided that (a) it is allocated in C heap memory and (b) it is safe to use THP without incurring defragmentation stall.

Use Transparent Huge Pages (THP) for monitor cache provided that (a) it is allocated in C heap memory and (b) it is safe to use THP without incurring defragmentation stall.

Use Transparent Huge Pages (THP) for sideband forwarding table provided that (a) it is allocated in C heap memory and (b) it is safe to use THP without incurring defragmentation stall.

Used to explicitly disable Transparent Huge Pages, overriding the parent process / system default

Points to the mount point for managing large pages when configuring static Large pages. Used in conjunction with -XX:UseLargePages on Linux kernel versions prior to 4.14. Before trying to use large pages, read Using Huge Pages with Zing for system configuration steps.

Enables non-uniform memory access (NUMA) interleaving when libnuma library is present.

Report more accurate resident set size (RSS) value for off heap memory in the GC log file. In the non-ZST mode, Zing uses the shared memory multimapping facility provided by Linux. However, the RSS reported by Linux is known to be inaccurate when the process does multimapping. When the flag is turned on, Zing tries to compute a more accurate value for RSS, which is then reported in the GC log.

Acquires all of Xmx upfront before starting the application. If the option is not specified, a JVM internal thread acquires the memory in the background after an application is started.

Optimizes mlockall(2) behavior to significantly reduce application exit times.

Enables use of Top Byte Ignore feature of Aarch64 processors for better out-of-the-box performance and correct RSS reporting. Supported only on ARMv8+ with linux kernel version 5.4 and above

Prevents the whole of the initial heap size, InitialHeapSize or -Xms, from being committed from the OS upfront, according to the specified value of GPGCLazyInitialHeapCommitPercent. The remainder gets committed based on regular elastic heap heuristics.

Specifies what percent of InitialHeapSize or -Xms shall be committed from the OS upfront at startup, when GPGPCCommitInitialHeapLazily is enabled.

Java 11 and 17: Switches back to the previous MXBean GC metric name java.lang.GarbageCollector.GPGC New and java.lang.GarbageCollector.GPGC Old.

Allows VM to smoothly decrease allocation rate of the application if GC doesn’t keep up. Helps to avoid complete exhaustion of heap space followed by possibly long stalls. Available in non-ZST mode only.

Tells the JVM to promote a checkpoint to a safepoint if the checkpoint takes too much time. A checkpoint happens when the JVM needs to interrupt a single Java thread and do something to it. The action will not affect any other threads that are running.

Abort the VM upon failure to reach safepoint. A safepoint happens when the JVM needs to pause every Java thread that’s running in order to perform an operation which can only happen when all threads are asleep

Delay in milliseconds for option CheckpointTimeout.

Delay in milliseconds for option DieOnSafepointTimeout.

Abort the VM if safepoint operationTime exceeds SafepointOperationTimeoutDelayMS.

Timeout, in milliseconds, for safepoint operation when DieOnSafepointOperationTimeout is enabled.

Number of cache lines of padding to insert after mutator relocated objects during relocation.

When true, retain any previously allocated active object padding during GC relocation. When false, any previously allocated active object padding is removed during GC relocation and will not be re-added until the object is mutator relocated again.

Time, in milliseconds, that an object page stays in the new generation before getting promoted to the old generation.

Limits the number of mutator NMT reference buffer flushes performed during concurrent marking. The default value of the retry limit is 3. To return to the old behavior of looping in concurrent marking until no more mutator references are flushed, change the default value to -1.

Controls the behavior of the new garbage collector when the number of iterations of the concurrent marking mutator NMT flush loop exceeds the specified retry limit. The default action is to perform reference strengthening followed by iterating the limit of retries more times before exiting out of the loop and heading toward the safepoint.

Allocates the limit from the pause fund to restrict pause prevention memory.

Controls the time interval between consecutive heuristic evaluations when Zing runs heuristics to determine the time to trigger a garbage collection. The default is 20 milliseconds starting with Zing 20.03.0.0. Before Zing 20.03.0.0, it was 50 milliseconds.

Implements a no-op garbage collector. When enabled, Zing neither triggers any GC cycles nor generates GC barriers. Being an experimental option, it needs to be unlocked by preceding -XX:+UnlockExperimentalVMOptions.

Specifies the half-life, in milliseconds, for exponential decay of heuristic models that drive triggering of garbage collection cycles.

Specifies the maximum interval between new generation garbage collection cycles triggered by GC heuristics. The interval is calculated from the start of the previous new generation collection.

Specifies the maximum interval between old generation garbage collection cycles triggered by GC heuristics. The interval is calculated from the start of the previous old generation collection.

Specifies the maximum number of new GC cycles that can be run before triggering the next full (Old) GC cycle.

Enables unified GC logging in Zing 8, 11, and 13.

Specifies the soft limit for java heap usage by the new generation, in bytes, that GC heuristics target to achieve.

If GPGCTargetPeakNewGenOccupancyBytes is not set, the value will be adjusted dynamically. Explicitly setting this option disables dynamic allocation.

Specifies the soft limit for java heap usage by the new generation, as a percentage of the maximum heap size, that GC heuristics target to achieve.

If GPGCTargetPeakNewGenOccupancyPercent is not set, the value will be adjusted dynamically. Explicitly setting this option disables dynamic allocation.

Specifies the soft limit for overall java heap usage, as a percentage of the maximum heap size, that GC heuristics target to achieve.

If GPGCTargetPeakHeapOccupancyPercent is not set, the value will be adjusted dynamically. Explicitly setting this option disables dynamic allocation.

Specifies the number of garbage collection worker threads for the new generation. Setting default value is based off of Xmx: If Xmx is more than 2 GB, the default value is 45% of the number of logical cores available to the process. If Xmx is less than or equal to 2 GB, the default value is either Xmx divided by 128 MB or 45% of the number of logical cores available to the process, whichever is smaller. If -XX:+UseSTW is specified, the default value is the number of logical cores. available to the process.

The minimum value supported is 1.

If not set, this value can be managed dynamically. See note in -XX:GPGCThreads.

Specifies the number of garbage collection worker threads for the old generation. Setting default value is based off of Xmx:

The minimum value supported is 1.

If not set, this value can be managed dynamically using . See note in -XX:GPGCThreads.

Specifies the total number of garbage collection worker threads This is an alternative way to specify GenPauselessNewThreads and GenPauselessOldThreads When used, GenPauselessOldThreads is derived as 40% of GPGCThreads. GenPauselessNewThreads is then derived as GPGCThreads – GenPauselessOldThreads. The default value is the sum of the default values of GenPauselessNewThreads and GenPauselessOldThreads.

The minimum value supported is 2.

Turn on/off dynamic changes to GC thread counts.

Enable dynamic garbage collection thread count policy.

Lower GC pauses with JVMTI, resolving deadlock with callbacks during JVMTI tag map clearing

When enabled, the JVM issues JVMTI GC event notifications from within safepoints. Disabling it causes notifications to happen from outside the safepoint.

If disabled, will cause CPU-based heuristics to be skipped for heap elasticity and dynamic GC thread counts.

Tells the Garbage Collector to pause and wait for mutator threads to be woken up before resuming, after every GC safepoint. If -XX:-GPGCSafepointWaitForMutatorResume is set, the Garbage Collector resumes its work in parallel with mutator threads waking up.

When set to a value greater than zero, defines a time interval for periodic printing of GC log headers. This helps open partial GC logs in GC log analyzer, for example those pulled from Splunk.

Also known as hybrid mode. Enables Load Value Barrier (LVB) Code Versioning. Improves the throughput of your JVM application by eliminating cost of the Garbage Collector (GC) barrier instructions when the GC is not running, at the cost of higher GC CPU usage while the GC is running.

Hybrid mode has three modes:

Preserves the starting logs during log rotation.

If you are using Unified Logging, this option is replaced with the Xlog:gc parameter 'savecount'.

Defines the duration of the periodic GC logging Warmup phase, in seconds.

Defines the duration of the periodic GC logging Steady phase, in seconds. The default is 0, which means logging continues indefinitely unless explicitly changed. If you explicitly set this option to 0, the Steady phase is skipped.

Controls how frequently logs are printed during the periodic GC logging Warmup phase, in seconds.

Controls how frequently logs are printed during the periodic GC logging Steady phase, in seconds.

Enables logging of Reference.get() counters in standard log line format. This records any time a Reference.get() call is made, as well as how many total refs were strengthened.

Adds Pressure Stall Information (PSI) to the GC log along with other system metrics.

Enable elimination of safepoint pauses for finding deadlocks operations by first attempting to complete them using a checkpoint. If a deadlock is detected in the checkpoint, it is then confirmed using a safepoint pause.

Gathers all useful diagnostic logs into one folder for easier evaluation.

Enables writing system information headers (GCHS) in the garbage collection log file.

Enables a new Garbage Collector logging level used wherever the data collection or reporting has a noticeable overhead. This flag also enables PrintGCDetails which is the next lower logging level.

Lets tardy threads complete the checkpoint process by pausing active threads. See Troubleshooting Guide for suggestions on when to use this option.

Defines the threshold for triggering the promotion timeout. This flag has an effect when -XX:+PromoteCheckpoints is specified.

Sets time limit for ReadyNow to wait for compilations to finish at startup as specified in seconds. For infinite, use -1.

Allows for specifying explicitly the number of CPUs available for Zing. Works only with the container support (i.e., if -XX:-UseContainerSupport is not specified) and overrides the automatic CPU detection logic in the JVM.

Turns off using container-specific information about available CPUs instead of using the information about the whole system. Enabled by default.

Starting with Zing 18.07.0.0, Zing diagnoses licensing problems if run with -version option: it prints a warning and exits with an error code. If this option is specified together with -version, the JVM ignores licensing problems (specifically the warning is not printed) and exits with 0. Setting the ZING_DASH_VERSION_SILENCE_LICENSE_ERRORS environment variable has the same effect.

(Available since Zing 17.03.0.0; requires ZST 5.18.0 or later) The flag is needed for producing flame graphs with the Linux perf utility and for similar performance analysis tools which rely on stackwalking to record Java method invocations, the time percentage spent in them, and their use of Linux system function calls.

Turns the LLVM-based disassembler off. Starting with Zing 18.07.0.0, the default disassembler is changed from Zing internal to LLVM-based.

Changes disassembly syntax from AT&T to intel. This flag is diagnostic and must be preceded by -XX:+UnlockDiagnosticVMOptions.

Internally polls on a ReferenceQueue to determine if a key object has been garbage collected rather than polling by checking for NULL through the Reference.get() API, that can unintentionally prevent the weakly reachable key from being garbage collected. The flag is more friendly to garbage collectors that perform marking concurrently.

Indicates which version of arraycopy of objects intrinsic works with. When set to true, it stands for a new vectorized intrinsic version. When set to false, it stands for the old scalar version.

If `-Xnativevmflags:error is specified and Zing detects an option that it does not support, it does not launch and generates the following type of message:

HotSpot™ 64-Bit Tiered VM error: Unsupported native VM option ‘+UseParNewGC’

If -Xnativevmflags:warn is specified as a last option in the command line, it enables a warning message for each OpenJDK JVM option ignored by Zing. It prints a warning message while your application starts normally, for example:

$ /opt/zing/zing-jdk8/bin/java -XX:+UseParallelGC -Xnativevmflags:warn -version

Zing 64-Bit Tiered VM warning: Ignoring unsupported native VM option '+UseParallelGC'

java version "1.8.0-zing_18.12.0.0"

Zing Runtime Environment for Java Applications (build 1.8.0-zing_18.12.0.0-b4)

Zing 64-Bit Tiered VM (build 1.8.0-zing_18.12.0.0-b9-product-azlinuxM-X86_64, mixed mode)

Clears the signal mask to enable SIGQUITs when set to true.

Enables the use of extra threads for compilations for the Tier 2 compiler during the pre-main phase when ReadyNow triggers and executes different activities.

This option is complementary to CIMaxCompilerThreads.

In pre-main phase when your code is not yet being executed and GC is silent, the total amount of C2/Falcon compiler threads is equal to the sum of CIMaxCompilerThreads and ProfilePreMainTier2ExtraCompilerThreads. Note that the sum is capped to match the number of CPUs available for Zing on a machine.

When the pre-main phase is done (i.e., ProfileStartupLimitInSeconds is exhausted) and your main is started, the total amount of compiler thread goes back to standard CIMaxCompilerThreads.

When this option value is greater than 0, it allows ReadyNow to use multiple concurrent background threads to asynchronously trigger and execute different ReadyNow-related activities such as early class loading, class initializations, or trigger compilations.When the flag value is set to 0, old synchronous event’s triggering and/or processing is used.

The default value is equal to the minimum number of CPUs available for Zing on a machine.

Does error reporting for SIGABRT, SIGFPE, and SIGTRAP signals if there are no user defined handlers installed.

Enables effectively final optimizations for private fields which are initialized inside a constructor or class initializer, but are otherwise read only. The effectively final family of optimizations allows the VM to perform compiler optimization as if the fields were constants, but deoptimize if a later write is detected at runtime.

Enables the OpenJSSE provider that supports TLS 1.3, see https://github.com/openjsse/openjsse for details.

Enables the Legacy8uJSSE provider that includes the 8u252 JSSE provider implementation without TLS 1.3 support as a fallback measure, and the non-default OpenJSSE provider previously included in Zing 8 distributions for non-default support for TLS 1.3. See Using Version 1.3 of Transport Layer Security (TLS) Protocol for details.

Adjusts the maximum heap size (if not explicitly specified) based on the configured cgroup memory limit. If Xmx is not specified, the VM heap size limit is calculated as (MaxRAMPercentage / 100) * cgroups_limit.

Enables 64-bit alignment of the starting point of any array in the heap memory.

Specifies the size of raw x86 instructions to dump into hs_err file.

Selects the memory locking strategy during JVM initialization:

Note that for the mlock operation to succeed the user should have permission to lock the required amount of memory in RAM. Check the ulimit l setting before starting the JVM with the MlockLevel option. Only a privileged user can increase this limit.

By default, no error message is printed if the mlock operation fails. Adding 1000 to the values above results in the same operation performed with errors, if any, printed to stderr. For example, specifying -XX:MlockLevel=1001 will print a warning if locking libjvm.so text region fails but -XX:MlockLevel=1 will not.

Enables lock-less JNI transitions.

This flag needs a minimum of 4K available lockable memory to be enabled. Otherwise, the flag ergonomically resets to false.

Enables a newer Tier 2 compiler implementation introduced to Zing in 2020. It is based on a lightweight use of the LLVM backend, and typically produces faster code than UseSeaOfNodesC2 while keeping compilation effort at similar levels. UseKestrelC2 generally exhibits a significantly lower compilation-time CPU consumption compared to Falcon.

This option is complementary to UseC2.

Enables the traditional C2 implementation that has been part of Zing since 2010.

This option is complementary to UseC2.

Specifies the name of the total java heap pool only when GPGCShowJavaHeapPoolMXBean is enabled.

Specifies the name of the new generation in the java heap pool.

Specifies the name of the old generation in the java heap pool.

Specifies the name of the permanent generation in the java heap pool.

Enable the use of the custom implementation of RuleBasedCollator to improve performance over OpenJDK’s text collation and normalization.

Use unsynchronized ByteArrayInputStream if it is used as an input of ObjectInputStream as a custom implementation.

Consider CPU shares when computing available processors inside a cgroup.

Use CPU quota divided by period as base for calculating VM internal thread counts in containers.

Use CPU shares divided by 1024 as base for calculating VM internal thread counts in containers.

Defines the maximum number of memory pools available for glibc.

Enables an alternate implementation for System.identityHashCode() which provides better distribution of objects at the cost of making the identity hash calculation itself slower.

Prints additional information in thread dumps.

This option creates significantly smaller Zing core files. This option is specified through the Java application launch command and applied to the runtime Java application. It is not applied to the Zing host machine. When you use this option:

Enables speculative locking.

Enables (Restricted Transactional Memory) RTM heuristics.

Threshold value for RTM heuristics. If aborted or attempted transactions ratio goes beyond this limit for a monitor then speculation is disabled for that monitor.

Number of times speculation is attempted on a monitor, per lock acquisition. Fewer, or no attempts will be made if internal heuristic disables speculation on the monitor.

Specifies which Tier 2 compiler should be used. The default Tier 2 compiler is Falcon. To use the C2 JIT (available until release 24.02) instead of the Falcon JIT, run the following command:

$JAVA_HOME/bin/java -XX:-UseFalcon –cp . myprog

Controls the handling of a Tier 2 compiler specific flag used when the other compiler is active.

Controls the On Stack Replacement (OSR) functionality. It is not recommended to disable this option. If needed, disable it for only diagnostics purposes.

Changes the threshold at which the OSR is triggered – that is loop compilation by the Tier 2 compiler.

The value might be decreased to improve warm-up characteristics.

Threshold value for the Falcon JIT compiler. Replaces the identical option of the C2 compiler (-XX:C2CompileThreshold) which was available until release 24.02.

Sets the compile threshold for a particular method, used in the following way: -XX:CompileCommand="option,<Class>::<method>,FalconCompileThreshold=<threshold value>"

Disables Falcon and switches to the KestrelC2 compiler.

Specifies the highest supported AVX instructions set on x86/x64 CPUs.

This option is deprecated with no replacement starting with the release of Zing 20.02.0.0.

Switches back to the old implementation of the LLVM inliner instead of using a highly customized integrated inliner to perform inlining optimizations in Falcon compiles.

Controls the level of compiling optimization.

Suggested use: the default value is expected to fit most cases. However, if the CPU load at warmup is too high or warmup takes too long, there is a reason to try 1. The downside is that peak performance might be lower with that setting.

Accepts values from 0 to 3:

0 - minimal optimizations, lowest CPU consumption by Falcon (not recommended for production)

1 - reasonable optimizations and CPU time/warmup (good for production)

2 - aggressive optimizations, might expose high CPU utilization in some cases (default)

3 - turns on very aggressive optimizations known to cause long compilations and high CPU load at warmup. Ideally used with Cloud Native Compiler and ReadyNow to offset long compilation times.

Disables aggressive optimization of boxing types (integer, double, etc.). Should only be used for applications which are found to rely on implementation defined behavior as opposed to the specified behavior of boxing routines.

Specifies the method inlining detail level for performance profiling output of compiled code. Setting a lower level may help to reduce compiled code size by a few percent.

Accepts values from 0 to 2:

0 - no method inlining information is generated

1 - stack of inlined methods is generated only (default)

2 - stack of inlined methods with bytecode indices (bci) is generated

Introduces a nop padding based mitigation for performance regressions seen on some systems following Intel’s micro code updates in response to errata SKX102.

This option is expected to become the default in a future Zing release.

If enabled, nop padding is used to align affected branches on systems with the micro code update applied.

Forces generation of nop padded code on unaffected systems for performance validation.

Enables the optimization to eliminate redundant boxing conversions.

Enables a lock coarsening optimization for loops where the lock over a loop is coarsened. This is done by chunking the loop and coarsening the lock over the chunked loop.

Enables loop chunking by chunk size of 32 and performs lock coarsening over the loop. Additionally, enables lock coarsening over memory operations with monitor exit when valid to do so.

Enables Multi-Tiering, allowing Falcon to assign methods to more than just one Falcon optimization level, assigning methods for either mid-tier or final-tier compilation. Final-tier compilation uses the default Zing optimizations (usually Falcon optimization level 2) and mid-tier compilation uses Falcon optimization level 0.

Allows CNC and Falcon to share the same frontend, enabling the CNC UnifiedCompiler directly in the VM. Disabling this feature tells the VM to use only the local Falcon compiler.

Allows us to collect more information about a crashing compile to improve reproducibility outside of the VM. Additional information is collected only for the Unified Compiler Frontend.

Improves the quality of debug (DWARF) metadata received from the general assembly, which is beneficial for some diagnostic tooling.

Prints an assembly level profiling report at the end of a run. The value specifies the number of methods to be printed. A negative value prints all methods and setting the value to 0 disables the feature.

Enables CPU budgeting options for the Tier 2 compiler.

Defines the maximum number of threads which can be dedicated to the compiler.

Defines the maximum number of threads, as a percent, which can be dedicated to the compiler. The number of threads is rounded up to the nearest whole number. Use the option CompilerTier2BudgetingCPUPercent instead to use a fractional value.

Defines how many extra threads over CIMaxCompilerThreads the Tier 2 compiler can use during warmup, before the Main class in compiled. After warmup, the value of CIMaxCompilerThreads shall be respected.

Defines how many extra threads over CIMaxCompilerThreads the Tier 2 compiler can use during warmup, before Main class is compiled.

Defines how long the Tier 2 compiler warmup period shall be, in seconds.

Specifies the number of threads, as a percent, which can be used for Tier 2 compilation during warmup. The resulting value can be less than 1 thread or any other non-whole number of threads. The Tier 2 compiler waits for this percent of threads to be available before continuing. To use this option, you must have -XX:+EnableTier2CompilerBudgeting set to true.

Specifies the number of threads, as a percent, which can be used for Tier 2 compilation post warmup. To use this option, you must have -XX:+EnableTier2CompilerBudgeting set to true.

Specifies a window of time, in ms, in which the average CPU consumption of the compiler shall not exceed CompilerTier2BudgetingCPUPercent. To use this option, you must have -XX:+EnableTier2CompilerBudgeting set to true.

Previously TopTierCompileThresholdMs - Controls the triggering time limit (in ms) in which the method needs to reach the compile threshold in order to be queued for compilation. If the threshold is reached, but not within this time limit, the method is ignored and the timer starts over again.

This option assigns the same value to TopTierHotCompileThresholdTriggerMillis and TopTierWarmCompileThresholdTriggerMillis, creating a boundary between hot and cold ranks while eliminating the warm rank.

This option must not be set if you are using TopTierHotCompileThresholdTriggerMillis and TopTierWarmCompileThresholdTriggerMillis to specify hot, warm, and cold ranks.

Sets an upper bound for min-time-between-promotions for the hot rank and a lower bound for the warm rank. The upper bound for the hot rank is 1ms less than the value set.

Sets the upper bound for min-time-between-promotions for the warm rank and lower bound for the cold rank. The upper bound for the warm rank is 1ms less than the value set.

Specifies the percentage of CPU time from the total budget available to compiler threads that can be spent on warm rank compilation. hot ranks are given 100% and cold ranks are given 0%.

ProfileLogOut enables Zing to record compilations from the current run. <filename> is the name of the profile that the JVM reads as input to ReadyNow. If prefixed with cnc://, it will attempt to pull the profile from Cloud Native Compiler.

If ReadyNow is configured as a rolling profile (with ProfileLogIn equal to ProfileLogOut), The JVM creates a backup of the input profile at startup before the profile is being read into memory. Otherwise, the file will be overwritten.

ProfileLogIn allows Zing to base its decisions on the information from a previous run. The current ProfileLogIn file information will be read in its entirety - before Zing starts to create a new ProfileLogOut log. <filename> is the name of the profile that the JVM reads as input to ReadyNow. If prefixed with cnc://, it will attempt to pull the profile from Cloud Native Compiler.

Name of the profile that the JVM both reads from and writes to. If prefixed with cnc://, it will attempt to write from Cloud Native Compiler.

Replaces ProfileLogIn and ProfileLogOut. Can be used in place of -XX:ProfileLogIn=<profile1> -XX:ProfileLogOut=<profile1>

Dump input profile to the specified path. For debugging purposes only.

Dump output profile to the specified path. For debugging purposes only.

Specifies the maximum size that a ReadyNow profile log is allowed to reach. Units can be specified in kilobytes (K or k), megabytes (M or m), or gigabytes (G or g). Profiles will be truncated at this size, regardless of whether the application has actually been completely warmed up. It is recommended to either not set this size explicitly, or set it generously if required, for example:

-XX:ProfileLogMaxSize=1G

0 = unlimited

When used with Cloud Native Compiler, specifies the maximum generation of a profile that a VM will nominate. If ContinueRecordingAfterPromotion (CNC server-side parameter) is set to false (default), then the JVM will not output another generation after this limit has been reached. If ContinueRecordingAfterPromotion is true, the JVM will output another generation to Cloud Native Compiler but will never nominate it. These additional generations are for debugging and analysis only.

0 = unlimited

When used with Cloud Native Compiler, the minimum time, in seconds, a profile must record before CNC will nominate it as a candidate. If no -XX:ProfileLogOutNominationMinTimeSec is set, then the candidate is nominated by CNC when -XX:ProfileLogTimeLimitSeconds is reached.

0 = any duration eligible, -1 means it will never be promoted

Instructs ReadyNow to stop adding to the profile log after a period of N seconds regardless of where the application has been completely warmed up. It is recommended to either not set this size explicitly, or set it generously if required.

0 = unlimited

Timeout on establishing remote connection and timeout on interval between downloading two chunks. Specified in milliseconds.

Indicate to server that the produced profile is eligible for promotion after specified amount of bytes recorded.

0 = any size eligible, -1 means it will never be promoted

Enables logging of verbose, optional tracing information in -XX:ProfileLogOut

Enables periodic dumping of runtime bytecode profiling counters to the ReadyNow profile log at the interval specified, in seconds. If you set the option to 0, a dump occurs only on a graceful JVM shutdown.

Enables and disables profiling of processor core time spent between various software execution units (for example, threads, methods, and run-time tasks).

Due to known issues with version 3.10 and earlier Linux kernels, including those used in RHEL 7.x and CentOS 7.x, using +UseTickProfiler in production should be done with caution, as potential hangs may result under heavy loads.

Enables the JVM exit on the first occurrence of an out-of-memory error. Useful if you prefer restarting an instance of the JVM to handling out of memory errors.

Enables the JVM crash and produce text and binary crash files when an out-of-memory error occurs.

The Java Flight Recorder (JFR) is always available in Zing, this flag is not needed to use JFR.

This flag is useful only to prevent JFR from being activated by users or from within an application. That can be achieved by adding -XX:-FlightRecorder to the command line. It gives no performance benefit.

See Using Java Flight Recorder for details.

Starts a flight recording from the command line with recording parameters provided as a value for this option.

For example, -XX:StartFlightRecording=filename=myrecording.jfr starts a recording in the file system while -XX:StartFlightRecording=disk=false,filename=myrecording.jfr starts an in-memory recording. In both cases the result is written to the myrecording.jfr file at the end of the JVM session. For the description of additional Java Flight Recording (JFR) parameters refer to JFR resources available in the Internet.

Specifies additional parameters to configure Java Flight Recorder (JFR). For the description of additional JFR parameters refer to JFR resources available in the Internet.

Specifies the percentage amount of a live set to be described by recorded JFR events. To omit some minor events from the recording, change the value of this option to a smaller number, e.g., 90.

Enables Zing to use the Tick Profiler instead of the JFR Thread Sampler. When set to true, EventExecutionSample JFR events are generated from data provided by the Tick Profiler.

Controls the interval between consecutive polls for the new Tick Profiler samples to pass them to the JFR in-memory buffer. This option has an effect only when -XX:+UseTickProfilerAsJFRThreadSampler is specified.

The MemoryMXBean.getHeapMemoryUsage() method of MXBeans API returns the value of the Committed memory equal to the amount of JVM heap memory guaranteed as available for running an application (see Understanding Heap Memory Management for details). To switch to the old behavior of the MXBeans interface that returned the value of the Committed memory equal to Used memory, change the value of this option to true.

Changes garbage collector names returned by GarbageCollectorMXBean from GPGC to G1. To define exact New and Old GC names use -XX:GPGCNewGCMemoryManagerName="GPGC New" and -XX:GPGCOldGCMemoryManagerName="GPGC Old" respectively. This option provides a workaround for applications that do not recognize GPGC names such as Logstash.

Sets the name returned by GarbageCollectorMXBean for the New generation collector.

Sets the name returned by GarbageCollectorMXBean for the Old generation collector.

Makes Java heap reporting APIs and Tools include "non-object" use.

Lets APIs which report max heap capacity be aware of elasticity.