1 /*
2 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 /*
26 * @test
27 * @modules java.base/jdk.internal.misc
28 * jdk.incubator.foreign/jdk.internal.foreign
29 * @run testng/othervm -Dforeign.restricted=permit TestNative
30 */
31
32 import jdk.incubator.foreign.MemoryAddress;
33 import jdk.incubator.foreign.MemoryLayout;
34 import jdk.incubator.foreign.MemoryLayout.PathElement;
35 import jdk.incubator.foreign.MemoryLayouts;
36 import jdk.incubator.foreign.MemorySegment;
37 import jdk.incubator.foreign.SequenceLayout;
38 import jdk.internal.misc.Unsafe;
39 import org.testng.annotations.DataProvider;
40 import org.testng.annotations.Test;
41
42 import java.lang.invoke.VarHandle;
43 import java.nio.Buffer;
44 import java.nio.ByteBuffer;
45 import java.nio.ByteOrder;
46 import java.nio.CharBuffer;
47 import java.nio.DoubleBuffer;
48 import java.nio.FloatBuffer;
49 import java.nio.IntBuffer;
50 import java.nio.LongBuffer;
51 import java.nio.ShortBuffer;
52 import java.util.function.BiConsumer;
53 import java.util.function.BiFunction;
54 import java.util.function.Consumer;
55 import java.util.function.Function;
56 import static jdk.incubator.foreign.MemorySegment.*;
57 import static org.testng.Assert.*;
58
59 public class TestNative {
60
61 static Unsafe UNSAFE;
62
63 static {
64 UNSAFE = Unsafe.getUnsafe();
65 }
66
67 static SequenceLayout bytes = MemoryLayout.ofSequence(100,
68 MemoryLayouts.JAVA_BYTE.withOrder(ByteOrder.nativeOrder())
69 );
70
71 static SequenceLayout chars = MemoryLayout.ofSequence(100,
72 MemoryLayouts.JAVA_CHAR.withOrder(ByteOrder.nativeOrder())
73 );
74
75 static SequenceLayout shorts = MemoryLayout.ofSequence(100,
76 MemoryLayouts.JAVA_SHORT.withOrder(ByteOrder.nativeOrder())
77 );
78
79 static SequenceLayout ints = MemoryLayout.ofSequence(100,
80 MemoryLayouts.JAVA_INT.withOrder(ByteOrder.nativeOrder())
81 );
82
83 static SequenceLayout floats = MemoryLayout.ofSequence(100,
84 MemoryLayouts.JAVA_FLOAT.withOrder(ByteOrder.nativeOrder())
85 );
86
87 static SequenceLayout longs = MemoryLayout.ofSequence(100,
88 MemoryLayouts.JAVA_LONG.withOrder(ByteOrder.nativeOrder())
89 );
90
91 static SequenceLayout doubles = MemoryLayout.ofSequence(100,
92 MemoryLayouts.JAVA_DOUBLE.withOrder(ByteOrder.nativeOrder())
93 );
94
95 static VarHandle byteHandle = bytes.varHandle(byte.class, PathElement.sequenceElement());
96 static VarHandle charHandle = chars.varHandle(char.class, PathElement.sequenceElement());
97 static VarHandle shortHandle = shorts.varHandle(short.class, PathElement.sequenceElement());
98 static VarHandle intHandle = ints.varHandle(int.class, PathElement.sequenceElement());
99 static VarHandle floatHandle = floats.varHandle(float.class, PathElement.sequenceElement());
100 static VarHandle longHandle = doubles.varHandle(long.class, PathElement.sequenceElement());
101 static VarHandle doubleHandle = longs.varHandle(double.class, PathElement.sequenceElement());
102
103 static void initBytes(MemoryAddress base, SequenceLayout seq, BiConsumer<MemoryAddress, Long> handleSetter) {
104 for (long i = 0; i < seq.elementCount().getAsLong() ; i++) {
105 handleSetter.accept(base, i);
106 }
107 }
108
109 static <Z extends Buffer> void checkBytes(MemoryAddress base, SequenceLayout layout,
110 BiFunction<MemoryAddress, Long, Object> handleExtractor,
111 Function<ByteBuffer, Z> bufferFactory,
112 BiFunction<Z, Integer, Object> nativeBufferExtractor,
113 BiFunction<Long, Integer, Object> nativeRawExtractor) {
114 long nelems = layout.elementCount().getAsLong();
115 ByteBuffer bb = base.segment().asSlice(base.segmentOffset(), (int)layout.byteSize()).asByteBuffer();
116 Z z = bufferFactory.apply(bb);
117 for (long i = 0 ; i < nelems ; i++) {
118 Object handleValue = handleExtractor.apply(base, i);
119 Object bufferValue = nativeBufferExtractor.apply(z, (int)i);
120 Object rawValue = nativeRawExtractor.apply(base.toRawLongValue(), (int)i);
121 if (handleValue instanceof Number) {
122 assertEquals(((Number)handleValue).longValue(), i);
123 assertEquals(((Number)bufferValue).longValue(), i);
124 assertEquals(((Number)rawValue).longValue(), i);
125 } else {
126 assertEquals((long)(char)handleValue, i);
127 assertEquals((long)(char)bufferValue, i);
128 assertEquals((long)(char)rawValue, i);
129 }
130 }
131 }
132
133 public static native byte getByteBuffer(ByteBuffer buf, int index);
134 public static native char getCharBuffer(CharBuffer buf, int index);
135 public static native short getShortBuffer(ShortBuffer buf, int index);
136 public static native int getIntBuffer(IntBuffer buf, int index);
137 public static native float getFloatBuffer(FloatBuffer buf, int index);
138 public static native long getLongBuffer(LongBuffer buf, int index);
139 public static native double getDoubleBuffer(DoubleBuffer buf, int index);
140
141 public static native byte getByteRaw(long addr, int index);
142 public static native char getCharRaw(long addr, int index);
143 public static native short getShortRaw(long addr, int index);
144 public static native int getIntRaw(long addr, int index);
145 public static native float getFloatRaw(long addr, int index);
146 public static native long getLongRaw(long addr, int index);
147 public static native double getDoubleRaw(long addr, int index);
148
149 public static native long getCapacity(Buffer buffer);
150
151 public static native long allocate(int size);
152 public static native void free(long address);
153
154 @Test(dataProvider="nativeAccessOps")
155 public void testNativeAccess(Consumer<MemoryAddress> checker, Consumer<MemoryAddress> initializer, SequenceLayout seq) {
156 try (MemorySegment segment = MemorySegment.allocateNative(seq)) {
157 MemoryAddress address = segment.baseAddress();
158 initializer.accept(address);
159 checker.accept(address);
160 }
161 }
162
163 @Test(dataProvider="buffers")
164 public void testNativeCapacity(Function<ByteBuffer, Buffer> bufferFunction, int elemSize) {
165 int capacity = (int)doubles.byteSize();
166 try (MemorySegment segment = MemorySegment.allocateNative(doubles)) {
167 ByteBuffer bb = segment.asByteBuffer();
168 Buffer buf = bufferFunction.apply(bb);
169 int expected = capacity / elemSize;
170 assertEquals(buf.capacity(), expected);
171 assertEquals(getCapacity(buf), expected);
172 }
173 }
174
175 static final int ALL_ACCESS_MODES = READ | WRITE | CLOSE | ACQUIRE | HANDOFF;
176
177 @Test
178 public void testDefaultAccessModes() {
179 MemoryAddress addr = MemoryAddress.ofLong(allocate(12));
180 MemorySegment mallocSegment = MemorySegment.ofNativeRestricted(addr, 12, null,
181 () -> free(addr.toRawLongValue()), null);
182 try (MemorySegment segment = mallocSegment) {
183 assertTrue(segment.hasAccessModes(ALL_ACCESS_MODES));
184 assertEquals(segment.accessModes(), ALL_ACCESS_MODES);
185 }
186 }
187
188 @Test
189 public void testMallocSegment() {
190 MemoryAddress addr = MemoryAddress.ofLong(allocate(12));
191 assertNull(addr.segment());
192 MemorySegment mallocSegment = MemorySegment.ofNativeRestricted(addr, 12, null,
193 () -> free(addr.toRawLongValue()), null);
194 assertEquals(mallocSegment.byteSize(), 12);
195 mallocSegment.close(); //free here
196 assertTrue(!mallocSegment.isAlive());
197 }
198
199 @Test(expectedExceptions = IllegalArgumentException.class)
200 public void testBadResize() {
201 try (MemorySegment segment = MemorySegment.allocateNative(4)) {
202 MemorySegment.ofNativeRestricted(segment.baseAddress(), 0, null, null, null);
203 }
204 }
205
206 @Test(expectedExceptions = NullPointerException.class)
207 public void testNullUnsafeSegment() {
208 MemorySegment.ofNativeRestricted(null, 10, null, null, null);
209 }
210
211 static {
212 System.loadLibrary("NativeAccess");
213 }
214
215 @DataProvider(name = "nativeAccessOps")
216 public Object[][] nativeAccessOps() {
217 Consumer<MemoryAddress> byteInitializer =
218 (base) -> initBytes(base, bytes, (addr, pos) -> byteHandle.set(addr, pos, (byte)(long)pos));
219 Consumer<MemoryAddress> charInitializer =
220 (base) -> initBytes(base, chars, (addr, pos) -> charHandle.set(addr, pos, (char)(long)pos));
221 Consumer<MemoryAddress> shortInitializer =
222 (base) -> initBytes(base, shorts, (addr, pos) -> shortHandle.set(addr, pos, (short)(long)pos));
223 Consumer<MemoryAddress> intInitializer =
224 (base) -> initBytes(base, ints, (addr, pos) -> intHandle.set(addr, pos, (int)(long)pos));
225 Consumer<MemoryAddress> floatInitializer =
226 (base) -> initBytes(base, floats, (addr, pos) -> floatHandle.set(addr, pos, (float)(long)pos));
227 Consumer<MemoryAddress> longInitializer =
228 (base) -> initBytes(base, longs, (addr, pos) -> longHandle.set(addr, pos, (long)pos));
229 Consumer<MemoryAddress> doubleInitializer =
230 (base) -> initBytes(base, doubles, (addr, pos) -> doubleHandle.set(addr, pos, (double)(long)pos));
231
232 Consumer<MemoryAddress> byteChecker =
233 (base) -> checkBytes(base, bytes, byteHandle::get, bb -> bb, TestNative::getByteBuffer, TestNative::getByteRaw);
234 Consumer<MemoryAddress> charChecker =
235 (base) -> checkBytes(base, chars, charHandle::get, ByteBuffer::asCharBuffer, TestNative::getCharBuffer, TestNative::getCharRaw);
236 Consumer<MemoryAddress> shortChecker =
237 (base) -> checkBytes(base, shorts, shortHandle::get, ByteBuffer::asShortBuffer, TestNative::getShortBuffer, TestNative::getShortRaw);
238 Consumer<MemoryAddress> intChecker =
239 (base) -> checkBytes(base, ints, intHandle::get, ByteBuffer::asIntBuffer, TestNative::getIntBuffer, TestNative::getIntRaw);
240 Consumer<MemoryAddress> floatChecker =
241 (base) -> checkBytes(base, floats, floatHandle::get, ByteBuffer::asFloatBuffer, TestNative::getFloatBuffer, TestNative::getFloatRaw);
242 Consumer<MemoryAddress> longChecker =
243 (base) -> checkBytes(base, longs, longHandle::get, ByteBuffer::asLongBuffer, TestNative::getLongBuffer, TestNative::getLongRaw);
244 Consumer<MemoryAddress> doubleChecker =
245 (base) -> checkBytes(base, doubles, doubleHandle::get, ByteBuffer::asDoubleBuffer, TestNative::getDoubleBuffer, TestNative::getDoubleRaw);
246
247 return new Object[][]{
248 {byteChecker, byteInitializer, bytes},
249 {charChecker, charInitializer, chars},
250 {shortChecker, shortInitializer, shorts},
251 {intChecker, intInitializer, ints},
252 {floatChecker, floatInitializer, floats},
253 {longChecker, longInitializer, longs},
254 {doubleChecker, doubleInitializer, doubles}
255 };
256 }
257
258 @DataProvider(name = "buffers")
259 public Object[][] buffers() {
260 return new Object[][] {
261 { (Function<ByteBuffer, Buffer>)bb -> bb, 1 },
262 { (Function<ByteBuffer, Buffer>)ByteBuffer::asCharBuffer, 2 },
263 { (Function<ByteBuffer, Buffer>)ByteBuffer::asShortBuffer, 2 },
264 { (Function<ByteBuffer, Buffer>)ByteBuffer::asIntBuffer, 4 },
265 { (Function<ByteBuffer, Buffer>)ByteBuffer::asFloatBuffer, 4 },
266 { (Function<ByteBuffer, Buffer>)ByteBuffer::asLongBuffer, 8 },
267 { (Function<ByteBuffer, Buffer>)ByteBuffer::asDoubleBuffer, 8 },
268 };
269 }
270 }