Release Notes of Azul Zulu Prime Stream and Stable Builds of OpenJDK

Azul Zulu Prime 23.02.0.0 contains the General Availability (GA) release of Azul Prime Builds of OpenJDK 19 for x86_64 systems.

Cloud Native Compiler (CNC) 1.6.1 client support.

NativeMemoryTracking has been extended with further Falcon tracking support.

To enable "extended tracking," set LD_PRELOAD=$JAVA_HOME/etc/zing/lib/libnmt_hooks.so in addition to regular NMT flags which are described in Native Memory Tracking Options and in the Oracle documentation.

Azul Zulu Prime 23.02.0.0 introduces new CPU budgeting features for the Falcon Tier 2 compiler. CPU Budgeting tells the Tier 2 compiler when to run and how many CPU threads to use, pre and post warmup.

With these new features, it is possible to specify allocated threads as a percent, meaning the compiler and the running application can share resources, resulting in less pauses and more stability for the running application. Previously, only whole numbers of threads could be allocated.

To enable these new features, use the argument -XX:+EnableTier2CompilerBudgeting.

New Falcon CPU Budgeting features are listed in Command Line Options, CPU Budgeting Options

A new command line option, AllocCodeCacheInLower2G has been introduced and is set to true by default. This option allocates code cache and related data structures at virtual address within 2 GB. To allow allocation to higher memory addresses, use -XX:-AllocCodeCacheinLower2G. This option is only available for x86_64 systems.

Lower GC pauses with JVMTI - JVMTI tag map clearing has been moved outside of safepoint pause by default. This is set by the command line argument ConcurrentJVMTITagMapClearing and is set to true by default.

Falcon improvement - Register allocation enhancement that improves code generation for derived pointers around GC safepoints. This allows derived pointers to rematerialize immediately before their use instead of after every safepoint. This is beneficial when a pointer is live across many statepoints but has few uses.

Allocation publication barrier optimizations for Aarch64 in Falcon. Testing has yielded up to an 8.5% performance improvement from this optimization.

The output format for -Xlog:safepoint has been changed to match OpenJDK for JDK13 and above.

There are no new issues to report in this release.

January 2023 CPU and PSU release security fixes.

There are no new issues to report in this release.

Internal bug fixes.

January 2023 CPU and PSU release security fixes.

Cloud Native Compiler (CNC) 1.6 client support.

You can now read and write ReadyNow profile logs to Cloud Native Compiler. This simplifies getting ReadyNow profile logs in and out of containers and other environments without persistent storage.

Compile stashing has been disabled by default, even when using ReadyNow.

Existing ReadyNow users that want to maintain the same compile stashing behavior as in earlier releases should ensure the -XX:+FalconUseCompileStashing flag is set.

Users who wish to use compile stashing with the new Profile Log Service must ensure both +FalconUseCompileStashing and +CNCForceLocalCompiler flags are set.

FalconContextReset is now set using ergonomics heuristic based on the number of Falcon compiler threads, unless specified explicitly. Falcon compiler threads reset the internal caches after every FalconContextReset number of compilations. This is a tradeoff between compilation speed and memory consumption. The more often the caches are reset, the less memory is consumed but more time is spent rebuilding the caches.

Currently, the value of FalconContextReset is chosen as FalconContextResetFactor=<number of Falcon threads> nested between FalconContextResetLowerLimit and FalconContextResetUpperLimit.

There are no new issues to report in this release.

Azul Zulu Prime 22.12.0.0, through various changed and updates, has been able to achieve 10% lower GC CPU usage on Cassandra.

Azul Zulu Prime 22.12.0.0 lowers the amount of GC pauses with hidden classes.

Falcon has been improved for Jackson as well as other optimizations to the Falcon JIT compiler.

New JMX MXBean metrics replace old metric name below java.lang.GarbageCollector to increase accuracy for GC monitoring added with JDK-8265136: Previously, metric "GPGC New/Old" was providing a sum of GC pauses and concurrent GC duration. This metric is replaced by the following:

