GraalVM and Modern JVM

Interpreter -> C1 (quick) -> C1 (detailed) -> C2 (or Graal) -> Native code

<plugin>
    <groupId>org.graalvm.nativeimage</groupId>
    <artifactId>native-image-maven-plugin</artifactId>
    <version>0.10.4</version>
    <configuration>
        <imageName>myapp</imageName>
        <mainClass>com.example.Main</mainClass>
        <buildArgs>
            <buildArg>--no-fallback</buildArg>
            <buildArg>-H:+ReportExceptionStackTraces</buildArg>
        </buildArgs>
    </configuration>
    <executions>
        <execution>
            <id>build-native</id>
            <phase>package</phase>
            <goals>
                <goal>native-image</goal>
            </goals>
        </execution>
    </executions>
</plugin>

plugins {
    id 'org.graalvm.buildtools.native' version '0.10.4'
}

graalvmNative {
    binaries {
        main {
            imageName = 'myapp'
            mainClass = 'com.example.Main'
            buildArgs.add('--no-fallback')
        }
    }
}

[
  {
    "name": "com.example.MyDto",
    "allDeclaredConstructors": true,
    "allPublicMethods": true,
    "allDeclaredFields": true
  }
]

{
  "resources": {
    "includes": [{ "pattern": ".*\\.properties$" }, { "pattern": ".*\\.xml$" }]
  }
}

[["java.sql.Connection", "java.lang.AutoCloseable"]]

[
  {
    "name": "com.example.NativeLib",
    "methods": [{ "name": "nativeMethod", "parameterTypes": ["java.lang.String"] }]
  }
]

import org.graalvm.nativeimage.hosted.Feature;

public class MyFeature implements Feature {
    @Override
    public void beforeAnalysis(BeforeAnalysisAccess access) {
        // Register classes, resources, proxies at build time
        access.registerSubtype(access.findClassByName("com.example.MyInterface"));
    }

    @Override
    public void duringAnalysis(DuringAnalysisAccess access) {
        // Query reachability and register additional types
        if (access.reachesType(access.findClassByName("com.example.OptionalFeature"))) {
            access.registerSubtype(access.findClassByName("com.example.OptionalImpl"));
        }
    }
}

Args = --features=org.graalvm.nativeimage.impl.InternalFeature \
       --features=com.example.MyFeature

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.VarHandle;

public class CStringOperations {
    public static void main(String[] args) throws Throwable {
        Linker linker = Linker.nativeLinker();
        SymbolLookup stdlib = SymbolLookup.libraryLookup("libc.so.6", Arena.ofAuto());
        SymbolLookup lookup = name -> stdlib.lookup(name).or(Linker.nativeLinker().defaultLookup().lookup(name));

        // strlen(const char *s) -> size_t
        MethodHandle strlen = linker.downcallHandle(
            lookup.lookup("strlen").orElseThrow(),
            FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
        );

        // Allocate a C string in native memory
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment cString = arena.allocateFrom("Hello, native world!");
            long length = (long) strlen.invoke(cString);
            System.out.println("Length: " + length); // 20
        }
    }
}

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.VarHandle;

public class StructExample {
    // Equivalent to: struct Point { double x; double y; };
    static final GroupLayout POINT_LAYOUT = MemoryLayout.structLayout(
        ValueLayout.JAVA_DOUBLE.withName("x"),
        ValueLayout.JAVA_DOUBLE.withName("y")
    );

    public static void main(String[] args) throws Throwable {
        Linker linker = Linker.nativeLinker();

        // Allocate a Point struct on the native heap
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment point = arena.allocate(POINT_LAYOUT);

            VarHandle xHandle = POINT_LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("x"));
            VarHandle yHandle = POINT_LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("y"));

            xHandle.set(point, 3.0);
            yHandle.set(point, 4.0);

            System.out.println("x=" + xHandle.get(point) + ", y=" + yHandle.get(point));
        }
    }
}

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

