This document summarizes Projects Valhalla, Loom and GraalVM. Project Valhalla aims to introduce inline types (value types) to Java to improve performance by reducing memory usage and indirection. Project Loom introduces virtual threads and continuations to allow writing scalable and asynchronous code more easily. GraalVM is a high-performance polyglot virtual machine for Java and other languages.

1. Projects Valhalla, Loom and GraalVM
JCON2020#
www.jcon.one
Vadym Kazulkin, ip.labs
Our Partners 2020:

2. Contact
Vadym Kazulkin
ip.labs GmbH Bonn, Germany
Co-Organizer of the Java User Group
Bonn and Serverless Bonn Meetup
v.kazulkin@gmail.com
@VKazulkin
@ServerlessBonn (Meetup)
https://www.linkedin.com/in/vadymk
azulkin/
https://www.iplabs.de/

3. ip.labs GmbH
https://www.iplabs.de/

4. Agenda
Project Valhalla (Inline Types)
Project Loom (Virtual Threads and Continuations)
GraalVM

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

6. Inline types = Value types

7. 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

8. 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

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

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

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

12. 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

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

14. 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

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

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

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

18. 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

19. 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

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

21. 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
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

22. Project Valhalla
Inline Types Hierarchy
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
Object
Point?
Point
Nullable Inline Type (Point or null)
Inline Type

23. Project Valhalla
Inline Types Hierarchy
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
Object
Point?
Point
Nullable Inline Type (Point or
null)
Inline Type
Object[]
Point?[]
Point[]

24. 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

25. 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

26. Project Valhalla
How Java type system should look like ?
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
Object
ValObject
Inline
Types
RefObject
References

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

28. Virtual Threads = Fibers=Lightweight Threads

29. 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

30. Project Loom
Goal:
To write simple and scalable code

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

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

33. 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()
}

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

35. Project Loom
Virtual Thread & Continuations
Thread
=
Continuation + Schedular

36. 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

37. Project Loom
Virtual Thread Implementation
Currently Thread and Virtual Thread don’t have a common
supertype
Thread.currentThread() in context of Virtual Thread
• Creates adaptor (Shadow Thread)
• Adaptor emulates legacy Thread API (except deprecated methods like stop, suspend and
resume)
• Thread Local becomes Virtual Thread Local
Source: Alan Bateman, Oracle „Project Loom Update” https://www.youtube.com/watch?v=NV46KFV1m-4

38. Project Loom
Virtual Thread Implementation
Thread t = Thread.startVirtualThread (() -> {
System.out.println(„Hello World“);
});
Thread t = Thread.builder().virtual().task( () -> { … }).build();
Thread t = Thread.builder().virtual().task( () -> { … }).start();
ThreadFactory factory = Thread.builder().virtual().factory();
Source: Ron Pressler: “Project Loom: Modern Scalable Concurrency for the Java”
https://www.youtube.com/watch?v=23HjZBOIshY
https://cr.openjdk.java.net/~rpressler/loom/loom/

39. Project Loom
Structured Concurrency
Basic idea: Everytime that the control splits into multiple concurrent
paths, we want to guarantee that they join up again
ThreadFactory factory = Thread.builder().virtual().factory();
try (var executor= Executors.newThreadExecutor(factory)) {
executor.submit(task1);
executor.submit(task2);
} //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-

40. Project Loom
Structured Concurrency
Cancelation probable solution:
Each Virtual Thread has cancel status which can only be set once, which
sets the interrupt status and unparks the Virtual Thread
The task can poll canceled status
ThreadFactory factory = Thread.builder().virtual().factory();
try (var executor= Executors.newThreadExecutor(factory),
PROPAGATE_CANCEL) {
executor.submit(task1);
executor.submit(task2);
} //canceling the virtual thread executing this code will task1 and task2
Source: Ron Pressler: “Project Loom: Modern Scalable Concurrency for the Java”
https://www.youtube.com/watch?v=23HjZBOIshY
https://cr.openjdk.java.net/~rpressler/loom/loom/

