1 /*
2 * Copyright (c) 2021, 2022, 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 import org.testng.Assert;
24 import org.testng.annotations.Test;
25 import org.testng.annotations.DataProvider;
26
27 import java.nio.ByteOrder;
28 import java.util.Arrays;
29 import java.util.List;
30 import java.util.function.IntFunction;
31 import java.util.function.IntUnaryOperator;
32
33 import java.lang.foreign.MemorySegment;
34 import jdk.incubator.vector.*;
35 import jdk.internal.vm.annotation.ForceInline;
36
37 /*
38 * @test id=ZSinglegen
39 * @bug 8260473
40 * @requires vm.gc.ZSinglegen
41 * @modules jdk.incubator.vector
42 * @modules java.base/jdk.internal.vm.annotation
43 * @run testng/othervm -XX:CompileCommand=compileonly,jdk/incubator/vector/ByteVector.fromMemorySegment
44 * -XX:-TieredCompilation -XX:CICompilerCount=1 -XX:+UseZGC -XX:-ZGenerational -Xbatch -Xmx256m VectorRebracket128Test
45 */
46
47 /*
48 * @test id=ZGenerational
49 * @bug 8260473
50 * @requires vm.gc.ZGenerational
51 * @modules jdk.incubator.vector
52 * @modules java.base/jdk.internal.vm.annotation
53 * @run testng/othervm -XX:CompileCommand=compileonly,jdk/incubator/vector/ByteVector.fromMemorySegment
54 * -XX:-TieredCompilation -XX:CICompilerCount=1 -XX:+UseZGC -XX:+ZGenerational -Xbatch -Xmx256m VectorRebracket128Test
55 */
56
57 @Test
58 public class VectorRebracket128Test {
59 static final int INVOC_COUNT = Integer.getInteger("jtreg.compiler.vectorapi.vectorrebracket128test.loop-iterations", 1000);
60 static final int NUM_ITER = 200 * INVOC_COUNT;
61
62 static final VectorSpecies<Integer> ispec128 = IntVector.SPECIES_128;
63 static final VectorSpecies<Float> fspec128 = FloatVector.SPECIES_128;
64 static final VectorSpecies<Long> lspec128 = LongVector.SPECIES_128;
65 static final VectorSpecies<Double> dspec128 = DoubleVector.SPECIES_128;
66 static final VectorSpecies<Byte> bspec128 = ByteVector.SPECIES_128;
67 static final VectorSpecies<Short> sspec128 = ShortVector.SPECIES_128;
68
69 static <T> IntFunction<T> withToString(String s, IntFunction<T> f) {
70 return new IntFunction<T>() {
71 @Override
72 public T apply(int v) {
73 return f.apply(v);
74 }
75
76 @Override
77 public String toString() {
78 return s;
79 }
80 };
81 }
82
83 interface ToByteF {
84 byte apply(int i);
85 }
86
87 static byte[] fill_byte(int s , ToByteF f) {
88 return fill_byte(new byte[s], f);
89 }
90
91 static byte[] fill_byte(byte[] a, ToByteF f) {
92 for (int i = 0; i < a.length; i++) {
93 a[i] = f.apply(i);
94 }
95 return a;
96 }
97
98 static final List<IntFunction<byte[]>> BYTE_GENERATORS = List.of(
99 withToString("byte(i)", (int s) -> {
100 return fill_byte(s, i -> (byte)(i+1));
101 })
102 );
103
104 @DataProvider
105 public Object[][] byteUnaryOpProvider() {
106 return BYTE_GENERATORS.stream().
107 map(f -> new Object[]{f}).
108 toArray(Object[][]::new);
109 }
110
111 static
112 void checkPartialResult(VectorSpecies<?> a, VectorSpecies<?> b,
113 byte[] input, byte[] output, byte[] expected,
114 int part, int origin) {
115 if (Arrays.equals(expected, output)) {
116 return;
117 }
118 int block;
119 block = Math.min(a.vectorByteSize(), b.vectorByteSize());
120
121 System.out.println("input: "+Arrays.toString(input));
122 System.out.println("Failing with "+a+"->"+b+
123 " (reinterpret)"+
124 ", block=" + block +
125 ", part=" + part +
126 ", origin=" + origin);
127 System.out.println("expect: "+Arrays.toString(expected));
128 System.out.println("output: "+Arrays.toString(output));
129 Assert.assertEquals(expected, output);
130 }
131
132 @ForceInline
133 static <E,F>
134 void testVectorRebracket(VectorSpecies<E> a, VectorSpecies<F> b,
135 byte[] input, byte[] output,
136 MemorySegment msInput, MemorySegment msOutput) {
137 Vector<E> av = a.fromMemorySegment(msInput, 0, ByteOrder.nativeOrder());
138 int block;
139 assert(input.length == output.length);
140
141 block = Math.min(a.vectorByteSize(), b.vectorByteSize());
142 if (false)
143 System.out.println("testing "+a+"->"+b+
144 (false?" (lanewise)":" (reinterpret)")+
145 ", block=" + block);
146 byte[] expected;
147 int origin;
148
149 int part = 0;
150 Vector<F> bv = av.reinterpretShape(b, part);
151 bv.intoMemorySegment(msOutput, 0, ByteOrder.nativeOrder());
152 // in-place copy, no resize
153 expected = input;
154 origin = 0;
155 checkPartialResult(a, b, input, output, expected,
156 part, origin);
157
158 }
159
160 @Test(dataProvider = "byteUnaryOpProvider")
161 static void testRebracket128(IntFunction<byte[]> fa) {
162 byte[] barr = fa.apply(128/Byte.SIZE);
163 byte[] bout = new byte[barr.length];
164 MemorySegment msin = MemorySegment.ofArray(barr);
165 MemorySegment msout = MemorySegment.ofArray(bout);
166 for (int i = 0; i < NUM_ITER; i++) {
167 testVectorRebracket(bspec128, bspec128, barr, bout, msin, msout);
168 testVectorRebracket(bspec128, sspec128, barr, bout, msin, msout);
169 testVectorRebracket(bspec128, ispec128, barr, bout, msin, msout);
170 }
171 }
172
173 }