public class CallbackExample {
    public static void main(String[] args) throws Throwable {
        Linker linker = Linker.nativeLinker();
        SymbolLookup lookup = name -> SymbolLookup.libraryLookup("libc.so.6", Arena.ofAuto())
            .lookup(name)
            .or(Linker.nativeLinker().defaultLookup().lookup(name));

        // int compare(const void *a, const void *b, void *arg)
        MethodHandle qsort = linker.downcallHandle(
            lookup.lookup("qsort").orElseThrow(),
            FunctionDescriptor.ofVoid(
                ValueLayout.ADDRESS,  // base
                ValueLayout.JAVA_LONG, // nmemb
                ValueLayout.JAVA_LONG, // size
                ValueLayout.ADDRESS   // compar
            )
        );

        // Callback: int (*compar)(const void *, const void *)
        MethodHandle comparHandle = MethodHandles.lookup().findStatic(
            CallbackExample.class,
            "compareInts",
            MethodType.methodType(int.class, MemorySegment.class, MemorySegment.class)
        );

        MemorySegment comparFunc = linker.upcallStub(
            comparHandle,
            FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.ADDRESS),
            Arena.ofAuto()
        );

        try (Arena arena = Arena.ofConfined()) {
            MemorySegment array = arena.allocate(ValueLayout.JAVA_INT, 5);
            VarHandle intHandle = ValueLayout.JAVA_INT.varHandle();
            intHandle.set(array, 0L, 5);
            intHandle.set(array, 1L, 2);
            intHandle.set(array, 2L, 8);
            intHandle.set(array, 3L, 1);
            intHandle.set(array, 4L, 9);

            qsort.invoke(array, 5L, 4L, comparFunc);

            System.out.print("Sorted: ");
            for (long i = 0; i < 5; i++) {
                System.out.print(intHandle.get(array, i) + " ");
            }
            // Output: Sorted: 1 2 5 8 9
        }
    }

    static int compareInts(MemorySegment a, MemorySegment b) {
        int va = ValueLayout.JAVA_INT.get(a, 0);
        int vb = ValueLayout.JAVA_INT.get(b, 0);
        return Integer.compare(va, vb);
    }
}

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.VarHandle;

public class LibCurlExample {
    static final Linker LINKER = Linker.nativeLinker();

    static final SymbolLookup CURL = SymbolLookup.libraryLookup(
        "libcurl.so.4", Arena.ofAuto()
    );

    static final MemorySession.SessionImpl CURL_GLOBAL_ALL =
        MemorySession.sessionCreator().create();

    public static void main(String[] args) throws Throwable {
        // curl_easy_init() -> CURL*
        MethodHandle curlEasyInit = LINKER.downcallHandle(
            CURL.lookup("curl_easy_init").orElseThrow(),
            FunctionDescriptor.of(ValueLayout.ADDRESS)
        );

        // curl_easy_setopt(CURL*, CURLoption, ...) -> CURLcode
        MethodHandle curlEasySetopt = LINKER.downcallHandle(
            CURL.lookup("curl_easy_setopt").orElseThrow(),
            FunctionDescriptor.of(
                ValueLayout.JAVA_INT,
                ValueLayout.ADDRESS,
                ValueLayout.JAVA_INT,
                ValueLayout.ADDRESS
            )
        );

        // curl_easy_perform(CURL*) -> CURLcode
        MethodHandle curlEasyPerform = LINKER.downcallHandle(
            CURL.lookup("curl_easy_perform").orElseThrow(),
            FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS)
        );

        // curl_easy_cleanup(CURL*) -> void
        MethodHandle curlEasyCleanup = LINKER.downcallHandle(
            CURL.lookup("curl_easy_cleanup").orElseThrow(),
            FunctionDescriptor.ofVoid(ValueLayout.ADDRESS)
        );

        try (Arena arena = Arena.ofConfined()) {
            MemorySegment curl = (MemorySegment) curlEasyInit.invoke();

            // CURLOPT_URL = 10002
            MemorySegment url = arena.allocateFrom("https://example.com");
            curlEasySetopt.invoke(curl, 10002, url);

            int result = (int) curlEasyPerform.invoke(curl);
            curlEasyCleanup.invoke(curl);

            System.out.println("curl result: " + result);
        }
    }
}

import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.ValueLayout;

public class ArenaExample {
    public static void main(String[] args) {
        // Confined arena: only one thread can access its segments
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment buffer = arena.allocate(1024);
            ValueLayout.JAVA_INT.set(buffer, 0L, 42);
            int value = ValueLayout.JAVA_INT.get(buffer, 0L);
            System.out.println("Value: " + value); // 42
        }
        // buffer is freed here

        // Shared arena: multiple threads can access segments
        try (Arena arena = Arena.ofShared()) {
            MemorySegment shared = arena.allocate(256);
            // safe to pass 'shared' to another thread
        }