There are no new issues to report in this release.

There are no resolved issues to report in this release.

October 2022 CPU and PSU release security fixes

Compatibility with Cloud Native Compiler (CNC) version 1.5

Support for the GA release of Azul Vulnerability Detection (AVD).

Changes for containers regarding thread pool size calculation and number of available CPUs.

With the October 2022 release of Java 11 and 17, the default calculation of available CPU cores will change, following JDK-8281181. Previously, the number of available CPU cores was in some situations calculated based on the lower bound defined in the environment. With the change in this release, the lower bound won’t be used anymore and the calculation will only be based on the upper limit of the environment. If in container-based systems no upper limit is defined, the total number of CPUs on the host machine is read as upper limit.

A situation where a change will occur is, for example, a Kubernetes container where neither CPU requests nor CPU Limits are set, as previously the JVM would select only 1 CPU core as available in this situation while after the chance, it will select all available CPU cores of the environment which can lead to higher resource usage as thread pools of various open source frameworks are using this calculation for sizing. To verify if your systems are effect, check especially those where no upper limit is defined.

In case you need to switch back to the previous calculation, add -XX:+UseContainerCpuShares to the Java command line.

Other terms used in the context of CPU definitions are for lower bound "CPU Requests" or "cgroups cpu.shares", and for upper limit "CPU Limits" or "cgroups cpu.cfs_quota_us".

When both quota and shares are specified for a cgroup and UseContainerCpuShares is true, the number of GC and compiler threads are derived based on a total processor count calculated as (quota+shares)/2. When UseContainerCpuShares is false the number is derived based on a total processor count calculated as (quota/2).

To check the current setting, for example, to compare previous and current Java versions in your environment, use the following example to display the actual number of CPUs as seen by application code and run it inside your container environment:

File AvailableCPUs.java:

 
public class AvailableCPUs {
    public static void main(String[] args) {
        System.out.println("CPUs: "
            + Runtime.getRuntime().availableProcessors());
    }
}

To run it:

 
java -showversion AvailableCPUs.java

There are no new issues to report in this release.

ZVM-25268 - As a part of the PSU update, UseContainerCpuShares has been set to false (off) by default.

ZVM-22642 - The GC log now reports data from remote compilations which can be viewed in GC Log Analyzer.

Internal bug fixes.

Improved accuracy of RSS metric reported in GC log (C heap usage). With this improvement, the reported memory usage in GC log will give more accurate results.

The Allocation Pacing feature is turned on by default in non-ZST mode. This will help reduce peak allocation delays while introducing smaller delays into allocation paths as heap usage approaches the total Java heap committed. To turn off the feature use -XX:-GPGCUseAllocationPacing.

There are no new issues to report in this release.

There are no resolved issues associated with this release.

Internal bug fixes.

ZVM-24576 - New feature, Allocation Pacing, to help protect against long allocation delays. When enabled, the virtual machine adds smooth delays to allocations as the heap usage approaches the maximum. This new feature helps prevent long allocation delays caused by memory exhaustion and helps the garbage collector keep up. To enable the feature, use -XX:+GPGCUseAllocationPacing, available in non-ZST mode only.

ZVM-24277 - Implemented StringUTF16.compress

There are no new issues to report in this release.

Internal bug fixes.

There are no new issues to report in this release.

July 2022 PSU release fixes.

ZVM-24301 - New command line option UseContainerCpuShares, default true, to consider CPU shares when computing available processors inside a cgroup. This option was backported from OpenJDK 17 and it is important to note that while OpenJDK has a default value of false, the default value in Azul Platform Prime is true.

There are no resolved issues associated with this release.

Internal bug fixes.

Internal bug fixes.

There are no new issues to report in this release.

Internal bug fixes.

Arm64 is now supported by Azul Zulu Prime JVM. Find the latest builds for Arm64 here:

There are no resolved issues associated with this release.

There are no new issues to report in this release.