41. Project Loom
Structured Concurrency
Cancelation :
We can also give all tasks a deadline that will interrupt those children that
have yet to terminate by the time it expires (as well as the current thread)
ThreadFactory factory = Thread.builder().virtual().factory();
try (var executor= Executors.newUnboundedExecutor(factory).
withDeadline(Instant.now().plusSeconds(60))) {
executor.submit(task1);
executor.submit(task2);
}
Source: Ron Pressler: “Project Loom: Modern Scalable Concurrency for the Java”
https://www.youtube.com/watch?v=23HjZBOIshY
https://cr.openjdk.java.net/~rpressler/loom/loom/

42. Project Loom
Virtual Thread
Current Status:
Virtual Thread currently supports:
• scheduling
• parking/unparking
• waiting for a Virtual Thread to terminate
Virtual 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

43. Project Loom
Current Status:
• Implemented initial prototype with Continuation and Virtual
Thread support
• Current prototype of Continuations and Virtual Thread can run
existing code
• Debugger Support
Current focus on:
• Performance improvement
• Stable Virtual Thread API
• Java Flight Recorder support
Source: Alan Bateman, Oracle „Project Loom Update” https://www.youtube.com/watch?v=NV46KFV1m-4

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

45. Project Loom
Open Questions:
Should the existing Thread API be completely re-examined?
Can all existing code be run on top of Virtual Threads?
Current answers:
• Since Java 5 and 6 developers and library creators are encouraged
to use Executors and ThreadFactory APIs instead of Thread directly
• In order to use Virtual Thread instead of Thread another Executor
implementation must be chosen
ThreadFactory factory = Thread.builder().virtual().factory();
//ThreadFactory factory = ThreadFactory.builder().factory();
Executor executor= Executors.newThreadExecutor(factory);

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

47. 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

48. 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

50. 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/

51. 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/

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

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

54. Creating AWS Lambda with Java 1/2
:
Source https://blog.runscope.com/posts/how-to-write-your-first-aws-lambda-function

55. Creating AWS Lambda with Java 2/2
:
Source https://blog.runscope.com/posts/how-to-write-your-first-aws-lambda-function

56. 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

57. Bootstrap the Java Runtime Phase
• AWS Lambda starts the JVM
• Java runtime loads and initializes
handler class
• Static initializer block of the handler class is
executed
• Lambda calls the handler method
Vadym Kazulkin @VKazulkin , ip.labs GmbH
Source: Stefano Buliani : "Best practices for AWS Lambda and Java„ https://www.youtube.com/watch?v=ddg1u5HLwg8

58. AWS Lambda cold start duration
per programming language
Source: Mikhail Shilkov: „AWS Lambda: Cold Start Duration per Language. 2020 edition” https://mikhail.io/serverless/coldstarts/aws/languages/

59. Cold start duration with Java
• Below 1 second is best-case cold start duration for very simple
Lambda like HelloWorld with no dependencies
• It goes up significantly with more complex scenarios
• Dependencies to multiple OS projects
• Clients instantiation to communicate with other (AWS) services (e.g. DynamoDB,
SNS, SQS, 3rd party)
Source: Stefano Buliani : "Best practices for AWS Lambda and Java„ https://www.youtube.com/watch?v=ddg1u5HLwg8
Sean O‘Toole „AWS Lambda Java Tutorial: Best Practices to Lower Cold Starts” https://www.capitalone.com/tech/cloud/aws-lambda-java-tutorial-reduce-cold-starts/

60. GraalVM on SubstrateVM
A game changer for Java & Serverless?
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 dimensions,
when using Serverless in the cloud

61. GraalVM on SubstrateVM
A game changer for Java & Serverless?
Current challenges with 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 (e.g. AWS) provide Custom Runtime Option

62. GraalVM Complitation Modes
Source: „Everything you need to know about GraalVM by Oleg Šelajev & Thomas Wuerthinger”
https://www.youtube.com/watch?v=ANN9rxYo5Hg

63. AOT vs JIT
Source: „Everything you need to know about GraalVM by Oleg Šelajev & Thomas Wuerthinger”
https://www.youtube.com/watch?v=ANN9rxYo5Hg

64. 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

65. is still an interesting and great
programming language

66. Thank You !
JCON2020#
www.jcon.one
Our Partners 2020: