# Package java.lang.foreign

package java.lang.foreign

Provides low-level access to memory and functions outside the Java runtime.

## Foreign memory access

The main abstraction introduced to support foreign memory access is `MemorySegment`, that models a contiguous region of memory, residing either inside or outside the Java heap. Memory segments are typically allocated using an `Arena`, which controls the lifetime of the regions of memory backing the segments it allocates. The contents of a memory segment can be described using a `memory layout`, which provides basic operations to query sizes, offsets, and alignment constraints. Memory layouts also provide an alternate, more abstract way, to access memory segments using var handles, which can be computed using layout paths.

For example, to allocate an off-heap region of memory big enough to hold 10 values of the primitive type `int`, and fill it with values ranging from `0` to `9`, we can use the following code:

    try (Arena arena = Arena.ofConfined()) {
        MemorySegment segment = arena.allocate(10 * 4);
        for (int i = 0 ; i < 10 ; i++) {
            segment.setAtIndex(ValueLayout.JAVA_INT, i, i);
        }
    }

This code creates a native memory segment, that is, a memory segment backed by off-heap memory; the size of the segment is 40 bytes, enough to store 10 values of the primitive type `int`. The native segment is allocated using a confined arena. As such, access to the native segment is restricted to the current thread (the thread that created the arena). Moreover, when the arena is closed, the native segment is invalidated, and its backing region of memory is deallocated. Note the use of the try-with-resources construct: this idiom ensures that the off-heap region of memory backing the native segment will be released at the end of the block, according to the semantics described in Section §14.20.3 of The Java Language Specification.

Memory segments provide strong safety guarantees when it comes to memory access. First, when accessing a memory segment, the access coordinates are validated (upon access), to make sure that access does not occur at any address that resides outside the boundaries of the memory segment used by the access operation. We call this guarantee spatial safety; in other words, access to memory segments is bounds-checked, in the same way as array access is, as described in Section §15.10.4 of The Java Language Specification.

Additionally, to prevent a region of memory from being accessed after it has been deallocated (i.e. use-after-free), a segment is also validated (upon access) to make sure that the arena from which it has been obtained has not been closed. We call this guarantee temporal safety.

Together, spatial and temporal safety ensure that each memory access operation either succeeds - and accesses a valid location within the region of memory backing the memory segment - or fails.

## Foreign function access

The key abstractions introduced to support foreign function access are `SymbolLookup`, `FunctionDescriptor` and `Linker`. The first is used to look up symbols inside libraries; the second is used to model the signature of foreign functions, while the third is used to link foreign functions as `MethodHandle` instances, so that clients can perform foreign function calls directly in Java, without the need for intermediate layers of C/C++ code (as is the case with the Java Native Interface (JNI)).

For example, to compute the length of a string using the C standard library function `strlen` on a Linux/x64 platform, we can use the following code:

     Linker linker = Linker.nativeLinker();
     SymbolLookup stdlib = linker.defaultLookup();
     MethodHandle strlen = linker.downcallHandle(
         stdlib.findOrThrow("strlen"),
         FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
     );

     try (Arena arena = Arena.ofConfined()) {
         MemorySegment cString = arena.allocateFrom("Hello");
         long len = (long)strlen.invokeExact(cString); // 5
     }

Here, we obtain a native linker and we use it to look up the `strlen` function in the standard C library; a downcall method handle targeting said function is subsequently obtainedRESTRICTED. To complete the linking successfully, we must provide a `FunctionDescriptor` instance, describing the signature of the `strlen` function. From this information, the linker will uniquely determine the sequence of steps which will turn the method handle invocation (here performed using `MethodHandle.invokeExact(java.lang.Object...)`) into a foreign function call, according to the rules specified by the ABI of the underlying platform.

The `Arena` class also provides many useful methods for interacting with foreign code, such as converting Java strings into zero-terminated, UTF-8 strings, as demonstrated in the above example.

API Note:
  Usual memory model guarantees (see §17.4) do not apply when accessing native memory segments as these segments are backed by off-heap regions of memory.
Since:
  22
External Specifications
  - Java Native Interface Specification

Related Packages
Package
Description
java.lang
Provides classes that are fundamental to the design of the Java programming language.
Interfaces
Class
Description
AddressLayout
A value layout used to model the address of some region of memory.
Arena
An arena controls the lifecycle of native memory segments, providing both flexible allocation and timely deallocation.
FunctionDescriptor
A function descriptor models the signature of a foreign function.
GroupLayout
A compound layout that is an aggregation of multiple, heterogeneous member layouts.
Linker
A linker provides access to foreign functions from Java code, and access to Java code from foreign functions.
Linker.Option
A linker option is used to provide additional parameters to a linkage request.
MemoryLayout
A memory layout describes the contents of a memory segment.
MemoryLayout.PathElement
An element in a layout path.
MemorySegment
A memory segment provides access to a contiguous region of memory.
MemorySegment.Scope
A scope models the lifetime of all the memory segments associated with it.
PaddingLayout
A padding layout.
SegmentAllocator
An object that may be used to allocate memory segments.
SequenceLayout
A compound layout that denotes a homogeneous repetition of a given element layout.
StructLayout
A group layout whose member layouts are laid out one after the other.
SymbolLookup
A symbol lookup retrieves the address of a symbol in one or more libraries.
UnionLayout
A group layout whose member layouts are laid out at the same starting offset.
ValueLayout
A layout that models values of basic data types.
ValueLayout.OfBoolean
A value layout whose carrier is `boolean.class`.
ValueLayout.OfByte
A value layout whose carrier is `byte.class`.
ValueLayout.OfChar
A value layout whose carrier is `char.class`.
ValueLayout.OfDouble
A value layout whose carrier is `double.class`.
ValueLayout.OfFloat
A value layout whose carrier is `float.class`.
ValueLayout.OfInt
A value layout whose carrier is `int.class`.
ValueLayout.OfLong
A value layout whose carrier is `long.class`.
ValueLayout.OfShort
A value layout whose carrier is `short.class`.