On Mon, 26 Feb 2024 13:24:11 GMT, Jorn Vernee <jver...@openjdk.org> wrote:
> This patch changes the alignment for `JAVA_LONG` and `JAVA_DOUBLE` to 8,
> regardless of the underlying platform. This means that atomic access modes
> work on memory segments wrapping `long[]` or `double[]`, as they already do
> when using `MethodHandless::arrayAccessVarHandle`.
>
> After discussion, we came to the conclusion that it is reasonable for the JDK
> to require the elements of a `long[]` and `double[]` to be 8 byte aligned. It
> is ultimately up to the JDK to set these requirements, which are for the VM
> to implement.
>
> I was seeing a stack overflow when running
> test/jdk/java/foreign/stackwalk/TestReentrantUpcalls.java on x86, so I've
> lowered the recursion to 50 (which is still more than enough I think).
>
> Testing: `jdk_foreign` on x64 Windows, x64 Windows + fallback linker, and x86
> Linux (uses fallback linker)
src/java.base/share/classes/java/lang/foreign/MemorySegment.java line 328:
> 326: * physical address 1010.</li>
> 327: * <li>The starting physical address of a {@code long[]} array will be
> 8-byte aligned
> 328: * (e.g. 1000), so that successive long elements occur at 8-byte
> aligned addresses
I believe there might be other changes required. I see the following sentences
in the javadoc:
* In other words, heap segments feature a (platform-dependent) <em>maximum</em>
* alignment which is derived from the size of the elements of the Java array
backing the
* segment, as shown in the following table:
```
* In such circumstances, clients have two options. They can use a heap segment
backed
* by a different array type (e.g. {@code long[]}), capable of supporting
greater maximum
* alignment. More specifically, the maximum alignment associated with {@code
long[]} is
* set to {@code ValueLayout.JAVA_LONG.byteAlignment()} which is a
platform-dependent
* value (set to {@code ValueLayout.ADDRESS.byteSize()}). That is, {@code
long[]}) is
* guaranteed to provide at least 8-byte alignment in 64-bit platforms, but
only 4-byte
* alignment in 32-bit platforms:
```
```
* In practice, the Java runtime lays out arrays in memory so that each n-byte
element
* occurs at an n-byte aligned physical address (except for {@code long[]} and
* {@code double[]}, where alignment is platform-dependent, as explained below).
```
-------------
PR Review Comment: https://git.openjdk.org/jdk/pull/18007#discussion_r1502771056