April 2022 CPU and PSU security fixes.

Enable elimination of safepoint pauses for finding deadlocks operations by first attempting to complete them using a checkpoint using the option -XX:[+/ -]OptimizeFindDeadlocksWithCheckpoint. If a deadlock is detected in the checkpoint, it is then confirmed using a safepoint pause.

There are no new issues to report in this release.

Internal bug fixes.

There are no new issues to report in this release.

Miscellaneous bug fixes and performance improvements.

There are no resolved issues to report in this release.

There are no new issues to report in this release.

Missing fixes from the January 22 PSU release of OpenJDK.

January 2022 PSU release security fixes.

Various performance improvements.

There are no resolved issues to report in this release.

There are no new issues to report in this release.

Small critical bug fixes over Azul Platform Prime 22.01.0.0.

January 2022 PSU release security fixes.

Various performance improvements.

There are no resolved issues to report in this release.

There are no new issues to report in this release.

January 2022 PSU release security fixes.

Various performance improvements.

There are no new issues to report in this release.

Photon OS is now supported.

Improved performance of string collation and character iteration. You can enable the use of the custom implementation of RuleBasedCollator using the option -XX:+UseModifiedRuleBasedCollator. This option is false by default.

Docker images for Prime are now available.

Azul Platform Prime 21.10.1.0 contains the same features as 21.10.0.0.

Includes all October 2021 CVE fixes.

Azul Platform Prime 21.10.0.0 contains the October 2021 CPU release of OpenJDK. Azul Platform Prime 21.10.0.0 brings the associated JDK 7, JDK 8, JDK 11, JDK 13, and JDK 15 versions to October 2021 CPU security update levels.

The peak heap occupancy target, used by heuristics to decide when to trigger a garbage collection, is now managed dynamically by default. The dynamic changes can be disabled by setting GPGCTargetPeakHeapOccupancyPercent to a desired value.

Increased parallelism between collectors for the new generation and old generation. Helps reduce the peak duration for a new generation collection and reduce allocation delays during peak load.

The number of concurrent GC threads is now changed dynamically when -Xms is set to the same value as -Xmx, or when Azul Zulu Prime System Tools (ZST) is installed. At JVM start a low number of concurrent GC threads is employed. If later during application uptime the GC Time Percent metric increases beyond a threshold, more GC threads are added to reduce the number of GC cycles. The limit for the total number of GC threads is 3/4 of the process' available CPU threads. As of this Prime version, the number of threads will never shrink later.

To disable the dynamic handling, use the following on the command line: -XX:-UseDynamicNumberOfGCThreads

If one of the following flags is set on the command line, the dynamic handling will also be disabled:

General performance improvements.

More intrinsics from Java 17.

Initial support for Cloud Native Compiler. Cloud Native Compiler provides a server-side optimization solution that offloads JIT compilation to dedicated hardware, providing more processing power to JIT compilation while freeing your client JVMs from the load of doing JIT compilation.

General performance improvements.

General performance improvements.

GC log line has been expanded to include additional information for heap elasticity.

Introduces a new JFR event named "Deoptimization" which arises when previously compiled code gets discarded. The event is useful in troubleshooting performance issues including low throughput and high CPU utilization.

Improved performance with large Java heaps on Intel Ice Lake systems with 5-level page tables.

Introduces support for Intel’s Ice Lake 5-level paging.

Support for dynamically varying garbage collector thread counts with the GPGCDynamicGCThreadCountPolicy option. See command line options for more details.

Incorporates all of the changes from the July 2021 CPU release and most of the changes from the July 2021 PSU release.

Various performance improvements including improved locking, stack-walking behavior for performance.

Loop unrolling improvements.

Java heap elasticity is turned on by default when not using the Prime System Tools (ZST). This means that -Xms is now recognized along with -Xmx. The default values also match OpenJDK. For latency sensitive applications it is advised to set -Xms equal to -Xmx to preserve the old behaviour. See Recommended Heap Size for more details.

