Project Valhalla

.jpg

https://horstmann.com/presentations/2024/valhalla

Slide navigation: Forward with space bar, →, or swipe left. Backwards with ← or swipe right. Switch slides with PgDn and PgUp.

OpenJDK Projects

.jpg

Amber: Programmer productivity
- Records
- Pattern matching
- String templates
Loom: Virtual threads
Panama: Foreign functions/memory
Leyden: Improve startup time
Valhalla: Value types

Values and References

.jpg

Ever since Java 1.0: Eight primitive types byte short int long float double boolean char
Everything else is a reference type
Different in so many ways:
- Primitive types are “flat”—no indirection
- And “dense”—no headers
- == compares primitives by value, not identity
- Primitives can't be null ⭐
- Initialized with zero bits (0 or false) ⭐
- Longer primitives can tear ⭐

Flatness and Density

Why Do We Care?

.jpg

Would like class instances that are like primitives
Codes like a class, acts like an int
Performance benefits
- Memory savings
- Better locality
- Less GC work
More intuitive == semantics:
```
Point p = ...
if (p == origin)
```
Avoid painful wrappers: Function<Integer, Boolean> vs. Predicate<Integer> vs. IntFunction<Boolean> vs. IntPredicate

Value Classes

.jpg

Value class gives up identity
==, hashCode derived from fields, not address

Fields are implicitly final:

public value class Point {
   private double x; // final
   private double y; // final
   ...
}

