JavaFest. Вадим Казулькин. Projects Valhalla, Loom and GraalVM

NEW PROFESSIONAL JAVA EVENT KYIV, 2020
NEW PROFESSIONAL
JAVA EVENT
MARCH 21ST, 2020
KYIV, UKRAINE
Vadym Kazulkin
Projects Valhalla, Loom and GraalVM

Contact
Vadym Kazulkin, ip.labs GmbH
v.kazulkin@gmail.com
https://www.linkedin.com/in/vadymkazulkin/
@VKazulkin
Co-Org Java User Group Bonn and Serverless Bonn Meetup

ip.labs GmbH

Agenda
• Project Valhalla (Inline Types)
• Project Loom (Lightweight Threads and Continuations)
• GraalVM

Project Valhalla
Inline Types
Source: http://openjdk.java.net/projects/valhalla/

Inline types = Value types

Project Valhalla
Goal:
• Reboot the layout of data in memory
Source: Brian Goetz, Oracle „Evolving the Java Language” https://www.youtube.com/watch?v=A-mxj2vhVAA

Project Valhalla
Motivation:
• Hardware has changed
• Multi-core
• The cost of cache misses has increased
Source: Brian Goetz, Oracle „Evolving the Java Language” https://www.youtube.com/watch?v=A-mxj2vhVAA

Project Valhalla
Hardware Memory Model
Source: https://www.enterpriseai.news/2014/06/30/shared-memory-clusters-101/

Project Valhalla
Motivation
Source: „Latency Numbers Every Programmer Should Know”
https://people.eecs.berkeley.edu/~rcs/research/interactive_latency.html

Project Valhalla
Storing objects in the Java Heap has its price, because storing
object’s metadata consumes additional memory for :
• flags facilitating synchronization/locking
• Identity and polymorphismus
• garbage collection

Project Valhalla
Inline Types
Inline Type is an immutable type that is distinguishable only
by the state of its properties

Project Valhalla
Inline Types
Immutable: an instance of an inline-type can’t change, once it’s been
created
Identity-less: inline-types of the same type with the same contents are
indistinguishable from each other
Flattenable: JVMs are allowed to flatten an inline-type inside of its
container
Source: Tobi Ajila “Welcome to LWorld: The current state of value types in Java “
https://www.youtube.com/watch?v=Xf22I16jVyE&list=LLYgjRSI2oCzI9eooyFrWR7A&index=11

Project Valhalla
Source: „What Is Project Valhalla?” https://dzone.com/articles/what-is-project-valhalla

Project Valhalla
Benefits:
• Reduced memory usage
• Reduced indirection
• Increased locality
Codes like a class, works like a primitive (Brian
Goetz)

Project Valhalla
Benefit: Reduced Memory Usage
No additional memory to store object metadata, such as flags
facilitating synchronization, identity, polymorphismus and
garbage collection

Project Valhalla
Benefit: Reduced indirection
• Since objects are stored as reference types in Java, each time
an object is accessed it must first be dereferenced, causing
additional instructions to be executed
• The flattened data associated with inline types are immediately
present in the location in which they are needed and therefore,
require no dereferencing

Project Valhalla
Benefit: Increased locality
• Flattened value objects remove indirection which increases the
likelihood that values are adjacently stored in memory–
especially for arrays or other contiguous memory structures
such as classes (i.e. if a class contains inline type fields)
• Consequently increases the chance of cache hits, because of
hardware prefetch of the cache lines

Project Valhalla
Inline Types
inline class Point {long x, y ;}

Project Valhalla
Inline Types
Can
• have method and field
• implement interfaces
• use encapsulation
• be generic
Can’t
• be mutated
• be sub-classed
• be cloned
• be Enums

Project Valhalla
Inline Types Hierarchy
Object
Point?
Point
Nullable Inline Type (Point or null)
Inline Type

Project Valhalla
Inline Types Hierarchy
Object
Point?
Point
Nullable Inline Type (Point or null)
Inline Type
Object[]
Point?[]
Point[]