Additional improvements of the Heap Elasticity feature introduced in 21.05.0.0. Improved memory allocation handling in Heap Elasticity mode to avoid exceeding the container/cgroups memory limit.

Fixed many issues with Async Profiling.

Various performance improvements with Falcon compiler:

A fix for bug ZVM-20496 which turns opt-boxing-rewrite-loads off by default to avoid miscompiles in certain code patterns.

Non-ZST Heap Elasticity introduced. See Recommended Heap Size for details. When heap elasticity is enabled, the Garbage Collector tries to minimize the memory footprint, keeping it between the user- defined range of -Xms and -Xmx. At the same time, the CPU usage of the Garbage Collector is monitored and the memory minimizing goal relaxed in case the CPU usage increases too much. Heap Elasticity is not available when Azul Zulu System Tools (ZST) is installed.

Azul Platform Prime 21.05.0.0 makes the OpenJDK C1 OSR the default OSR for the Falcon compiler. The C1 OSR takes much less time and CPU resources to fully optimize your code to steady-state performance.

Stream Builds (previously known as Feature Releases) are now free for use in development and evaluation. As such, the builds no longer check for an evaluation license.

Latency improvement for applications with frequent Unsafe.get() and put() calls.

Fixed heap dump compatibility issue that prevented opening Azul Zulu Prime head dumps in IntelliJIdea.

Enabled jcmd ManagementAgent command option support.

April 2021 CPU and PSU fixes.

Quicker acquisition of transparent huge pages on Ubuntu, Amazon Linux or similar Linux systems with kernel 4.19.7 or newer in non-ZST mode. This can help get peak performance earlier as well as enable faster java process restart when THP is configured.

Default value of Xmx in cgroups is now the minimum of 25% of cgroup memory limit and 32 GB. Prior to 21.04.0.0, it was 25% of cgroup memory limit.

Reduced code cache usage for applications with high number of classes or interfaces and a large number of associated methods.

Enhanced Compatibility With Data Management Platforms

ZVM 21.03.0.0 improves compatibility between the MXBean memory pool names and names expected by in- memory data management systems (e.g., Pivotal GemFire 8.2).

JFR Event Streaming allows to asynchronously subscribe to select JFR events and avoid the overhead associated with creating a recording in JDK 15.

Various performance improvements, like enhancements to tracking of garbage-collection roots, compiler optimizations for aggressive lock coarsening, and an experimental ReadyNow! mode that enables the pre-initialization of a greater number of bootstrap classes.

Introduces medium-term support (MTS) for Java Standard Edition 15. See Azul Product Support Lifecycle for more information.

Additional non-security changes associated with the January 2021 Patch Set Updates (PSU) OpenJDK 7u292, OpenJDK 8u282, OpenJDK 11.0.10, OpenJDK 13.0.6 and OpenJDK 15.0.2 release contents.

Load value barriers for reference equality checks are optimized within loops. Azul Zulu Prime JVM also optimizes more such checks aggressively by considering both operands of the equality check.

Improved object locking with better monitor inflation behavior.

The functionality of UseCodeCacheFlushing is offered under UseIncrementalCodeCacheFlushing in Azul Zulu Prime JVM 21.02.0.0. However, Azul Zulu Prime JVM has emergency code cache flushing turned on by default, see UseEmergencyCodeCacheFlushing in Using Azul Zulu Prime JVM Command-Line Options for details.

Early-access support for ReadyNow! Image, an experimental warm-up optimizer based on ReadyNow! and Linux Checkpoint/Restore In Userspace (CRIU).

Azul Zulu Prime JVM 21.02.0.0 installation contains ReadyNow! Image files in the /etc/rni/ directory: ` `criu libnet.so.1 libnl-3.so.200 libprotobuf-c.so.1 restore-script wait-script

Azul Zulu Prime JVM 21.02.0.0 includes optional experimental support for interaction with connected runtime services through an emerging protocol in Azul Zulu Prime JVM 13. Note that for Azul Zulu Prime JVM 8 and Azul Zulu Prime JVM 11 this support was introduced in Azul Zulu Prime JVM 21.01.0.0.