        // Auto arena: freed by the GC (for interop with existing code)
        Arena autoArena = Arena.ofAuto();
        MemorySegment ephemeral = autoArena.allocate(128);
        // freed when ephemeral becomes unreachable
    }
}

import java.lang.foreign.*;
import java.lang.invoke.VarHandle;
import java.nio.ByteOrder;

public class MemorySegmentDemo {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            // Allocate from a C string literal
            MemorySegment hello = arena.allocateFrom("Hello, World!");
            long byteSize = hello.byteSize(); // 14 (13 chars + null terminator)

            // Allocate a typed array in native memory
            MemorySegment doubles = arena.allocate(ValueLayout.JAVA_DOUBLE, 10);
            for (long i = 0; i < 10; i++) {
                ValueLayout.JAVA_DOUBLE.set(doubles, i, i * 1.5);
            }

            // Bulk copy between segments
            MemorySegment dest = arena.allocate(80);
            dest.copyFrom(doubles);

            // Slice a segment
            MemorySegment firstFive = doubles.asSlice(0, 5 * ValueLayout.JAVA_DOUBLE.byteSize());

            // Fill with a value
            MemorySegment zeros = arena.allocate(256);
            zeros.fill((byte) 0);

            // Create a mapped segment from a file
            MemorySegment fileData = MemorySegment.mapFile(
                Path.of("data.bin"),
                0L,
                1024,
                FileChannel.MapMode.READ_ONLY,
                Arena.ofAuto()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.lang.foreign.ValueLayout;
import java.nio.ByteOrder;

// Standard layouts (platform byte order)
ValueLayout.JAVA_BYTE      // 1 byte
ValueLayout.JAVA_SHORT     // 2 bytes
ValueLayout.JAVA_CHAR      // 2 bytes (unsigned)
ValueLayout.JAVA_INT       // 4 bytes
ValueLayout.JAVA_LONG      // 8 bytes
ValueLayout.JAVA_FLOAT     // 4 bytes
ValueLayout.JAVA_DOUBLE    // 8 bytes
ValueLayout.ADDRESS        // Platform-dependent pointer size (4 or 8 bytes)

// Custom layouts with explicit byte order
ValueLayout.JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN)

// C-compatible layouts
ValueLayout.C_BOOL         // _Bool (1 byte)
ValueLayout.C_SHORT        // short (2 bytes)
ValueLayout.C_INT          // int (4 bytes)
ValueLayout.C_LONG         // long (4 or 8 bytes, platform-dependent)
ValueLayout.C_LONG_LONG    // long long (8 bytes)
ValueLayout.C_FLOAT        // float (4 bytes)
ValueLayout.C_DOUBLE       // double (8 bytes)
ValueLayout.C_POINTER      // pointer (4 or 8 bytes)

import java.lang.foreign.*;
import java.lang.invoke.VarHandle;
import java.util.concurrent.atomic.AtomicInteger;

public class VarHandleMemoryDemo {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment counter = arena.allocate(ValueLayout.JAVA_INT);

            VarHandle handle = ValueLayout.JAVA_INT.varHandle();

            // Plain access
            handle.set(counter, 0L, 0);

            // Volatile write and read
            handle.setVolatile(counter, 0L, 42);
            int val = (int) handle.getVolatile(counter, 0L);

            // Compare-and-swap
            boolean success = handle.compareAndSet(counter, 0L, 42, 43);

            // Atomic add
            int oldVal = (int) handle.getAndAdd(counter, 0L, 10);
        }
    }
}

import java.lang.foreign.*;

public class OffHeapRingBuffer {
    private final MemorySegment buffer;
    private final long capacity;
    private final VarHandle intHandle;
    private long head = 0;
    private long tail = 0;

    public OffHeapRingBuffer(int capacity) {
        this.capacity = capacity;
        try (Arena arena = Arena.ofConfined()) {
            this.buffer = arena.allocate(ValueLayout.JAVA_LONG, capacity);
        }
        this.intHandle = ValueLayout.JAVA_LONG.varHandle();
    }

    public void offer(long value) {
        intHandle.set(buffer, tail * ValueLayout.JAVA_LONG.byteSize(), value);
        tail = (tail + 1) % capacity;
    }

    public long poll() {
        long value = (long) intHandle.get(buffer, head * ValueLayout.JAVA_LONG.byteSize());
        head = (head + 1) % capacity;
        return value;
    }

    public boolean isEmpty() {
        return head == tail;
    }
}

import jdk.incubator.vector.*;