Project Valhalla
Current Status:
• Released public prototype LW2
• Can declare and use inline types (inline classes)
• No support for generics yet List<Point> // compilation error
• No support for specialized generics (Point<T>)
• No Support for migration of existing classes (like Optional)
• Memory Layout optimizations implemented
• Compiler/Virtual Machine optimizations implemented
• A lot of challenges to solve (read the article
https://www.infoq.com/news/2019/07/valhalla-openjdk-lw2-released/)
Source: Brian Goetz, Oracle „Valhalla Update” https://www.youtube.com/watch?v=1H4vmT-Va4o

Project Valhalla
Open Questions:
• Migration of existing classes (Option, LocaDateTime) to inline classes
• Nullity
• Equality
• GraalVM Support
• How Java type system should look like
Source: Brian Goetz, Oracle „Valhalla Update” https://www.youtube.com/watch?v=1H4vmT-Va4o

Project Valhalla
How Java type system should look like ?
Object
ValObject
Inline
Types
RefObject
References

Project Loom
Lightweight Thread and Continuations
Source: http://openjdk.java.net/projects/loom

Lightweight Threads = Fibers
Lightweight Threads = Virtual Threads in the
newest prototype?

Project Loom
Motivation:
Developers currently have 2 choices to write concurrent code:
• use blocking/synchronous API, which is simple, but less scalable (number of
threads, that OS supports is far less that open and concurrent connections
required)
• asynchronous API (Spring Project Reactor, RXJava 2), which is scalable, but
complex, harder to debug and profile and limited (no asynchronous JDBC
standard in this area)
Sources: Alan Bateman, Oracle „Project Loom: Fibers and Continuations for Java” https://www.youtube.com/watch?v=vbGbXUjlRyQ

Project Loom
Goal:
To write simple and scalable code

Project Loom
Lightweight Thread
Lightweight thread scheduled not by the OS, but by the Java Runtime
with low memory footprint and low task-switching cost

Project Loom
Continuation
Continuation is a program object, representing a computation that
may be suspended and resumed

Continuation
package java.lang;
public class Continuation {
public Continuation (ContinuationScope scope, Runnable target)
public final void run()
public static void yield (ContinuationScope scope)
public boolean isDone()
}

Project Loom
Continuations
example () {
var scope = new ContinuationScope(„Example_Scope“);
var continuation = new Continuation (scope, () -> {
out.print(„1“);
Continuation.yield(scope);
out.print(„2“);
out.print(„3“);
});
while (! continuation.isDone()) {
out.print(„ run.. “);
continuation.run();
}
}
Output: run.. 1 run.. 2 run.. 3

Project Loom
Lightweight Thread & Continuations
Thread
=
Continuation + Schedular

Project Loom
Schedular
Schedular executes the task on a pool of carrier threads
• java.util.concurrent.Executor API exposes the Schedular
• Default schedular is a ForJoinPool
Source: Alan Bateman, Oracle „Project Loom Update” https://www.youtube.com/watch?v=NV46KFV1m-4

Project Loom
Lightweight Thread Implementation
• Currently Thread and Lightweight Thread don’t have a common
supertype
• Thread.currentThread() in context of Lightweight Thread
• Creates adaptor (Shadow Thread)
• Adaptor emulates legacy Thread API (except deprecated methods like stop,
suspend and resume)
• Thread Local becomes Lightweight Thread Local

Project Loom
Structured Concurrency
Basic idea: Everytime that the control splits into multiple concurrent paths, we
want to guarantee that they join up again
try (var scope= ThreadScope. open()) {
scope.schedule(task1);
} //blocks until task1 and task2 terminate
Sources: Nathanial J. Smith „Notes on structured concurrency, or: Go statement considered harmful”
https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/
Roman Elizarov: “Structured concurrency with Coroutines in Kotlin” https://medium.com/@elizarov/structured-concurrency-722d765aa952

Project Loom
Structured Concurrency
Cancelation:
• Each Lightweight Thread has cancel status which can only be set once, which sets
the interrupt status and unparks the Lightweight Thread
• The task can poll canceled status
try (var scope= ThreadScope. open(PROPAGATE_CANCEL)) {
} //canceling the lightweight thread executing this code will task1 and task2

Project Loom
Lightweight Thread
Current Status:
• Lightweight Thread currently supports:
• scheduling
• parking/unparking
• waiting for a Lightweight Thread to terminate
• Lightweight Thread -friendly APIs
• java.util.concurrent Locks
• java.net.Socket/ServerSocket (since JDK 13)
• java.nio.channels.SocketChannel and Pipes (since JDK 11)
• Thread.sleep
• JSSE implementation of TLS
• AccessControl.doPrivileged (since JDK 12)
Source: Ron Pressler, Project Loom: Helping Write Concurrent Applications on the Java Platform
https://www.youtube.com/watch?v=lIq-x_iI-kc

Project Loom
Current Status:
• Implemented initial prototype with Continuation and Lightweight
Thread support
• Current prototype of Continuations and Lightweight Thread can run
existing code
• Debugger Support
Current focus on:
• Performance improvement
• Stable Lightweight Thread API
• Java Flight Recorder support

Project Loom
Limitations:
• Can‘t yield with native frames
Further Work:
• java.net.InetAddress
• Console I/O
• File I/O

Project Loom
Open Questions:
• Should the existing Thread API be completely re-examined?
• Can all existing code be run on top of Lightweight Threads?

Polyglot GraalVM
Source: http://openjdk.java.net/projects/metropolis

Project Metropolis
Goals:
• Low footprint ahead-of-time mode for JVM-based languages
• High performance for all languages
• Convenient language interoperability and polyglot tooling
Source: „Everything you need to know about GraalVM by Oleg Šelajev & Thomas Wuerthinger”
https://www.youtube.com/watch?v=ANN9rxYo5Hg

JEP 317
Experimental Java-Based JIT Compiler
Graal, a Java-based JIT compiler on the Linux/x64 platform, is the basis of the
experimental Ahead-of-Time (AOT) compiler introduced in JDK 9.
To Enable:
-XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler

GraalVM
Architecture
Sources: Practical Partial Evaluation for High-Performance Dynamic Language Runtimes http://chrisseaton.com/rubytruffle/pldi17-
truffle/pldi17-truffle.pdf
„The LLVM Compiler Infrastructure“ https://llvm.org/

GraalVM
Benchmarks
Sources: Renaissance Suite https://renaissance.dev/

GraalVM
libgraal Library
Sources: „libgraal: GraalVM compiler as a precompiled GraalVM native image“
https://medium.com/graalvm/libgraal-graalvm-compiler-as-a-precompiled-graalvm-native-image-26e354bee5c
libgraal jargraal
• libgraal is a shared library, produced by GraalVM Native Image with a pre-compiled
version of the GraalVM compiler
• In Java applications on GraalVM libgraal used as the top tier Just-In-Time compiler
• libgraal improves startup

SubstrateVM
Source: Oleg Šelajev, Thomas Wuerthinger, Oracle: “Deep dive into using GraalVM for Java and JavaScript”
https://www.youtube.com/watch?v=a-XEZobXspo

GraalVM and SubstrateVM
Source: Oleg Selajev, Oracle : “Run Code in Any Language Anywhere with GraalVM” https://www.youtube.com/watch?v=JoDOo4FyYMU

GraalVM on SubstrateVM
A game changer for Java & Serverless?
Cold Start :
Source: Ajay Nair „Become a Serverless Black Belt” https://www.youtube.com/watch?v=oQFORsso2go

AWS Lambda cold start time
by supported language
Source: Yan Cui: https://read.acloud.guru/does-coding-language-memory-or-package-size-affect-cold-starts-of-aws-lambda-a15e26d12c76

Java Function compiled into a native executable using GraalVM on
SubstrateVM reduces
• “cold start” times
• memory footprint
by order of magnitude compared to running on JVM.
And both memory and execution time are cost dimension, when using
Serverless in the cloud

Current challenges native executable using GraalVM :
• Most Cloud Providers (AWS) doesn’t provide GraalVM as Java Runtime
out of the box, only Open JDK (e.g. AWS provides Corretto)
• Some Cloud Providers (AWS) provide Custom Runtime Option
• Docker Image with GraalVM instead of Open JDK
• Frameworks like Micronaut and Quarkus which provide tooling for generating
Custom Runtime for cloud providers

GraalVM Complitation Modes

AOT vs JIT

Support of GraalVM native images in Frameworks
• Spring Framework: working toward GraalVM native image support without
requiring additional configuration or workaround is one of the themes of
upcoming Spring Framework 5.3
• Spring Boot: Ongoing work on experimental Spring Graal Native project. Probably
ready for the 2.4 release
• Quarkus: a Kubernetes Native Java framework developed by Red Hat tailored for
GraalVM and HotSpot, crafted from best-of-breed Java libraries and standards.
• Micronaut: a modern, JVM-based, full-stack framework for building modular,
easily testable microservice and serverless applications.
Source: „GraalVM native image support“ https://github.com/spring-projects/spring-framework/wiki/GraalVM-native-image-support

GraalVM Current State

is still an interesting and great
programming language

www.iplabs.de
Thank You!

JavaFest. Вадим Казулькин. Projects Valhalla, Loom and GraalVM

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a JavaFest. Вадим Казулькин. Projects Valhalla, Loom and GraalVM

Similar a JavaFest. Вадим Казулькин. Projects Valhalla, Loom and GraalVM (20)

Más de FestGroup

Más de FestGroup (10)

Último

Último (20)

JavaFest. Вадим Казулькин. Projects Valhalla, Loom and GraalVM