Azul Zulu Prime JVM 21.02.0.0 installation contains the following files related to the services:

C2 Improvement

The default JIT compiler on Azul Zulu Prime JVM JDK 8 and JDK 7 is changed from SeaOfNodesC2 to KestrelC2 when the Azul Zulu Prime JVM C2 mode is enabled with -XX:+UseC2.

For Azul Zulu Prime JVM JDK 11, this improvement was made in Azul Zulu Prime JVM 20.04.0.0.

KestrelC2 is a C2 implementation introduced to Azul Zulu Prime JVM 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.

See Using Azul Zulu Prime JVM Command-Line Options for -XX:[+/-]UseKestrelC2 and -XX:[+/-]UseSeaOfNodesC2 command-line options and details.

The default JIT compiler in Azul Zulu Prime JVM is the high-performance Falcon introduced in 2017.

New Experimental Features

Azul Zulu Prime JVM 21.01.0.0 includes optional experimental support for interaction with connected runtime services through an emerging protocol in Azul Zulu Prime JVM 11 and Azul Zulu Prime JVM 8.

These experimental capabilities are enabled by the ‑XX:+UseCRS command-line option and turned off by default. Being an experimental Azul Zulu Prime JVM option, it must be unlocked by preceding ‑XX:+UnlockExperimentalVMOptions.

Performance Improvement

Azul Zulu Prime JVM 21.01.0.0 introduces an improved escape analysis for arrays in the Falcon compiler.

The improvement includes an optimization for array reallocation pattern (e.g., java.util.Arrays.copyOf) to avoid redundant copying. Notably, this optimization improves the performance of string concatenation using the StringBuilder class by the elimination of excessive reallocations of the underlying StringBuilder buffer.

Support for EdDSA Signature Algorithm

Azul Zulu Prime JVM 21.01.0.0 introduces the OpenEdDSA provider which can be used for cryptographic signatures using the Edwards-Curve Digital Signature Algorithm (EdDSA) in Azul Zulu Prime JVM 8 with no application or code changes. See JEP 339: Edwards-Curve Digital Signature Algorithm (EdDSA) for details.

The OpenEdDSA public API is provided in the org.openeddsa.java.security.interfaces and org.openeddsa.java.security.spec packages.

To enable the OpenEdDSA provider, do either of the following:

Azul Zulu Prime JVM 20.12.0.0 incorporates additional non-security changes associated with the October Patch Set Updates (PSU) 2020 OpenJDK 7u285, OpenJDK 8u275, OpenJDK 11.0.9.1, and OpenJDK 13.0.5.1 release contents.

Azul Zulu Prime JVM 20.12.0.0 introduces an enhanced induction variable analysis and range checks removal mechanism. Particularly, improved range check elimination capabilities for decrementing loops of the following type:

 
for (int i = array.length - 1; i >= 0; i--) {
array[i] = ...
}

Azul Zulu Prime JVM 20.10.0.0 brings the associated JDK 7, JDK 8, JDK 11 and JDK 13 versions to October 2020 Critical Patch Update (CPU) security update levels and incorporates changes related to OpenJDK 7u281, OpenJDK 8u271, OpenJDK 11.0.8.0.101, and OpenJDK 13.0.4.0.101 release contents.

Azul Zulu Prime JVM 20.10.0.0 includes loop form fixes to increase performance of loops by simplified triggering of enabled vectorization methods. The optimization is enabled by default.

Azul Zulu Prime JVM 20.10.0.0 contains an improved allocation mechanism which has a positive impact on the Azul Zulu Prime JVM's performance. The optimization is enabled by default.

Azul Zulu Prime JVM 20.10.0.0 introduces method counters across JVM runs, which enables ReadyNow! to build a profile over multiple short runs when the number of orders is low.

