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