JVM may (but doesn't have to) optimize layout/performance

Many value classes will be records:

public value record Point(double x, double y) {
   public Point moveBy(Point other) { return new Point(x + other.x, y + other.x); }
}

Value Equality

.jpg

In Java, x == y tests whether x and y are references to the identical object
Except for primitive types (or one primitive and one boxed value)...

Value types act like primitive values:

Point p, q;
...
if (p == q) // Checks p.x == q.x && p.y == q.y

Works with nested value classes:

value record Circle(double radius, Point center) {}
Circle c, d;
...
if (c == d) // Checks c.radius = d.radius, c.center == d.center

Analogous to recursive equals in records
Technical wrinkle: Floating-point comparison will likely use compare, not ==, different for ±0, NaN

Casting to Object does not check reference identity:

Point p = new Point(3, 4), q = new Point(3, 4);
p == q // true
Object op = p, oq = q;
op == oq // true

Candidates for Value Classes

.jpg

Numeric types: longer long and double, short float, unsigned, complex numbers
Mathematical constructs: geometric shapes, measurements
Currency values
Date and time
Optional, Either, Try
Pairs, ranges
Tuples
Records
Internal classes for the JDK, e.g. for deconstruction

Value vs. Identity Classes

.jpg

“Classic” class/record is identity class
Cannot extend concrete value class

Both value and identity classes can extend abstract value class:

abstract value class JSONValue { ... }
abstract value class JSONPrimitive extends JSONValue { ... }
value record JSONNumber(double value) extends JSONPrimitive { ... }
class JSONObject extends JSONValue { ... } // identity class

Abstract value class can have fields
Value class can implement interfaces
Value class cannot extend identity class
Exception: Object is an identity class, but value classes extend it
Value classes cannot have synchronized methods

Value Object Construction

.png

Classic construction sequence:
- Call super(...)
- Set fields
Inverted for value objects
Assignment to fields in “larval stage”, before super()
Advantage: Another thread can't read partially initialized object
With JEP 482, field assignment before super possible for arbitrary classes

Required for value classes with explicit super call:

public value class LocalizedMessage extends Localized {
   private String message;
   public LocalizedMessage(String message, Locale locale) {
      this.message = message;
      super(locale);
   }
   ...
}

Null-Restricted Types

.jpg

Value type instances can be null:
```
Point target = null; 
```
Flattened layout needs a bit for nullness
Null-restricted type: Value class type that can't be null:
```
Point! origin = new Point(0, 0); // Syntax may change
```
Compiler forbids null assignment:
```
origin = null; // Compile-time error
```

Also run-time check:

Point![] path = new Point![NPOINTS];
Object[] objs = path;
objs[0] = null; // NullPointerException

Conversions

.jpg

T! is not a subtype of T, but conversions are ok in both directions.

Widening conversion: Null-restricted type to unrestricted type (or supertype):

Point! origin = new Point(0, 0);
Point p = origin; // Widening conversion
Object o = origin; // Ok, also widening conversion
p = null; // Ok, doesn't change origin

Narrowing conversion is checked at runtime:

origin = p; // NullPointerException
origin = (Point!) o; // Narrowing conversion. maybe NPE
origin = (Point) o; // Same

Works with arrays:

Point![] path = new Point![NPOINTS];
Object[] objs = path; // Ok, even if unsound
objs[0] = "Fred"; // ArrayStoreException
objs[0] = null; // NullPointerException

Circular Data Structures

.png

Linked list node:

public value class Node {
   private Object data;
   private Node next;
   public Node(Object data, Node next) { this.data = data; this.next = next; }
   ...
}

Can it be flattened?
```
   private Node! next;
```
Surely this can't work!
Value class cannot have null-restricted field of its own type
Why allow circularity at all? Small win for flattening nodes on the stack

Reflection and Erasure

.webp

Null restrictions are erased at runtime
No separate Point!.class

Can reflectively check restrictions:

var path = new Point![100];
CheckedType type = Array.getComponentType(path);
type.cast("Fred"); // ClassCastException
type.cast(null); // NullPointerException

Can use checked type to create new instances:

var cloud = (Point[]) Array.newInstance(type, NPOINT);
cloud[0] = null; // NullPointerException

Zero Instances

.jpeg

Primitive types have defaults with all-zero bits: 0, 0.0, '\0', false
For field/array initialization, need a default for (non-null) value type
Zero bits default not appropriate for all value classes, e.g. LocalDate

Class opts in like this: (Syntax may change)

value record Point(double x, double y) {
   public implicit Point();
}

Non-static Inner class can't have an implicit constructor
Can only form type T! when T has implicit constructor

Enhanced Primitive Boxing

.jpg

Goal: Make primitive types more like other value types

Methods can be applied without explicit boxing:

int n = 42;
String hex = n.toHexString();
   // i.e. Integer.valueOf(n).toHexString()
var signs = Stream.of(1, -4, 0).map(0::compareTo).toList();
   // i.e. Integer.valueOf(0)::compareTo

Same with primitive types:

int.MAX_VALUE
   // i.e. Integer.MAX_VALUE
"Hello 🇧🇬".codePoints().map(char::charCount).toArray()
   // i.e. Character::charCount

Covariant Arrays

.webp

With conversions between int and Integer!, what about arrays?

Integer! digits = new Integer![]{ 3, 1, 4, 1, 5, 9}; // A flattened array
int[] intDigits = digits; // The same array, but accessed with different byte codes

Conversion to reference type:

Object[] objs = digits; // An array of references
objs = intDigits; // used to be illegal

Details need work
Not easy for int to be Integer!

Return Overriding, Type Arguments

Can override boxed with primitive type:

class Die extends Supplier<Integer> {
   int get() { return 1 + (int) (6 * Math.random()); }
      // i.e. Integer get() { ... }
}

Overriding primitive with boxed is ok too, but not so interesting
Can use primitive type parameters:

class Die extends Supplier<int>
   // i.e. Supplier<Integer!>

For a while longer, List<int> still uses boxing.

Atomic Updates

.jpg

References, primitive types ≤ 32 bits are updated atomically
64 bit primitives long, double may tear
Another thread may read half-updated value
Tearing more likely for longer flattened values
By default, value type updates are atomic

Must opt in to avoid synchronization cost: (Syntax may change)

value record Point(double x, double y)
   implements LooselyConsistentValue {}

Users of the class may need to use locks or volatile fields

Migration

.jpeg

Standard library classes considered as value classes even though not so declared:
- Wrappers Integer, Double, etc.
- Optional
- Record
Wrappers and Optional are deemed to have an implicit constructor
Consider migrating immutable classes that describe “just data”
Also abstract classes with “just data” subclasses
Keep the rules for value class inheritance in mind
Be sure that == and hashCode reflect field-based value semantics
Is there a security impact? Can field values be compromised?
No synchronized

Generics

.jpg

Should ArrayList<int> use int or Object bytecodes?
Array creation for int[] or Integer![] is different than for Object[]
Is List<int> a subtype of the raw List or wildcard List<?> type?
Constraining to value types? (Optional<T!>)
get method of Map<String, int> can't return null

Overloading:

static <T extends Comparable<? super T>> void sort(T[] a)
static void sort(int[] a)

Universal generics first, then specialized generics

History Notes

.jpg

Valhalla was born ten years ago (July 10, 2014)
There used to be different bytecodes for references L and values Q—no more
There used to be special bytecodes withfield and defaultvalue—no more
Surface syntax has changed many times, e.g. inline classes
value class seems here to stay
So does Point! for null-restricted types
Syntax for accepting zero defaults, tearability still in flux
Generics are work in progress—perhaps type variables T!, T?, T*

Building Valhalla

.jpg

Currently outdated build on https://jdk.java.net/valhalla/
No need to build for simple experiments—use the sandbox https://javaalmanac.io/jdk/valhalla/

Easy to build on Linux:

git clone https://github.com/openjdk/valhalla/
cd valhalla
bash configure

Install any missing packages
Run
```
make images
```
The JDK build is in valhalla/build/linux-x86_64-server-release/images/jdk

Running Valhalla

.webp

value class syntax is supported

Be sure to enable preview:

javac --enable-preview --source 23 ...
java --enable-preview ...
jshell --enable-preview

Need annotations in jdk.internal.vm.annotation package for “phase 2” features
@NullRestricted on a field (instead of !)
@ImplicitlyConstructible on a value type (instead of implicit constructor)
@LooselyConsistentValue on a value type (instead of marker interface)
jdk.internal.value.ValueClass lets you construct null-restricted arrays

To access internals::

javac -add-exports java.base/jdk.internal.vm.annotation=ALL-UNNAMED \
  --add-exports java.base/jdk.internal.value=ALL-UNNAMED ...
java --add-exports java.base/jdk.internal.value=ALL-UNNAMED ...

Easy thing to try: Brownian motion—repeatedly move Point by random amount (Code)

Benchmarking

.webp

Use JMH (Java Microbenchmark Harness)

mvn archetype:generate \
  -DinteractiveMode=false \
  -DarchetypeGroupId=org.openjdk.jmh \
  -DarchetypeArtifactId=jmh-java-benchmark-archetype \
  -DgroupId=com.horstmann \
  -DartifactId=valhalla-benchmark \
  -Dversion=1.0

In POM, add this inside configuration of maven-compiler-plugin:

<compilerArgs>
   <arg>-verbose</arg>
   <arg>--enable-preview</arg>
   <arg>-proc:full</arg>
   <arg>--add-exports</arg>
   <arg>java.base/jdk.internal.vm.annotation=ALL-UNNAMED</arg>
</compilerArgs>

Compile and run:

mvn clean install
java --enable-preview -jar target/benchmarks.jar

Embarrassingly good result:

Benchmark                         Mode  Cnt      Score      Error  Units
c.h.novalhalla.Benchmark1.work    avgt   25  34819.177 ± 4295.566  us/op
c.h.withvalhalla.Benchmark1.work  avgt   25      0.004 ±    0.001  us/op

More normal

Benchmark                         Mode  Cnt      Score      Error  Units
c.h.novalhalla.Benchmark3.work    avgt   25  47725.264 ± 6597.810  us/op
c.h.withvalhalla.Benchmark3.work  avgt   25  24847.389 ± 3120.296  us/op

Code

JIT Code Disassembly

.png

Download hsdis-amd64.so from https://www.chriswhocodes.com/hsdis/ into lib directory
Set environment variable
```
export LD_LIBRARY_PATH=lib
```

Run with these flags:

-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly \
-XX:+LogCompilation -XX:LogFile=logfilename

View the logs with JITWatch

java --enable-preview -jar jitwatch-ui-1.4.9-shaded-linux-x64.jar

Click Open Log, then Start
Opcodes at https://shell-storm.org/x86doc/

Memory Consumption

.jpg

Sleep after allocating value objects/arrays:

Point[] path = (Point[]) ValueClass.newNullRestrictedArray(Point.class, 100_000_000);
for (int i = 1; i < path.length; i++) {
   path[i] = path[i - 1].transform();
}
System.out.println(path[path.length - 1]);
Thread.sleep(60_000);

Run the program, then

jcmd withvalhalla.Points GC.class_histogram | head

Sample output:

num     #instances         #bytes  class name (module)
-------------------------------------------------------
   1:             1     1600000016  [Lwithvalhalla.Point;

Flat array with 200_000_000 double

Conclusion

.jpeg

After ten years of prototyping, value types may come to a JVM near you real soon now
Some workloads will see significant performance improvements
Even more when flattening works with null restrictions
Primitive types will be approximated by null-restricted wrappers
Conversion/overloading rules will get (even more) complex, but most programmers won't need to care
Generics will come in stages
Still a way to go before List<int> is backed by an int[]
When value types come, benchmark to see if they are for you

Q&A

.jpg

Project Valhalla

OpenJDK Projects

Values and References

Flatness and Density

Why Do We Care?

Value Classes

Value Equality

Candidates for Value Classes

Value vs. Identity Classes

Value Object Construction

Null-Restricted Types

Conversions

Circular Data Structures

Reflection and Erasure

Zero Instances

Enhanced Primitive Boxing

Covariant Arrays

Return Overriding, Type Arguments

Atomic Updates

Migration

Generics

History Notes

Building Valhalla

Running Valhalla

Benchmarking

JIT Code Disassembly

Memory Consumption

Further Reading

Conclusion

Q&A