Azul Zulu Prime JVM 20.09.0.0 introduces Medium Term Support for Java SE 13. See Azul Product Support Lifecycle for more information.

Azul Zulu Prime JVM 20.09.0.0 includes accelerated copying of large array chunks. The optimization is enabled by default. See UseArrayCopyChunkingIntrinsics in Using Azul Zulu Prime JVM Command-Line Options for details.

Azul Zulu Prime JVM 20.09.0.0 provides a performance improvement for org.apache.logging.log4j.util.StackLocator.getCallerClass(), which maximizes logging performance when using log4j versions 2.13.1 - 2.13.3 on Azul Zulu Prime JVM 8 and log4j versions 2.9.0 - 2.13.3 on Azul Zulu Prime JVM 11+. The improvement is disabled by default. See UseLog4jGetCallerClassIntrinsic in Using Azul Zulu Prime JVM Command-Line Options for details.

Azul Zulu Prime JVM 20.09.0.0 introduces unified Garbage Collection (GC) logging that utilizes unified JVM logging framework (JEP 271: Unified GC Logging). See Unified GC Logging Recommendations to learn more.

Azul Zulu Prime JVM 20.08.0.0 incorporates additional non-security changes associated with the July Patch Set Updates (PSU) 2020 OpenJDK 7u272, OpenJDK 8u265, and OpenJDK 11.0.8 release contents.

NONEwithDSAinP1363Format is included in signature algorithms enabled in Azul Zulu Prime JVM 20.08.0.0 by default. NONEwithDSAinP1363Format is scheduled for removal in the following release of the Azul Zulu Prime JVM Virtual Machine. Since the algorithm is not supported in other JDK 8 virtual machines, it is recommended to migrate to Digital Signature Algorithms with ASN.1 encoded signature bytes.

Azul Zulu Prime JVM 20.08.0.0 introduces multiple optimizations that significantly increase performance on a set of Java Stream API scenarios.

Azul Zulu Prime JVM 20.08.0.0 introduces a new version string format that includes a matching OpenJDK release number.

Version 1 of the GC Log Analyser has reached its end-of-life and is removed from Azul Zulu Prime JVM 20.08.0.0. Version 2 of the GC Log Analyzer is available for download at https://cdn.azul.com/gcla/GCLogAnalyzer2.jar.

Azul Zulu Prime JVM 20.07.0.0 brings the associated JDK 7, JDK 8, and JDK 11 versions to July 2020 Critical Patch Update (CPU) security update levels and incorporates changes related to OpenJDK 7u271, OpenJDK 8u261, and OpenJDK 11.0.7.0.101 release contents.

The lock-less Java Native Interface (JNI) protocol is enabled by default in Azul Zulu Prime JVM 20.07.0.0. See Using Azul Zulu Prime JVM Command-Line Options for the UseThreadStateNativeWrapperProtocol option and details.

Azul Zulu Prime JVM 20.07.0.0 introduces optimization in object allocation (internal new_stub() function) for improved performance in TLAB allocation intensive applications. The optimization is enabled by default.

Starting with Azul Zulu Prime JVM 20.07.0.0, Azul Zulu Prime JVM 8 supports TLS 1.3 by default and follows the application programming interface (API) changes introduced by Maintenance Release 3 to the Java SE 8 specification.

The release of Azul Zulu Prime JVM 20.06.0.0 includes ReadyNow! improvements for faster warmup and smaller footprint.

Azul Zulu Prime JVM 20.06.0.0 introduces a JNI exception checking optimization. See Using Azul Zulu Prime JVM Command-Line Options for the UseFastJNIExceptionCheck option and details.

Azul Zulu Prime JVM 20.06.0.0 provides full elasticity support for code cache. See Using Azul Zulu Prime JVM Command-Line Options for the InitialCodeCacheSize, ReservedCodeCacheSize, and CodeCacheOopTableSize options and details.