public class VectorDemo {
    public static void floatVectorAdd(float[] a, float[] b, float[] result) {
        // Select the preferred vector species for float (256-bit on most x86 machines)
        VectorSpecies<Float> species = FloatVector.SPECIES_PREFERRED;
        int i = 0;

        // Process 8 floats at a time (256 bits / 32 bits per float = 8 lanes)
        int upperBound = species.loopBound(a.length);
        for (; i < upperBound; i += species.length()) {
            FloatVector va = FloatVector.fromArray(species, a, i);
            FloatVector vb = FloatVector.fromArray(species, b, i);
            va.add(vb).intoArray(result, i);
        }

        // Handle remainder
        for (; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }
    }

    public static void main(String[] args) {
        float[] a = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
        float[] b = {8.0f, 7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f};
        float[] result = new float[8];

        floatVectorAdd(a, b, result);
        // result: [9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0]
    }
}

import jdk.incubator.vector.*;

public class LaneWiseOperations {
    public static void vectorOperations(float[] a, float[] b, float[] result) {
        VectorSpecies<Float> species = FloatVector.SPECIES_PREFERRED;
        int i = 0;
        int upperBound = species.loopBound(a.length);

        for (; i < upperBound; i += species.length()) {
            FloatVector va = FloatVector.fromArray(species, a, i);
            FloatVector vb = FloatVector.fromArray(species, b, i);

            // Lane-wise multiply, then add a scalar
            FloatVector mul = va.mul(vb);
            FloatVector addScalar = mul.add(1.0f);

            // Lane-wise comparison, producing a mask
            VectorMask<Float> mask = va.gt(vb);

            // Blend: select from va where mask is true, from vb where false
            FloatVector blended = va.blend(vb, mask);

            // Reduce: sum all lanes to a single float
            float sum = va.reduceLanes(VectorOperators.ADD);

            blended.intoArray(result, i);
        }

        for (; i < a.length; i++) {
            result[i] = a[i];
        }
    }
}

// Create a single virtual thread
Thread vt = Thread.ofVirtual().name("worker").start(() -> doWork());

// Executor that creates a new virtual thread per task
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> blockingIoCall());
}

// Avoid synchronized blocks for blocking operations (pinning)
// Bad: pins the carrier thread
synchronized (lock) { socket.read(buffer); }

// Good: ReentrantLock allows unmounting
lock.lock();
try { socket.read(buffer); } finally { lock.unlock(); }

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    var userTask = scope.fork(() -> fetchUser(id));
    var ordersTask = scope.fork(() -> fetchOrders(id));

    scope.join();
    scope.throwIfFailed();

    return new UserData(userTask.get(), ordersTask.get());
}

// Record pattern in instanceof
if (obj instanceof Point(var x, var y)) {
    System.out.println("Point at (" + x + ", " + y + ")");
}

// Record pattern in switch with sealed hierarchy
return switch (shape) {
    case Circle(var r) when r == 0 -> 0.0;
    case Circle(var r) -> Math.PI * r * r;
    case Rectangle(var w, var h) -> w * h;
    case Triangle t -> heronsFormula(t);
};

// Value class (Valhalla preview syntax)
public value class Point {
    final double x;
    final double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

// Usage: Point is stored inline, no heap allocation
public value class Line {
    final Point start;
    final Point end;

    public Line(Point start, Point end) {
        this.start = start;
        this.end = end;
    }
}

// Identity class: array of references (each element is a pointer)
Point[] identityPoints = new Point[1000];
// Memory: 8000 bytes for references + 16000 bytes for Point objects on heap

// Value class: array of flattened values (no indirection)
value Point[] valuePoints = new value Point[1000];
// Memory: 16000 bytes total (8 bytes per element, inline in the array)

// Today: List<int> does not exist, must use List<Integer> (boxed)
List&lt;Integer&gt; boxed = new ArrayList&lt;&gt;();
boxed.add(42); // allocates an Integer object

// Valhalla: List<int> stores int values directly
List&lt;int&gt; unboxed = new ArrayList&lt;&gt;(); // hypothetical syntax
unboxed.add(42); // no allocation

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <image>
            <builder>paketobuildpacks/builder-jammy-base:latest</builder>
            <env>
                <BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE>
            </env>
        </image>
    </configuration>
</plugin>

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class NativeImageTest {
    @Test
    void testMainOutput() {
        // Test the main class logic, not the native image itself
        App app = new App();
        String result = app.greet("World");
        assertEquals("Hello, World!", result);
    }
}