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 * @run testng TestMemoryCopy
28 */
29
30 import jdk.incubator.foreign.MemoryAddress;
31 import jdk.incubator.foreign.MemoryLayouts;
32 import jdk.incubator.foreign.MemorySegment;
33 import org.testng.annotations.DataProvider;
34 import org.testng.annotations.Test;
35
36 import java.lang.invoke.VarHandle;
37 import java.util.ArrayList;
38 import java.util.List;
39 import java.util.function.IntFunction;
40
41 import static org.testng.Assert.*;
42
43 public class TestMemoryCopy {
44
45 final static VarHandle BYTE_HANDLE = MemoryLayouts.JAVA_BYTE.varHandle(byte.class);
46
47 @Test(dataProvider = "slices")
48 public void testCopy(SegmentSlice s1, SegmentSlice s2) {
49 MemoryAddress addr1 = s1.segment.baseAddress();
50 MemoryAddress addr2 = s2.segment.baseAddress();
51 int size = Math.min(s1.size(), s2.size());
52 //prepare source and target segments
53 for (int i = 0 ; i < size ; i++) {
54 BYTE_HANDLE.set(addr2.addOffset(i), (byte)0);
55 }
56 for (int i = 0 ; i < size ; i++) {
57 BYTE_HANDLE.set(addr1.addOffset(i), (byte) i);
58 }
59 //perform copy
60 s2.segment.copyFrom(s1.segment.asSlice(0, size));
61 //check that copy actually worked
62 for (int i = 0 ; i < size ; i++) {
63 assertEquals((byte)i, BYTE_HANDLE.get(addr2.addOffset(i)));
64 }
65 }
66
67 static class SegmentSlice {
68
69 enum Kind {
70 NATIVE(MemorySegment::allocateNative),
71 ARRAY(i -> MemorySegment.ofArray(new byte[i]));
72
73 final IntFunction<MemorySegment> segmentFactory;
74
75 Kind(IntFunction<MemorySegment> segmentFactory) {
76 this.segmentFactory = segmentFactory;
77 }
78
79 MemorySegment makeSegment(int elems) {
80 return segmentFactory.apply(elems);
81 }
82 }
83
84 final Kind kind;
85 final int first;
86 final int last;
87 final MemorySegment segment;
88
89 public SegmentSlice(Kind kind, int first, int last, MemorySegment segment) {
90 this.kind = kind;
91 this.first = first;
92 this.last = last;
93 this.segment = segment;
94 }
95
96 int size() {
97 return last - first + 1;
98 }
99 }
100
101 @DataProvider(name = "slices")
102 static Object[][] slices() {
103 int[] sizes = { 16, 8, 4, 2, 1 };
104 List<SegmentSlice> slices = new ArrayList<>();
105 for (SegmentSlice.Kind kind : SegmentSlice.Kind.values()) {
106 MemorySegment segment = kind.makeSegment(16);
107 //compute all slices
108 for (int size : sizes) {
109 for (int index = 0 ; index < 16 ; index += size) {
110 MemorySegment slice = segment.asSlice(index, size);
111 slices.add(new SegmentSlice(kind, index, index + size - 1, slice));
112 }
113 }
114 }
115 Object[][] sliceArray = new Object[slices.size() * slices.size()][];
116 for (int i = 0 ; i < slices.size() ; i++) {
117 for (int j = 0 ; j < slices.size() ; j++) {
118 sliceArray[i * slices.size() + j] = new Object[] { slices.get(i), slices.get(j) };
119 }
120 }
121 return sliceArray;
122 }
123 }