Azul Zulu Prime JVM 20.06.0.0 includes a further improvement of JDK 11 java.lang.StackWalker which is frequently used by log4j2 and other logging implementations. See also https://openjdk.java.net/jeps/259 and java.lang.StackStreamFactory$AbstractStackWalker.

Azul Zulu Prime JVM 20.06.0.0 introduces new diagnostic Java Flight Recorder (JFR) events to simplify error handling.

The lock-less Java Native Interface (JNI) protocol is disabled by default. See Using Azul Zulu Prime JVM Command-Line Options for the UseThreadStateNativeWrapperProtocol option and details.

In Azul Zulu Prime JVM 20.05.0.0, the Java Flight Recorder Tick Profiler becomes enabled by default.

In Azul Zulu Prime JVM 20.05.0.0, Java monitors are moved from CodeCache to a new dedicated MonitorCache storage.

The release of Azul Zulu Prime JVM 20.05.0.0 includes optimizations targeted at accelerating compilation and warmup.

Azul Zulu Prime JVM 20.05.0.0 introduces better JDK 11 java.lang.StackWalker which is frequently used by log4j2 and other logging implementations. See also https://openjdk.java.net/jeps/259 and java.lang.StackStreamFactory$AbstractStackWalker.

Azul Zulu Prime JVM 20.05.0.0 provides a reduction of application exit times in the non-ZST mode when a process uses mlockall().

Azul Zulu Prime JVM 20.05.0.0 improves the mitigation strategy used by the Falcon compiler to minimize performance impacts due to Intel's microcode updates in response to Jump Conditional Code (JCC) Erratum SKX102. Previous versions inserted nop instructions for padding; the new version can optionally increase the size of existing instructions in some cases. As before, the mitigation is enabled only on affected processors, and no user action is needed.

Azul Zulu Prime JVM 20.05.0.0 introduces a testing grace period mode, under which the Azul Zulu Prime JVM can run for up to 60 minutes (3600 seconds) without requiring a valid license. The testing grace period can be enabled by setting the ZING_TESTING_GRACE_PERIOD_SEC environment variable to a number of grace period seconds (up to 3600), or by using the -XX:ZVMTestingGracePeriodSec=N flag with a similar value.

The release of Azul Zulu Prime JVM 20.04.0.0 contains April 2020 critical patch update (CPU) security and critical bug fixes and brings the associated JDK 7, JDK 8, and JDK 11 versions to April 2020 CPU security update levels.

Azul Zulu Prime JVM 20.04.0.0 incorporates additional non-security changes associated with the April PSU 2020 OpenJDK 8u252 and OpenJDK 11.0.7 release contents.

Starting with Azul Zulu Prime JVM 20.04.0.0, the -XX:+UseC2 option can use one of two separate implementations of C2 JIT compilation: a traditional UseSeaOfNodesC2 mode and a new UseKestrelC2 mode.

The new mode is selected with +UseKestrelC2 which is on by default for Azul Zulu Prime JVM 11 and off by default for Azul Zulu Prime JVM 8 and Azul Zulu Prime JVM 7. This mode enables a C2 implementation introduced to Azul Zulu Prime JVM 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.

The old mode is selected with +UseSeaOfNodesC2 which is off by default in Azul Zulu Prime JVM 11 and on by default for Azul Zulu Prime JVM 8 and Azul Zulu Prime JVM 7.

See Using Azul Zulu Prime JVM Command-Line Options for UseKestrelC2 and UseSeaOfNodesC2 command-line options and details.

Azul Zulu Prime JVM 20.04.0.0 introduces a compilation time improvement.

The release of Azul Zulu Prime JVM 20.04.0.0 introduces an increased maximum Java heap size from 1 TB to 2.5 TB in the default non-ZST mode.

The maximum Java heap size for the Azul Zulu Prime JVM Virtual Machine with ZST is 20 TB.

In Azul Zulu Prime JVM 20.04.0.0, a new Java Flight Recorder functionality allows you to collect profiling data about applications that use JNI invocations.

