A New GraalVM Release and New Free License!

For Native Image, in this release we are introducing:

Now let’s look closer at each of those performance metrics.

Native Image is known for the fastest application startup times. Thanks to additional compiler optimizations with Oracle GraalVM, startup goes to the next level:

Thanks to additional memory optimizations, our benchmark application built with Oracle GraalVM Native Image uses significantly less memory:

The peak throughput of Oracle GraalVM Native Image here is 1.6x higher than GraalVM CE. For this specific application, the throughput is still slightly below JIT. When running other benchmarks with Spring, as well as Quarkus and Micronaut, in many cases we see AOT even ahead of JIT for peak throughput.

Another metric important to evaluate for your application is efficiency: how much performance you can get for a given amount of time and resources. This is especially relevant for the cloud, where you pay for resources and how long you are using them, but even on-prem you want to use your infrastructure efficiently. To evaluate this, let’s look at how many requests our application can process per GB of memory per second (see the chart above):

This means that with Oracle GraalVM Native Image you can get the best peak throughput for the infrastructure you have, or run with good performance even in resource-constrained environments.

Now let’s look into latency distributions. Latency is a critical metric that reflects the responsiveness of all requests of your application. The slowest requests are visible in the tail latency distribution and impact greatly the quality of service. Usually, business requirements mandate a specific latency limit for most of the requests (typically 99%, i.e. the P99 latency).

Here we see that up until the 95th percentile Oracle GraalVM Native Image and CE JIT with C2 have very similar response times under 3 ms. This means that you can expect the same responsiveness of your application with Native Image as with JIT. However, the highest percentiles degrade significantly on the JIT while they stay low with Native Image. So for this application Native Image provides a significantly better P99 latency, and therefore improved responsiveness of the service.

In summary, Oracle GraalVM Native Image provides excellent performance characteristics for long-running applications in addition to fast startup and low resources usage.

We’ve also been working on many new features in this release. Since we have so many updates, we have two blog posts: this one focuses on GraalVM JDK and Native Image, and we have another for GraalVM languages and Truffle updates.

Now let’s see what else is new in this release!

GraalVM now has a new naming scheme that is aligned with JDK versioning — for example, this release includes two GraalVM versions: GraalVM for JDK 17 and GraalVM for JDK 20. Both versions are based on the main branch and contain new features, so you can choose the JDK version that works best for you. However, we encourage you to move to JDK 20 — as we announced some time ago, we are transitioning to a new release schedule, in which we’ll release GraalVM only for the latest Java version (just like Oracle JDK does). This way you can also use all the latest Java and GraalVM features together.

Another great update in this release is that the GraalVM JDK download now includes Native Image! No need to download Native Image as a separate component or run gu install native-image — it’s ready from the get-go.

One of the exciting new features in this release is machine-learning-based profile inference. Native Image now uses a pre-trained ML model to predict the probabilities of the control flow graph branches. Then, we use the predicted probabilities to perform PGO. In our measurements on a comprehensive set of benchmarks such as Renaissance, Da Capo, and Da Capo con Scala, PGO powered by the predicted profiles provides ~6% runtime speedup compared to the default Native Image configuration. ML-based profile inference is available in Oracle GraalVM, enabled by default, and we are looking forward to your feedback and performance reports.

However, remember that ML profile inference might slightly increase the size of the native executable file by 1–2%.

One of the ways a compiler can provide better performance is by leveraging the architecture-specific features of your deployment platform. Using those specific features is great for performance, but may pose compatibility challenges when deploying on machines without those specific instructions. We introduced a new -march option, similar to gcc, that gives you the flexibility to choose between platform-specific performance and compatibility: -march=compatibility for best compatibility, or -march=native for best performance if the native executable is deployed on the same machine architecture or on a machine with the same CPU features. To list all available machine architectures, use -march=list.

We’ve also made several changes to profile-guided optimizations:

The Native Image build command (native-image -jar MyApp.jar) may look simple on the surface, but it initiates a complex build process with many variables and properties that depend on the environment. It would be very helpful to be able to replicate a build — for example, for updating and patching your applications, or reproducing issues. For that purpose, this release introduced Native Image Bundles. Now you can produce a build bundle that contains a JAR file of your application along with information about arguments, environment variables, system properties settings, classpath and module-path options. To produce a bundle, use the — bundle-create=<imagename>.nib flag when building a native executable. This will produce the actual executable just like before, along with a <imagename>.nib file and the <imagename>.output directory. Having those files available, you can then reproduce the build by running the following:

Bundles should simplify updating Native Image deployments and help with debugging and reproducing issues. Give this feature a try and let us know what you think!

Native Image now can generate build reports that help you better understand the contents of your executables. The build reports come in HTML format and provide insights into the following:

Use -H:+BuildReport to try this new experimental feature.

With every release we are introducing updates to make the developer experience with GraalVM, and in particular Native Image, more smooth and streamlined. There are several changes in this release:

And for the GraalVM languages and Truffle updates, please navigate to the related blog post.

— the GraalVM team

Related posts:

Ubiloan. Decentralized service that will allow you to take credit on the pledge of your gaming and metaverse NFT. Today I will tell you how you can get started (it’s very simple). **We are talking…

Who Buys Equipment? Whether it’s running or not, Buy Your Equipment buys used equipment all around the United States and Canada. Trucks, tractors, motor graders, dozers, skid steers, backhoes…

The Mars explorer Nozomi passed 1,000 km from the Hells Angels DILLIGAF Support81 Shirt of Mars. The Venus Climate Orbiter Akatsuki entered Venus orbit in a second attempt on 7 December 2015, making…