214 lines
9.4 KiB
Java
214 lines
9.4 KiB
Java
/*
|
|
* Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @run testng TestMemoryAlignment
|
|
*/
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.lang.foreign.*;
|
|
import java.lang.foreign.MemoryLayout.PathElement;
|
|
import java.lang.invoke.VarHandle;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.ByteOrder;
|
|
import java.nio.CharBuffer;
|
|
import java.nio.DoubleBuffer;
|
|
import java.nio.FloatBuffer;
|
|
import java.nio.IntBuffer;
|
|
import java.nio.LongBuffer;
|
|
import java.nio.ShortBuffer;
|
|
import java.nio.channels.FileChannel;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.StandardOpenOption;
|
|
import java.util.stream.LongStream;
|
|
import java.util.stream.Stream;
|
|
|
|
import org.testng.annotations.*;
|
|
import static org.testng.Assert.*;
|
|
|
|
public class TestMemoryAlignment {
|
|
|
|
@Test(dataProvider = "alignments")
|
|
public void testAlignedAccess(long align) {
|
|
ValueLayout layout = ValueLayout.JAVA_INT
|
|
.withOrder(ByteOrder.BIG_ENDIAN);
|
|
assertEquals(layout.byteAlignment(), 4);
|
|
ValueLayout aligned = layout.withByteAlignment(align);
|
|
assertEquals(aligned.byteAlignment(), align); //unreasonable alignment here, to make sure access throws
|
|
VarHandle vh = aligned.varHandle();
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
MemorySegment segment = arena.allocate(aligned);;
|
|
vh.set(segment, 0L, -42);
|
|
int val = (int)vh.get(segment, 0L);
|
|
assertEquals(val, -42);
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "alignments")
|
|
public void testUnalignedAccess(long align) {
|
|
ValueLayout layout = ValueLayout.JAVA_INT
|
|
.withOrder(ByteOrder.BIG_ENDIAN);
|
|
assertEquals(layout.byteAlignment(), 4);
|
|
ValueLayout aligned = layout.withByteAlignment(align);
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
MemoryLayout alignedGroup = MemoryLayout.structLayout(MemoryLayout.paddingLayout(1), aligned);
|
|
assertEquals(alignedGroup.byteAlignment(), align);
|
|
VarHandle vh = aligned.varHandle();
|
|
MemorySegment segment = arena.allocate(alignedGroup);;
|
|
vh.set(segment.asSlice(1L), 0L, -42);
|
|
assertEquals(align, 8); //this is the only case where access is aligned
|
|
} catch (IllegalArgumentException ex) {
|
|
assertNotEquals(align, 8); //if align != 8, access is always unaligned
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "alignments")
|
|
public void testUnalignedPath(long align) {
|
|
MemoryLayout layout = ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN);
|
|
MemoryLayout aligned = layout.withByteAlignment(align).withName("value");
|
|
try {
|
|
GroupLayout alignedGroup = MemoryLayout.structLayout(MemoryLayout.paddingLayout(1), aligned);
|
|
alignedGroup.varHandle(PathElement.groupElement("value"));
|
|
assertEquals(align, 1); //this is the only case where path is aligned
|
|
} catch (IllegalArgumentException ex) {
|
|
assertNotEquals(align, 1); //if align != 8, path is always unaligned
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "alignments")
|
|
public void testUnalignedSequence(long align) {
|
|
try {
|
|
SequenceLayout layout = MemoryLayout.sequenceLayout(5, ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN).withByteAlignment(align));
|
|
VarHandle vh = layout.varHandle(PathElement.sequenceElement());
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
MemorySegment segment = arena.allocate(layout);;
|
|
for (long i = 0 ; i < 5 ; i++) {
|
|
vh.set(segment, 0L, i, -42);
|
|
}
|
|
}
|
|
} catch (IllegalArgumentException ex) {
|
|
assertTrue(align > 4); //if align > 4, access is always unaligned (for some elements)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testPackedAccess() {
|
|
ValueLayout vChar = ValueLayout.JAVA_BYTE;
|
|
ValueLayout vShort = ValueLayout.JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN);
|
|
ValueLayout vInt = ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN);
|
|
//mimic pragma pack(1)
|
|
GroupLayout g = MemoryLayout.structLayout(vChar.withByteAlignment(1).withName("a"),
|
|
vShort.withByteAlignment(1).withName("b"),
|
|
vInt.withByteAlignment(1).withName("c"));
|
|
assertEquals(g.byteAlignment(), 1);
|
|
VarHandle vh_c = g.varHandle(PathElement.groupElement("a"));
|
|
VarHandle vh_s = g.varHandle(PathElement.groupElement("b"));
|
|
VarHandle vh_i = g.varHandle(PathElement.groupElement("c"));
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
MemorySegment segment = arena.allocate(g);;
|
|
vh_c.set(segment, 0L, Byte.MIN_VALUE);
|
|
assertEquals(vh_c.get(segment, 0L), Byte.MIN_VALUE);
|
|
vh_s.set(segment, 0L, Short.MIN_VALUE);
|
|
assertEquals(vh_s.get(segment, 0L), Short.MIN_VALUE);
|
|
vh_i.set(segment, 0L, Integer.MIN_VALUE);
|
|
assertEquals(vh_i.get(segment, 0L), Integer.MIN_VALUE);
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "alignments")
|
|
public void testActualByteAlignment(long align) {
|
|
if (align > (1L << 10)) {
|
|
return;
|
|
}
|
|
try (Arena arena = Arena.ofConfined()) {
|
|
var segment = arena.allocate(4, align);
|
|
assertTrue(segment.maxByteAlignment() >= align);
|
|
// Power of two?
|
|
assertEquals(Long.bitCount(segment.maxByteAlignment()), 1);
|
|
assertEquals(segment.asSlice(1).maxByteAlignment(), 1);
|
|
}
|
|
}
|
|
|
|
public void testActualByteAlignmentMappedSegment() throws IOException {
|
|
File tmp = File.createTempFile("tmp", "txt");
|
|
try (FileChannel channel = FileChannel.open(tmp.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE);
|
|
Arena arena = Arena.ofConfined()) {
|
|
var segment =channel.map(FileChannel.MapMode.READ_WRITE, 0L, 32L, arena);
|
|
// We do not know anything about mapping alignment other than it should
|
|
// be positive.
|
|
assertTrue(segment.maxByteAlignment() >= Byte.BYTES);
|
|
// Power of two?
|
|
assertEquals(Long.bitCount(segment.maxByteAlignment()), 1);
|
|
assertEquals(segment.asSlice(1).maxByteAlignment(), 1);
|
|
} finally {
|
|
tmp.delete();
|
|
}
|
|
}
|
|
|
|
@Test()
|
|
public void testActualByteAlignmentNull() {
|
|
long alignment = MemorySegment.NULL.maxByteAlignment();
|
|
assertEquals(1L << 62, alignment);
|
|
}
|
|
|
|
@Test(dataProvider = "heapSegments")
|
|
public void testActualByteAlignmentHeap(MemorySegment segment, int bytes) {
|
|
assertEquals(segment.maxByteAlignment(), bytes);
|
|
// A slice at offset 1 should always have an alignment of 1
|
|
var segmentSlice = segment.asSlice(1);
|
|
assertEquals(segmentSlice.maxByteAlignment(), 1);
|
|
}
|
|
|
|
@DataProvider(name = "alignments")
|
|
public Object[][] createAlignments() {
|
|
return LongStream.range(1, 20)
|
|
.mapToObj(v -> new Object[] { 1L << v })
|
|
.toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider(name = "heapSegments")
|
|
public Object[][] heapSegments() {
|
|
return Stream.of(
|
|
new Object[]{MemorySegment.ofArray(new byte[]{1}), Byte.BYTES},
|
|
new Object[]{MemorySegment.ofArray(new short[]{1}), Short.BYTES},
|
|
new Object[]{MemorySegment.ofArray(new char[]{1}), Character.BYTES},
|
|
new Object[]{MemorySegment.ofArray(new int[]{1}), Integer.BYTES},
|
|
new Object[]{MemorySegment.ofArray(new long[]{1}), Long.BYTES},
|
|
new Object[]{MemorySegment.ofArray(new float[]{1}), Float.BYTES},
|
|
new Object[]{MemorySegment.ofArray(new double[]{1}), Double.BYTES},
|
|
new Object[]{MemorySegment.ofBuffer(ByteBuffer.allocate(8)), Byte.BYTES},
|
|
new Object[]{MemorySegment.ofBuffer(CharBuffer.allocate(8)), Character.BYTES},
|
|
new Object[]{MemorySegment.ofBuffer(ShortBuffer.allocate(8)), Short.BYTES},
|
|
new Object[]{MemorySegment.ofBuffer(IntBuffer.allocate(8)), Integer.BYTES},
|
|
new Object[]{MemorySegment.ofBuffer(LongBuffer.allocate(8)), Long.BYTES},
|
|
new Object[]{MemorySegment.ofBuffer(FloatBuffer.allocate(8)), Float.BYTES},
|
|
new Object[]{MemorySegment.ofBuffer(DoubleBuffer.allocate(8)), Double.BYTES}
|
|
)
|
|
.toArray(Object[][]::new);
|
|
}
|
|
|
|
}
|