The release of Azul Zulu Prime JVM 20.04.0.0 includes optimizations targeted at reducing JNI transition costs. The cost of a native call from Java was reduced, and the implementation of the accessor functions used to retrieve fields of Java objects from native code was also improved. Most applications will not be affected, but applications with many native transitions (such as a socket or file IO) may see the marked improvement.

See Using Azul Zulu Prime JVM Command-Line Options for UseFastJNIAccessors, UseMembar, and UseThreadStateNativeWrapperProtocol command-line options and details.

Azul Zulu Prime JVM 20.04.0.0 excludes debug symbols embedded in libjvm.so, which reduces the filesystem footprint of a Azul Zulu Prime JVM installation by 280 MB.

Contact [email protected] if you need to install debug symbols for the Azul Zulu Prime JVM.

The release of Azul Zulu Prime JVM 20.03.0.0 introduces the elimination of redundant boxing conversions and the optimized copying of HashSets.

Internal bug fixes and stability improvements.

January 2020 PSU Release.

This version incorporates additional non-security changes associated with the PSU 2020 OpenJDK 8u242 and OpenJDK 11.0.6 release contents.

Deprecation of FalconUseLegacyInliner

The FalconUseLegacyInliner command-line option is deprecated in Zing 8 and 11 with no replacemen.

January 2020 CPU Release.

InZVM20.01.0.0, -XX:+FalconCompensateForIntelMCUForErratumSKX102 is an off-by-default option and introduces a nop padding based mitigation for performance regressions seen on some systems following Intel’s microcode updates in response to errata SKX102. This option is expected to become the default in a future Zing release. If enabled, nop padding will be used to align affected branches on systems with the microcode update applied.

For testing purposes, the flag -XX:+ForceFalconCompensateForIntelMCUForErratumSKX102 is also provided. This can be used to force the generation of nop padded code on unaffected systems for performance validation.

Internal bug fixes.

There are no new issues to report in this release.

January 2023 CPU release security fixes.

There are no resolved issues associated with this release.

There are no new issues to report in this release.

Internal bug fixes.

Backport issue ZULU-39745 - Support custom security providers in Azul Zulu Prime builds of JDK17.

The Java launcher can be updated to easily configure and enable custom security providers:

There are no new issues to report in this release.

Internal bug fixes.

October 2022 PSU release security fixes

Important information regarding Java in containers (Docker, Kubernetes, and related) about automatic thread pool size calculation and number of CPUs available to the application:

While in the general October 2022 release of Java 11 and 17, the default calculation of available CPU cores has changed in container environments following JDK-8281181, this change wasn’t made in the Azul Platform Prime stable release 22.08.200.0 to allow seamless transition from previous stable versions.

That means, Azul Platform Prime 22.08 differs in this aspect from current OpenJDK. In practical use, this difference will only affect those situations where a new migration from OpenJDK to Prime 22.08 is started. If you notice your application performance being affected during such a transition from OpenJDK to Prime 22.08 add -XX:-UseContainerCpuShares to the Java command line to switch Azul Platform Prime to the same new calculation method as OpenJDK.

To check your environment in general about this change, independent of whether it is running on OpenJDK or Azul Platform Prime, run the following command inside your container to display the actual result of the available CPU number calculation:

Save the following code to file AvailableCPUs.java:

 
public class AvailableCPUs {
    public static void main(String[] args) {
        System.out.println("CPUs: "
            + Runtime.getRuntime().availableProcessors());
    }
}

Run it:

 
java -showversion AvailableCPUs.java

There are no new issues to report in this release.

Internal bug fixes.

There are no new issues to report in this release.

There are no resolved issues associated with this release.

October 2022 CPU release security fixes.

There are no resolved issues associated with this release.

There are no new issues to report in this release.

Internal bug fixes.

Improved accuracy of RSS metric reported in GC log (C heap usage). With this improvement, the reported memory usage in GC log will give more accurate results.

There are no resolved issues associated with this release.

There are no new issues to report in this release.

October 2022 CPU release security fixes

Internal bug fixes.