289 lines
12 KiB
Java
289 lines
12 KiB
Java
/*
|
|
* Copyright (c) 2021, 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.
|
|
*/
|
|
|
|
package compiler.intrinsics;
|
|
|
|
/*
|
|
* @test
|
|
* @requires vm.opt.final.UseVectorizedMismatchIntrinsic == true
|
|
* @modules java.base/jdk.internal.misc
|
|
* java.base/jdk.internal.util
|
|
*
|
|
* @run main/othervm -XX:CompileCommand=quiet -XX:CompileCommand=compileonly,*::test*
|
|
* -Xbatch -XX:-TieredCompilation
|
|
* -XX:UseAVX=3
|
|
* compiler.intrinsics.VectorizedMismatchTest
|
|
*
|
|
* @run main/othervm -XX:CompileCommand=quiet -XX:CompileCommand=compileonly,*::test*
|
|
* -Xbatch -XX:-TieredCompilation
|
|
* -XX:+UnlockDiagnosticVMOptions -XX:UseAVX=3 -XX:AVX3Threshold=0
|
|
* compiler.intrinsics.VectorizedMismatchTest
|
|
*/
|
|
|
|
import jdk.internal.misc.Unsafe;
|
|
import jdk.internal.util.ArraysSupport;
|
|
|
|
public class VectorizedMismatchTest {
|
|
private boolean[] boolean_a = new boolean[128];
|
|
private boolean[] boolean_b = new boolean[128];
|
|
|
|
int testBooleanConstantLength(int length) {
|
|
boolean[] obja = boolean_a;
|
|
boolean[] objb = boolean_b;
|
|
long offset = Unsafe.ARRAY_BOOLEAN_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_BOOLEAN_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
|
|
}
|
|
|
|
int testBooleanConstantLength0() { return testBooleanConstantLength(0); }
|
|
int testBooleanConstantLength1() { return testBooleanConstantLength(1); }
|
|
int testBooleanConstantLength64() { return testBooleanConstantLength(64); }
|
|
int testBooleanConstantLength128() { return testBooleanConstantLength(128); }
|
|
|
|
/* ==================================================================================== */
|
|
|
|
private byte[] byte_a = new byte[128];
|
|
private byte[] byte_b = new byte[128];
|
|
|
|
int testByteConstantLength(int length) {
|
|
byte[] obja = byte_a;
|
|
byte[] objb = byte_b;
|
|
long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
|
|
}
|
|
|
|
int testByteConstantLength0() { return testByteConstantLength(0); }
|
|
int testByteConstantLength1() { return testByteConstantLength(1); }
|
|
int testByteConstantLength64() { return testByteConstantLength(64); }
|
|
int testByteConstantLength128() { return testByteConstantLength(128); }
|
|
|
|
/* ==================================================================================== */
|
|
|
|
private short[] short_a = new short[64];
|
|
private short[] short_b = new short[64];
|
|
|
|
int testShortConstantLength(int length) {
|
|
short[] obja = short_a;
|
|
short[] objb = short_b;
|
|
long offset = Unsafe.ARRAY_SHORT_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_SHORT_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
|
|
}
|
|
|
|
int testShortConstantLength0() { return testShortConstantLength(0); }
|
|
int testShortConstantLength1() { return testShortConstantLength(1); }
|
|
int testShortConstantLength32() { return testShortConstantLength(32); }
|
|
int testShortConstantLength64() { return testShortConstantLength(64); }
|
|
|
|
/* ==================================================================================== */
|
|
|
|
private char[] char_a = new char[64];
|
|
private char[] char_b = new char[64];
|
|
|
|
int testCharConstantLength(int length) {
|
|
char[] obja = char_a;
|
|
char[] objb = char_b;
|
|
long offset = Unsafe.ARRAY_CHAR_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_CHAR_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
|
|
}
|
|
|
|
int testCharConstantLength0() { return testCharConstantLength(0); }
|
|
int testCharConstantLength1() { return testCharConstantLength(1); }
|
|
int testCharConstantLength32() { return testCharConstantLength(32); }
|
|
int testCharConstantLength64() { return testCharConstantLength(64); }
|
|
|
|
/* ==================================================================================== */
|
|
|
|
private int[] int_a = new int[32];
|
|
private int[] int_b = new int[32];
|
|
|
|
int testIntConstantLength(int length) {
|
|
int[] obja = int_a;
|
|
int[] objb = int_b;
|
|
long offset = Unsafe.ARRAY_INT_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_INT_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
|
|
}
|
|
|
|
int testIntConstantLength0() { return testIntConstantLength(0); }
|
|
int testIntConstantLength1() { return testIntConstantLength(1); }
|
|
int testIntConstantLength16() { return testIntConstantLength(16); }
|
|
int testIntConstantLength32() { return testIntConstantLength(32); }
|
|
|
|
/* ==================================================================================== */
|
|
|
|
private float[] float_a = new float[32];
|
|
private float[] float_b = new float[32];
|
|
|
|
int testFloatConstantLength(int length) {
|
|
float[] obja = float_a;
|
|
float[] objb = float_b;
|
|
long offset = Unsafe.ARRAY_FLOAT_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_FLOAT_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
|
|
}
|
|
|
|
int testFloatConstantLength0() { return testFloatConstantLength(0); }
|
|
int testFloatConstantLength1() { return testFloatConstantLength(1); }
|
|
int testFloatConstantLength16() { return testFloatConstantLength(16); }
|
|
int testFloatConstantLength32() { return testFloatConstantLength(32); }
|
|
|
|
/* ==================================================================================== */
|
|
|
|
private long[] long_a = new long[16];
|
|
private long[] long_b = new long[16];
|
|
|
|
int testLongConstantLength(int length) {
|
|
long[] obja = long_a;
|
|
long[] objb = long_b;
|
|
long offset = Unsafe.ARRAY_LONG_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_LONG_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
|
|
}
|
|
|
|
int testLongConstantLength0() { return testLongConstantLength(0); }
|
|
int testLongConstantLength1() { return testLongConstantLength(1); }
|
|
int testLongConstantLength8() { return testLongConstantLength(8); }
|
|
int testLongConstantLength16() { return testLongConstantLength(16); }
|
|
|
|
/* ==================================================================================== */
|
|
|
|
private double[] double_a = new double[16];
|
|
private double[] double_b = new double[16];
|
|
|
|
int testDoubleConstantLength(int length) {
|
|
double[] obja = double_a;
|
|
double[] objb = double_b;
|
|
long offset = Unsafe.ARRAY_DOUBLE_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_DOUBLE_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
|
|
}
|
|
|
|
int testDoubleConstantLength0() { return testDoubleConstantLength(0); }
|
|
int testDoubleConstantLength1() { return testDoubleConstantLength(1); }
|
|
int testDoubleConstantLength8() { return testDoubleConstantLength(8); }
|
|
int testDoubleConstantLength16() { return testDoubleConstantLength(16); }
|
|
|
|
/* ==================================================================================== */
|
|
|
|
static class ClassInitTest {
|
|
static final int LENGTH = 64;
|
|
static final int RESULT;
|
|
static {
|
|
byte[] arr1 = new byte[LENGTH];
|
|
byte[] arr2 = new byte[LENGTH];
|
|
for (int i = 0; i < 20_000; i++) {
|
|
test(arr1, arr2);
|
|
}
|
|
RESULT = test(arr1, arr2);
|
|
}
|
|
|
|
static int test(byte[] obja, byte[] objb) {
|
|
long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE;
|
|
return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, LENGTH, scale); // LENGTH is not considered a constant
|
|
}
|
|
}
|
|
|
|
int testConstantBeingInitialized() {
|
|
return ClassInitTest.RESULT; // trigger class initialization
|
|
}
|
|
|
|
/* ==================================================================================== */
|
|
|
|
int testLoopUnswitch(int length) {
|
|
long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE;
|
|
|
|
int acc = 0;
|
|
for (int i = 0; i < 32; i++) {
|
|
acc += ArraysSupport.vectorizedMismatch(byte_a, offset, byte_b, offset, length, scale);
|
|
}
|
|
return acc;
|
|
}
|
|
|
|
int testLoopHoist(int length, int stride) {
|
|
long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
|
|
int scale = ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE;
|
|
|
|
int acc = 0;
|
|
|
|
for (int i = 0; i < 32; i += stride) {
|
|
acc += ArraysSupport.vectorizedMismatch(byte_a, offset, byte_b, offset, length, scale);
|
|
}
|
|
return acc;
|
|
}
|
|
|
|
/* ==================================================================================== */
|
|
|
|
public static void main(String[] args) {
|
|
VectorizedMismatchTest t = new VectorizedMismatchTest();
|
|
for (int i = 0; i < 20_000; i++) {
|
|
t.testBooleanConstantLength0();
|
|
t.testBooleanConstantLength1();
|
|
t.testBooleanConstantLength64();
|
|
t.testBooleanConstantLength128();
|
|
|
|
t.testByteConstantLength0();
|
|
t.testByteConstantLength1();
|
|
t.testByteConstantLength64();
|
|
t.testByteConstantLength128();
|
|
|
|
t.testShortConstantLength0();
|
|
t.testShortConstantLength1();
|
|
t.testShortConstantLength32();
|
|
t.testShortConstantLength64();
|
|
|
|
t.testCharConstantLength0();
|
|
t.testCharConstantLength1();
|
|
t.testCharConstantLength32();
|
|
t.testCharConstantLength64();
|
|
|
|
t.testIntConstantLength0();
|
|
t.testIntConstantLength1();
|
|
t.testIntConstantLength16();
|
|
t.testIntConstantLength32();
|
|
|
|
t.testFloatConstantLength0();
|
|
t.testFloatConstantLength1();
|
|
t.testFloatConstantLength16();
|
|
t.testFloatConstantLength32();
|
|
|
|
t.testLongConstantLength0();
|
|
t.testLongConstantLength1();
|
|
t.testLongConstantLength8();
|
|
t.testLongConstantLength16();
|
|
|
|
t.testDoubleConstantLength0();
|
|
t.testDoubleConstantLength1();
|
|
t.testDoubleConstantLength8();
|
|
t.testDoubleConstantLength16();
|
|
|
|
t.testLoopUnswitch(32);
|
|
t.testLoopHoist(128, 2);
|
|
}
|
|
}
|
|
}
|