Oleg Šelajev is a developer advocate at Oracle Labs working on GraalVM -- the high-performance embeddable polyglot virtual machine. He organizes VirtualJUG, the online Java User Group, and a GDG chapter in Tartu, Estonia. In 2017 became a Java Champion.
In this talk we would like to give you a short overview of GraalVM and then move on to why the GraalVM JIT compiler is so fast / efficient, and where it really excels.
We will show some examples that will allow us to take a look at the internal IR graph that GraalVM uses to generate native code.
You'll learn about some of the most important optimisations in the GraalVM compiler
And finally we would like to talk about what it is about GraalVM that lends itself to being improved - and as an example of this we will look at some recent improvements.
GraalVM often shows the best results on a variety of Java workloads. Even more so for the JVM languages like Scala and Clojure and others.
While it's not necessary to understand how the JIT compilers work, or the particular optimizations to use the fastest runtime you can (you just need to measure and assess your options carefully), it's a very interesting topic that can be educational to Java developers.
You'll learn which code patterns get optimized well or not, you'll learn some patterns where GraalVM compiler completely outclasses its competition, and will be able to recognize them in the code you write.
You'll also get a better idea what C2 -- the default top tier JIT compiler in OpenJDK does for those code patterns and if needed could maybe use that information to manually optimize code for it.
In this session we'll talk about the performance boost you can get from running your code on GraalVM, look at the examples of running typical web-applications with it, enhancing them with code in other languages, creating native images for incredibly fast startup and low memory overhead for your services.
GraalVM offers you the opportunity to write the code in the language you want, and run the resulting program really fast.
In this session we will discuss the best practices for Java code and compiler configurations to maximize performance with GraalVM and how to measure performance in a reliable manner. We will talk about how to achieve minimal memory footprint and binary size of GraalVM native images — programs compiled ahead of time to native executables. A comparison of profile-guided optimizations for ahead-of-time compilation and just-in-time compilation will show the benefits and drawbacks of the two approaches. After this session you will have a better idea how to use GraalVM for the maximum potential to run your applications faster!
Workshop, attendees should bring their own computers and can try GraalVM themselves
GraalVM is a high-performance polyglot runtime for dynamic, static, and native languages. Among other things it can compile Java applications ahead-of-time to native binaries which start up really fast, are immediately ready to do useful work, and have much lower memory usage than a typical Java apps. As in milliseconds to start and run well with just a few MB of memory. This ability makes GraalVM ideal runtime for deploying Java applications to the cloud, autoscale to 0, or Function as a Service environments where otherwise you'd think it's a bit awkward to use Java.
You will learn how to use GraalVM as a platform for your cloud Java deployments: building native binaries, profiling your code for the best AOT compilation results, configuring resource consumption based on the best practices and historic data, and reducing the container startup overhead for ultimately fast startup.
In this session we'll talk about building Java microservices that start instantly and have a low memory footprint, which makes them perfect for the cloud services. They can be built using GraalVM — a high-performance runtime, that can run your Java applications and also generate native executables ahead of time.
We'll show how to get started with GraalVM, share some experiences with frameworks that work with GraalVM native image well, and talk about optimizing performance of native images. You'll learn what runtime performance you can expect from native images and how to make the very best of them, configure runtime memory usage and GC options, profile-guided optimizations and so on. All to be ready to use GraalVM as the platform for your cloud deployments.