The new JEP 434 has just seen daylight and describes the second preview of the ”Foreign Function & Memory API” (or FFM for short) which is going to be incorporated in the upcoming Java 20 release! In this article, we will take a closer look at some of the improvements made from the first preview that debuted in Java 19 via the older JEP 424.
Getting familiar with the FFM
This article assumes you are familiar with the FFM API. If not, you can get a good overview via the new JEP
Short Summary
Here is a short summary of the FFM changes made in Java 20 compared to Java 19:
The MemorySegment and MemoryAddress abstractions are unified (memory addresses are now modeled by zero-length memory segments);
MemorySession has been split into Arena and SegmentScope to facilitate sharing segments across maintenance boundaries.
The sealed MemoryLayout hierarchy is enhanced to facilitate usage with pattern matching in switch expressions and statements (JEP 433)
MemorySegment
A MemorySegment models a contiguous region of memory, residing either inside or outside the Java heap. A MemorySegment can also be used in conjunction with memory mapping whereby file contents can be directly accessed via a MemorySegment.
Some changes were done between Java 19 and Java 20 with respect to the MemorySegment concept. In Java 19, there was a notion named MemoryAddress used for “pointers to memory” and function addresses. In Java 20, MemorySegment::address returns a raw memory address in the form of a long rather than a MemoryAddress object. Additionally, function addresses are now modeled as a MemorySegment of length zero. This means the MemoryAddress class was dropped entirely.
SegmentScope
All MemorySegment instances need a SegmentScope which models the lifecycle of MemorySegment instances. A scope can be associated with several segments, meaning these segments share the same lifecycle and consequently, their backing resources will be released materially at the same time.
In Java 19, the term MemorySession was used for lifecycles but was also a closeable segment allocator. In Java 20, a SegmentScope is a much more concise, lifecycle-only concept.
Perpetual Global Scope Allocation
Native MemorySegment instances that should live during the entire JVM lifetime can be allocated through the SegmentScope.global() scope (i.e. segment memory associated with this scope will never be released unless the JVM exits). The SegmentScope.global() scope is guaranteed to be a singleton.
Automatic JVM-Managed Deallocation
Native MemorySegment instances that are managed by the JVM can now be allocated through the SegmentScope.auto() factory:
MemorySegment instances associated with new scopes created via the auto() method are also available to all threads but will be automatically managed by the Java garbage collector. This means segments will be released some unspecified time after the segment becomes unreachable. Thus, segments will be released when they are no longer referenced, just like ByteBuffer objects allocated via the ByteBuffer.allocateDirect() method.
This allows a convenient create-and-forget scheme but also implies giving up exact control of when potentially large segments of off-heap memory are actually released.
Deterministic User-Managed Deallocation via Arena
Native MemorySegment instances can also be managed directly and deterministically via the Arena factory methods:
Arena.openConfined()
Arena.openShared()
MemorySegment instances associated with an openConfined() Arena will only be available to the thread that first invokes the factory method and the backing memory will exist merely until the Arena::close method is invoked (either explicitly or by participating in a try-with-resources clause) whereafter accessing any segments associated with the closed Arena will throw an exception.
MemorySegment instances associated with an openShared() Arena behave in a similar way except they are available to any thread. Another difference is when arenas of this type are closed, the JVM has to make sure no other threads are in a critical section (to ensure memory addressing integrity while maintaining performance) and so, closing a shared Arena is slower than closing a confined Arena.
It should be mentioned that forgetting to invoke the Arena::close method means; any and all memory associated with the Arena will remain allocated until the JVM exits. There are no safety nets here and so, a try-with-resource fits nicely for short-lived arenas as it guarantees all the resources of an Arena are released, no matter what.
An Arena can also be used to co-allocate segments in the same scope. This is convenient when using certain data structures with pointers. For example, a linked list that can be dynamically grown by creating new segments when the old ones become full. The referencing pointers are guaranteed to remain valid as all the participating segments are associated with the same scope. Only when the common scope is closed, all the underlying segment resources can be released.
In Java 19, the MemorySession was similar to the Java 20 Arena but crucially, an Arena is not a lifecycle but is now instead associated with a lifecycle (accessible via the Arena::scope method).
MemoryLayout and Pattern Matching
In FFM, a MemoryLayout can be used to describe the contents of a MemorySegment. If we, for example, have the following C struct declaration:
typedef struct Point {
int x,
int y
} Points[5];
Then, we can model it in FFM like this:
SequenceLayout pints = MemoryLayout.sequenceLayout(5,
MemoryLayout.structLayout(
ValueLayout.JAVA_INT.withName("x"),
ValueLayout.JAVA_INT.withName("y")
)
).withName("Points");
Pattern matching (as recently described in JEP 427) will arguably be one of the largest improvements to the Java language ever made and of a similar dignity as generics (appearing in Java 5) and lambdas/functions (appearing in Java 8). In Java 20, the sealed hierarchy of the MemorySegment was overhauled to provide a pattern-matching-friendly definition. This allows, for example, uncomplicated and concise rendering of memory segments as shown hereunder:
default String render(MemorySegment segment,
long offset,
ValueLayout layout) {
return layout.name().orElse(layout.toString())+ " = " +
switch (layout) {
case OfBoolean b -> Boolean.toString(segment.get(b, offset));
case OfByte b -> Byte.toString(segment.get(b, offset));
case OfChar c -> Character.toString(segment.get(c, offset));
case OfShort s -> Short.toString(segment.get(s, offset));
case OfInt i -> Integer.toString(segment.get(i, offset));
case OfLong l -> Long.toString(segment.get(l , offset));
case OfFloat f -> Float.toString(segment.get(f, offset));
case OfDouble d -> Double.toString(segment.get(d, offset));
case OfAddress a ->
"0x"+Long.toHexString(segment.get(a, offset).address());
};
}
The code above can relatively easily be expanded with cases for the complete MemoryLayout sealed hierarchy including recursive calls for the types SequenceLayout, GroupLayout and for the more simple PaddingLayout.
As a side note, the javadocs in Java 20 will likely come with a pattern-matching nudger in the form of a graphic rendering of the sealed hierarchy for selected classes (i.e. those tagged with “@sealedGraph”). Here is how the graph for MemoryLayout might look like once Java 20 hits GA:
As can be seen, the graph and the pattern-matching switch example above correspond and the cases are exhaustive with respect to the ValueLayout type.
Other Improvements
Java 20 will also see many other improvements in the FFM API, some of which are summarized hereunder:
Reduced API surface, making it easier to learn and understand the new API
Improved documentation
Ability to access thread local variables in native calls, including errorno
Show Me the Code!
Here are some examples of creating MemorySegment instances for various purposes:
Allocate a 1K MemorySegment for the Entire Duration of an Application’s Lifetime
public static final MemorySegment SHARED_DATA =
MemorySegment.allocateNative(1024, MemoryScope.global());
Allocate a Small, 32-byte Temporary MemorySegment not Bothering When the Underlying Native Memory is Released
var seg = MemorySegment.allocateNative(32, MemoryScope.auto());
Co-allocate a New MemorySegment with an Existing Segment
var coSegment = MemorySegment.allocateNative(32, seg.scope());
// Store a pointer to the original segment
coSegment.set(ValueLayout.ADDRESS, 0, seg);
Allocate a Large, 4 GiB Temporary MemorySegment Used by the Current Thread Only
try (var arena = Arena.openConfined()) {
var confined = arena.allocate(1L << 32);
use(confined);
} // Memory in "confined" is released here via TwR
Allocate a large, 4 GiB temporary MemorySegment to be Used by Several Threads
try (var arena = Arena.openShared()) {
var shared = arena.allocate(1L << 32);
useInParallel(shared);
} // Memory in "shared" is released here via TwR
Access an Array via a MemorySegment
int[] intArray = new int[10];
var intSeg = MemorySegment.ofArray(intArray);
Access a Buffer (of long in This Example) via a MemorySegment
LongBuffer longBuffer = LongBuffer.allocate(20);
var longSeg = MemorySegment.ofBuffer(longBuffer);
What’s Next?
Take FFM for a spin today by downloading a Java 20 Early-Access build. Do not forget to pass the --enable-preview JVM flag or the code will not run.
Test how you can benefit from FFM already now and engage with the open-source community via the panama mailing list.