1405 lines
69 KiB
Java
1405 lines
69 KiB
Java
/*
|
|
* Copyright (c) 2024, 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.vectorapi;
|
|
|
|
import compiler.lib.ir_framework.*;
|
|
|
|
import jdk.test.lib.Asserts;
|
|
import jdk.incubator.vector.*;
|
|
import java.util.Arrays;
|
|
import java.nio.ByteOrder;
|
|
|
|
/**
|
|
* @test
|
|
* @bug 8325520
|
|
* @library /test/lib /
|
|
* @summary Don't allow folding of Load/Store vectors when using incompatible indices or masks
|
|
* @modules jdk.incubator.vector
|
|
*
|
|
* @run driver compiler.vectorapi.VectorGatherMaskFoldingTest
|
|
*/
|
|
|
|
public class VectorGatherMaskFoldingTest {
|
|
// Species
|
|
private static final VectorSpecies<Long> L_SPECIES = LongVector.SPECIES_MAX;
|
|
private static final VectorSpecies<Integer> I_SPECIES = IntVector.SPECIES_MAX;
|
|
private static final VectorSpecies<Float> F_SPECIES = FloatVector.SPECIES_MAX;
|
|
private static final VectorSpecies<Double> D_SPECIES = DoubleVector.SPECIES_MAX;
|
|
// Vectors
|
|
private static final LongVector longVector;
|
|
private static final LongVector longVector2;
|
|
private static final IntVector intVector;
|
|
private static final IntVector intVector2;
|
|
private static final DoubleVector doubleVector;
|
|
private static final DoubleVector doubleVector2;
|
|
private static final FloatVector floatVector;
|
|
private static final FloatVector floatVector2;
|
|
// Arrays
|
|
private static final long[] longArray = new long[L_SPECIES.length()];
|
|
private static final long[] longArray2 = new long[L_SPECIES.length()];
|
|
private static final int[] intArray = new int[I_SPECIES.length()];
|
|
private static final int[] intArray2 = new int[I_SPECIES.length()];
|
|
private static final double[] doubleArray = new double[D_SPECIES.length()];
|
|
private static final double[] doubleArray2 = new double[D_SPECIES.length()];
|
|
private static final float[] floatArray = new float[F_SPECIES.length()];
|
|
private static final float[] floatArray2 = new float[F_SPECIES.length()];
|
|
// Indices
|
|
private static final int[] longIndices = new int[L_SPECIES.length()];
|
|
private static final int[] longIndices2 = new int[L_SPECIES.length()];
|
|
private static final int[] duplicateLongIndices = new int[L_SPECIES.length()];
|
|
private static final int[] intIndices = new int[I_SPECIES.length()];
|
|
private static final int[] intIndices2 = new int[I_SPECIES.length()];
|
|
private static final int[] duplicateIntIndices = new int[I_SPECIES.length()];
|
|
private static final int[] doubleIndices = new int[D_SPECIES.length()];
|
|
private static final int[] doubleIndices2 = new int[D_SPECIES.length()];
|
|
private static final int[] duplicateDoubleIndices = new int[D_SPECIES.length()];
|
|
private static final int[] floatIndices = new int[F_SPECIES.length()];
|
|
private static final int[] floatIndices2 = new int[F_SPECIES.length()];
|
|
private static final int[] duplicateFloatIndices = new int[F_SPECIES.length()];
|
|
// Masks
|
|
private static final boolean[] longMask = new boolean[L_SPECIES.length()];
|
|
private static final boolean[] longMask2 = new boolean[L_SPECIES.length()];
|
|
private static final boolean[] intMask = new boolean[I_SPECIES.length()];
|
|
private static final boolean[] intMask2 = new boolean[I_SPECIES.length()];
|
|
private static final boolean[] doubleMask = new boolean[D_SPECIES.length()];
|
|
private static final boolean[] doubleMask2 = new boolean[D_SPECIES.length()];
|
|
private static final boolean[] floatMask = new boolean[F_SPECIES.length()];
|
|
private static final boolean[] floatMask2 = new boolean[F_SPECIES.length()];
|
|
private static final VectorMask<Long> longVectorMask;
|
|
private static final VectorMask<Long> longVectorMask2;
|
|
private static final VectorMask<Integer> intVectorMask;
|
|
private static final VectorMask<Integer> intVectorMask2;
|
|
private static final VectorMask<Double> doubleVectorMask;
|
|
private static final VectorMask<Double> doubleVectorMask2;
|
|
private static final VectorMask<Float> floatVectorMask;
|
|
private static final VectorMask<Float> floatVectorMask2;
|
|
|
|
// Filling vectors/indices/masks
|
|
static {
|
|
for (int i = 0; i < L_SPECIES.length(); i++) {
|
|
longArray[i] = i + 1;
|
|
longArray2[i] = L_SPECIES.length() - i + 1;
|
|
longMask[i] = L_SPECIES.length() > 1 && i % 2 == 0;
|
|
longMask2[i] = i >= L_SPECIES.length() / 2;
|
|
longIndices[i] = (i + L_SPECIES.length() / 2) % L_SPECIES.length();
|
|
longIndices2[i] = (L_SPECIES.length() - i) % L_SPECIES.length();
|
|
duplicateLongIndices[i] = longIndices[i] / 2;
|
|
}
|
|
longVector = LongVector.fromArray(L_SPECIES, longArray, 0);
|
|
longVector2 = LongVector.fromArray(L_SPECIES, longArray2, 0);
|
|
longVectorMask = VectorMask.fromArray(L_SPECIES, longMask, 0);
|
|
longVectorMask2 = VectorMask.fromArray(L_SPECIES, longMask2, 0);
|
|
for (int i = 0; i < I_SPECIES.length(); i++) {
|
|
intArray[i] = i + 1;
|
|
intArray2[i] = I_SPECIES.length() - i + 1;
|
|
intMask[i] = i % 2 == 0;
|
|
intMask2[i] = i >= I_SPECIES.length() / 2;
|
|
intIndices[i] = (i + I_SPECIES.length() / 2) % I_SPECIES.length();
|
|
intIndices2[i] = (I_SPECIES.length() - i) % I_SPECIES.length();
|
|
duplicateIntIndices[i] = intIndices[i] / 2;
|
|
}
|
|
intVector = IntVector.fromArray(I_SPECIES, intArray, 0);
|
|
intVector2 = IntVector.fromArray(I_SPECIES, intArray2, 0);
|
|
intVectorMask = VectorMask.fromArray(I_SPECIES, intMask, 0);
|
|
intVectorMask2 = VectorMask.fromArray(I_SPECIES, intMask2, 0);
|
|
for (int i = 0; i < D_SPECIES.length(); i++) {
|
|
doubleArray[i] = (double) i + 1.0;
|
|
doubleArray2[i] = (double) (D_SPECIES.length() - i) + 1.0;
|
|
doubleMask[i] = D_SPECIES.length() > 1 && i % 2 == 0;
|
|
doubleMask2[i] = i >= D_SPECIES.length() / 2;
|
|
doubleIndices[i] = (i + D_SPECIES.length() / 2) % D_SPECIES.length();
|
|
doubleIndices2[i] = (D_SPECIES.length() - i) % D_SPECIES.length();
|
|
duplicateDoubleIndices[i] = doubleIndices[i] / 2;
|
|
}
|
|
doubleVector = DoubleVector.fromArray(D_SPECIES, doubleArray, 0);
|
|
doubleVector2 = DoubleVector.fromArray(D_SPECIES, doubleArray2, 0);
|
|
doubleVectorMask = VectorMask.fromArray(D_SPECIES, doubleMask, 0);
|
|
doubleVectorMask2 = VectorMask.fromArray(D_SPECIES, doubleMask2, 0);
|
|
for (int i = 0; i < F_SPECIES.length(); i++) {
|
|
floatArray[i] = i + 1.0f;
|
|
floatArray2[i] = F_SPECIES.length() - i + 1.0f;
|
|
floatMask[i] = i % 2 == 0;
|
|
floatMask2[i] = i >= F_SPECIES.length() / 2;
|
|
floatIndices[i] = (i + F_SPECIES.length() / 2) % F_SPECIES.length();
|
|
floatIndices2[i] = (F_SPECIES.length() - i) % F_SPECIES.length();
|
|
duplicateFloatIndices[i] = floatIndices[i] / 2;
|
|
}
|
|
floatVector = FloatVector.fromArray(F_SPECIES, floatArray, 0);
|
|
floatVector2 = FloatVector.fromArray(F_SPECIES, floatArray2, 0);
|
|
floatVectorMask = VectorMask.fromArray(F_SPECIES, floatMask, 0);
|
|
floatVectorMask2 = VectorMask.fromArray(F_SPECIES, floatMask2, 0);
|
|
}
|
|
|
|
// LOAD TESTS
|
|
|
|
// LongVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoLongVectorLoadGatherNotEqualArray() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray2, 0, longIndices, 0);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoLongVectorLoadGatherNotEqualIndices() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices2, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && res.equals(res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_L, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testOneLongVectorLoadGather() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && res.equals(res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_L, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testOneLongVectorLoadMasked() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longVectorMask);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoLongVectorLoadGatherEquals() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoLongVectorLoadMaskedEquals() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0, longVectorMask);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longVectorMask);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoLongVectorLoadMaskedNotEqualMask() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0, longVectorMask);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longVectorMask2);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorLoadGatherMaskedEquals() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0, longVectorMask);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0, longVectorMask);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorLoadGatherMaskedNotEqualMask() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0, longVectorMask);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0, longVectorMask2);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorLoadGatherMaskedNotEqualIndices() {
|
|
LongVector res = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0, longVectorMask);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices2, 0, longVectorMask);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && res.equals(res2));
|
|
}
|
|
|
|
|
|
// IntVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoIntVectorLoadGatherNotEqualArray() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray2, 0, intIndices, 0);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoIntVectorLoadGatherNotEqualIndices() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices2, 0);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_I, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testOneIntVectorLoadGather() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_I, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testOneIntVectorLoadMasked() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intVectorMask);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoIntVectorLoadGatherEquals() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoIntVectorLoadMaskedEquals() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0, intVectorMask);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intVectorMask);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoIntVectorLoadMaskedNotEqualMask() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0, intVectorMask);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intVectorMask2);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorLoadGatherMaskedEquals() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0, intVectorMask);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0, intVectorMask);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorLoadGatherMaskedNotEqualMask() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0, intVectorMask);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0, intVectorMask2);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorLoadGatherMaskedNotEqualIndices() {
|
|
IntVector res = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0, intVectorMask);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices2, 0, intVectorMask);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
|
|
// DoubleVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorLoadGatherNotEqualArray() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray2, 0, doubleIndices, 0);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorLoadGatherNotEqualIndices() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices2, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && res.equals(res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_D, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorLoadGather() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && res.equals(res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_D, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorLoadMasked() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleVectorMask);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorLoadGatherEquals() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorLoadMaskedEquals() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleVectorMask);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleVectorMask);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorLoadMaskedNotEqualMask() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleVectorMask);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleVectorMask2);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorLoadGatherMaskedEquals() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0, doubleVectorMask);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0, doubleVectorMask);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorLoadGatherMaskedNotEqualMask() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0, doubleVectorMask);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0, doubleVectorMask2);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorLoadGatherMaskedNotEqualIndices() {
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0, doubleVectorMask);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices2, 0, doubleVectorMask);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && res.equals(res2));
|
|
}
|
|
|
|
|
|
// FloatVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorLoadGatherNotEqualArray() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray2, 0, floatIndices, 0);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorLoadGatherNotEqualIndices() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices2, 0);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_F, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testOneFloatVectorLoadGather() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_F, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testOneFloatVectorLoadMasked() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatVectorMask);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorLoadGatherEquals() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorLoadMaskedEquals() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatVectorMask);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatVectorMask);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx2", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorLoadMaskedNotEqualMask() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatVectorMask);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatVectorMask2);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorLoadGatherMaskedEquals() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0, floatVectorMask);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0, floatVectorMask);
|
|
Asserts.assertEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorLoadGatherMaskedNotEqualMask() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0, floatVectorMask);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0, floatVectorMask2);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.LOAD_VECTOR_GATHER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorLoadGatherMaskedNotEqualIndices() {
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0, floatVectorMask);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices2, 0, floatVectorMask);
|
|
Asserts.assertNotEquals(res, res2);
|
|
}
|
|
|
|
|
|
// STORE TESTS
|
|
|
|
// LongVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorStoreScatterNotEqualVector() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longIndices, 0);
|
|
longVector2.intoArray(res2, 0, longIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorStoreScatterNotEqualIndices() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longIndices, 0);
|
|
longVector.intoArray(res2, 0, longIndices2, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.STORE_VECTOR_SCATTER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorStoreScatter() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0);
|
|
longVector.intoArray(res2, 0, longIndices, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.STORE_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorStoreMasked() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0);
|
|
longVector.intoArray(res2, 0, longVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorStoreScatterEquals() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longIndices, 0);
|
|
longVector.intoArray(res2, 0, longIndices, 0);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorStoreMaskedEquals() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longVectorMask);
|
|
longVector.intoArray(res2, 0, longVectorMask);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorStoreMaskedNotEqualMask() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longVectorMask);
|
|
longVector.intoArray(res2, 0, longVectorMask2);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorStoreScatterMaskedEquals() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longIndices, 0, longVectorMask);
|
|
longVector.intoArray(res2, 0, longIndices, 0, longVectorMask);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorStoreScatterMaskedNotEqualMask() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longIndices, 0, longVectorMask);
|
|
longVector.intoArray(res2, 0, longIndices, 0, longVectorMask2);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoLongVectorStoreScatterMaskedNotEqualIndices() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
long[] res2 = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longIndices, 0, longVectorMask);
|
|
longVector.intoArray(res2, 0, longIndices2, 0, longVectorMask);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && Arrays.equals(res, res2));
|
|
}
|
|
|
|
|
|
// IntVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorStoreScatterNotEqualVector() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intIndices, 0);
|
|
intVector2.intoArray(res2, 0, intIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorStoreScatterNotEqualIndices() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intIndices, 0);
|
|
intVector.intoArray(res2, 0, intIndices2, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.STORE_VECTOR_SCATTER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorStoreScatter() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0);
|
|
intVector.intoArray(res2, 0, intIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.STORE_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorStoreMasked() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0);
|
|
intVector.intoArray(res2, 0, intVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorStoreScatterEquals() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intIndices, 0);
|
|
intVector.intoArray(res2, 0, intIndices, 0);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorStoreMaskedEquals() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intVectorMask);
|
|
intVector.intoArray(res2, 0, intVectorMask);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorStoreMaskedNotEqualMask() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intVectorMask);
|
|
intVector.intoArray(res2, 0, intVectorMask2);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorStoreScatterMaskedEquals() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intIndices, 0, intVectorMask);
|
|
intVector.intoArray(res2, 0, intIndices, 0, intVectorMask);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorStoreScatterMaskedNotEqualMask() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intIndices, 0, intVectorMask);
|
|
intVector.intoArray(res2, 0, intIndices, 0, intVectorMask2);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoIntVectorStoreScatterMaskedNotEqualIndices() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
int[] res2 = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intIndices, 0, intVectorMask);
|
|
intVector.intoArray(res2, 0, intIndices2, 0, intVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
|
|
// DoubleVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorStoreScatterNotEqualVector() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleIndices, 0);
|
|
doubleVector2.intoArray(res2, 0, doubleIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorStoreScatterNotEqualIndices() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleIndices, 0);
|
|
doubleVector.intoArray(res2, 0, doubleIndices2, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.STORE_VECTOR_SCATTER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorStoreScatter() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0);
|
|
doubleVector.intoArray(res2, 0, doubleIndices, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.STORE_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorStoreMasked() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0);
|
|
doubleVector.intoArray(res2, 0, doubleVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorStoreScatterEquals() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleIndices, 0);
|
|
doubleVector.intoArray(res2, 0, doubleIndices, 0);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorStoreMaskedEquals() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleVectorMask);
|
|
doubleVector.intoArray(res2, 0, doubleVectorMask);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorStoreMaskedNotEqualMask() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleVectorMask);
|
|
doubleVector.intoArray(res2, 0, doubleVectorMask2);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorStoreScatterMaskedEquals() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleIndices, 0, doubleVectorMask);
|
|
doubleVector.intoArray(res2, 0, doubleIndices, 0, doubleVectorMask);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorStoreScatterMaskedNotEqualMask() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleIndices, 0, doubleVectorMask);
|
|
doubleVector.intoArray(res2, 0, doubleIndices, 0, doubleVectorMask2);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoDoubleVectorStoreScatterMaskedNotEqualIndices() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
double[] res2 = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleIndices, 0, doubleVectorMask);
|
|
doubleVector.intoArray(res2, 0, doubleIndices2, 0, doubleVectorMask);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && Arrays.equals(res, res2));
|
|
}
|
|
|
|
|
|
// FloatVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorStoreScatterNotEqualVector() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatIndices, 0);
|
|
floatVector2.intoArray(res2, 0, floatIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorStoreScatterNotEqualIndices() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatIndices, 0);
|
|
floatVector.intoArray(res2, 0, floatIndices2, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.STORE_VECTOR_SCATTER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorStoreScatter() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0);
|
|
floatVector.intoArray(res2, 0, floatIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.STORE_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorStoreMasked() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0);
|
|
floatVector.intoArray(res2, 0, floatVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorStoreScatterEquals() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatIndices, 0);
|
|
floatVector.intoArray(res2, 0, floatIndices, 0);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorStoreMaskedEquals() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatVectorMask);
|
|
floatVector.intoArray(res2, 0, floatVectorMask);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorStoreMaskedNotEqualMask() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatVectorMask);
|
|
floatVector.intoArray(res2, 0, floatVectorMask2);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorStoreScatterMaskedEquals() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatIndices, 0, floatVectorMask);
|
|
floatVector.intoArray(res2, 0, floatIndices, 0, floatVectorMask);
|
|
Asserts.assertTrue(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorStoreScatterMaskedNotEqualMask() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatIndices, 0, floatVectorMask);
|
|
floatVector.intoArray(res2, 0, floatIndices, 0, floatVectorMask2);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER_MASKED, ">= 2" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testTwoFloatVectorStoreScatterMaskedNotEqualIndices() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
float[] res2 = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatIndices, 0, floatVectorMask);
|
|
floatVector.intoArray(res2, 0, floatIndices2, 0, floatVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, res2));
|
|
}
|
|
|
|
|
|
// STORE - LOAD tests
|
|
|
|
// LongVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorStoreLoadGather() {
|
|
long[] array = new long[L_SPECIES.length()];
|
|
longVector.intoArray(array, 0);
|
|
LongVector res = LongVector.fromArray(L_SPECIES, array, 0, longIndices, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && res.equals(longVector));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_L, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorStoreScatterLoad() {
|
|
long[] array = new long[L_SPECIES.length()];
|
|
longVector.intoArray(array, 0, longIndices, 0);
|
|
LongVector res = LongVector.fromArray(L_SPECIES, array, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && res.equals(longVector));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorStoreLoadMasked() {
|
|
long[] array = new long[L_SPECIES.length()];
|
|
longVector.intoArray(array, 0);
|
|
LongVector res = LongVector.fromArray(L_SPECIES, array, 0, longVectorMask);
|
|
Asserts.assertNotEquals(res, longVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_L, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorStoreMaskedLoad() {
|
|
long[] array = new long[L_SPECIES.length()];
|
|
longVector.intoArray(array, 0, longVectorMask);
|
|
LongVector res = LongVector.fromArray(L_SPECIES, array, 0);
|
|
Asserts.assertNotEquals(res, longVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testLongVectorLoadGatherStoreScatterDuplicateIndicesVector() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, duplicateLongIndices, 0);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, res, 0, duplicateLongIndices, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && res2.equals(longVector));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testLongVectorStoreLoadMaskedVector() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0, longVectorMask);
|
|
LongVector res2 = LongVector.fromArray(L_SPECIES, res, 0, longVectorMask);
|
|
Asserts.assertNotEquals(res2, longVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_L, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testStoreLoadLongVectorDifferentSpeciesVector() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
longVector.intoArray(res, 0);
|
|
LongVector res2 = LongVector.fromArray(LongVector.SPECIES_64, res, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && res2.equals(longVector));
|
|
}
|
|
|
|
|
|
// IntVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorStoreLoadGather() {
|
|
int[] array = new int[I_SPECIES.length()];
|
|
intVector.intoArray(array, 0);
|
|
IntVector res = IntVector.fromArray(I_SPECIES, array, 0, intIndices, 0);
|
|
Asserts.assertNotEquals(res, intVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_I, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorStoreScatterLoad() {
|
|
int[] array = new int[I_SPECIES.length()];
|
|
intVector.intoArray(array, 0, intIndices, 0);
|
|
IntVector res = IntVector.fromArray(I_SPECIES, array, 0);
|
|
Asserts.assertNotEquals(res, intVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorStoreLoadMasked() {
|
|
int[] array = new int[I_SPECIES.length()];
|
|
intVector.intoArray(array, 0);
|
|
IntVector res = IntVector.fromArray(I_SPECIES, array, 0, intVectorMask);
|
|
Asserts.assertNotEquals(res, intVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_I, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorStoreMaskedLoad() {
|
|
int[] array = new int[I_SPECIES.length()];
|
|
intVector.intoArray(array, 0, intVectorMask);
|
|
IntVector res = IntVector.fromArray(I_SPECIES, array, 0);
|
|
Asserts.assertNotEquals(res, intVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testIntVectorLoadGatherStoreScatterDuplicateIndicesVector() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, duplicateIntIndices, 0);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, res, 0, duplicateIntIndices, 0);
|
|
Asserts.assertNotEquals(res2, intVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testIntVectorStoreLoadMaskedVector() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0, intVectorMask);
|
|
IntVector res2 = IntVector.fromArray(I_SPECIES, res, 0, intVectorMask);
|
|
Asserts.assertNotEquals(res2, intVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_I, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testStoreLoadIntVectorDifferentSpeciesVector() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
intVector.intoArray(res, 0);
|
|
IntVector res2 = IntVector.fromArray(IntVector.SPECIES_64, res, 0);
|
|
Asserts.assertNotEquals(res2, intVector);
|
|
}
|
|
|
|
|
|
// DoubleVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorStoreLoadGather() {
|
|
double[] array = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(array, 0);
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, array, 0, doubleIndices, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && res.equals(doubleVector));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_D, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorStoreScatterLoad() {
|
|
double[] array = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(array, 0, doubleIndices, 0);
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, array, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && res.equals(doubleVector));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorStoreLoadMasked() {
|
|
double[] array = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(array, 0);
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, array, 0, doubleVectorMask);
|
|
Asserts.assertNotEquals(res, doubleVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_D, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorStoreMaskedLoad() {
|
|
double[] array = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(array, 0, doubleVectorMask);
|
|
DoubleVector res = DoubleVector.fromArray(D_SPECIES, array, 0);
|
|
Asserts.assertNotEquals(res, doubleVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testDoubleVectorLoadGatherStoreScatterDuplicateIndicesVector() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, duplicateDoubleIndices, 0);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, res, 0, duplicateDoubleIndices, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && res2.equals(doubleVector));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testDoubleVectorStoreLoadMaskedVector() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0, doubleVectorMask);
|
|
DoubleVector res2 = DoubleVector.fromArray(D_SPECIES, res, 0, doubleVectorMask);
|
|
Asserts.assertNotEquals(res2, doubleVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_D, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testStoreLoadDoubleVectorDifferentSpeciesVector() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
doubleVector.intoArray(res, 0);
|
|
DoubleVector res2 = DoubleVector.fromArray(DoubleVector.SPECIES_64, res, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && res2.equals(doubleVector));
|
|
}
|
|
|
|
|
|
// FloatVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorStoreLoadGather() {
|
|
float[] array = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(array, 0);
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, array, 0, floatIndices, 0);
|
|
Asserts.assertNotEquals(res, floatVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_F, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorStoreScatterLoad() {
|
|
float[] array = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(array, 0, floatIndices, 0);
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, array, 0);
|
|
Asserts.assertNotEquals(res, floatVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorStoreLoadMasked() {
|
|
float[] array = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(array, 0);
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, array, 0, floatVectorMask);
|
|
Asserts.assertNotEquals(res, floatVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_F, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorStoreMaskedLoad() {
|
|
float[] array = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(array, 0, floatVectorMask);
|
|
FloatVector res = FloatVector.fromArray(F_SPECIES, array, 0);
|
|
Asserts.assertNotEquals(res, floatVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testFloatVectorLoadGatherStoreScatterDuplicateIndicesVector() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, duplicateFloatIndices, 0);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, res, 0, duplicateFloatIndices, 0);
|
|
Asserts.assertNotEquals(res2, floatVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testFloatVectorStoreLoadMaskedVector() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0, floatVectorMask);
|
|
FloatVector res2 = FloatVector.fromArray(F_SPECIES, res, 0, floatVectorMask);
|
|
Asserts.assertNotEquals(res2, floatVector);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_F, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testStoreLoadFloatVectorDifferentSpeciesVector() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
floatVector.intoArray(res, 0);
|
|
FloatVector res2 = FloatVector.fromArray(FloatVector.SPECIES_64, res, 0);
|
|
Asserts.assertNotEquals(res2, floatVector);
|
|
}
|
|
|
|
|
|
// LOAD - STORE tests
|
|
|
|
// LongVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorLoadGatherStore() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
LongVector vector = LongVector.fromArray(L_SPECIES, longArray, 0, longIndices, 0);
|
|
vector.intoArray(res, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && Arrays.equals(res, longArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_L, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorLoadStoreScatter() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
LongVector vector = LongVector.fromArray(L_SPECIES, longArray, 0);
|
|
vector.intoArray(res, 0, longIndices, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && Arrays.equals(res, longArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorLoadMaskedStore() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
LongVector vector = LongVector.fromArray(L_SPECIES, longArray, 0, longVectorMask);
|
|
vector.intoArray(res, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, longArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_L, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneLongVectorLoadStoreMasked() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
LongVector vector = LongVector.fromArray(L_SPECIES, longArray, 0);
|
|
vector.intoArray(res, 0, longVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, longArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testLongVectorStoreScatterLoadGatherDuplicateIndicesVector() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
LongVector vector = LongVector.fromArray(L_SPECIES, longArray, 0, duplicateLongIndices, 0);
|
|
vector.intoArray(res, 0, duplicateLongIndices, 0);
|
|
Asserts.assertFalse(L_SPECIES.length() != 1 && Arrays.equals(res, longArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testLongVectorLoadMaskedStoreVector() {
|
|
long[] res = new long[L_SPECIES.length()];
|
|
LongVector vector = LongVector.fromArray(L_SPECIES, longArray, 0, longVectorMask);
|
|
vector.intoArray(res, 0, longVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, longArray));
|
|
}
|
|
|
|
|
|
// IntVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorLoadGatherStore() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
IntVector vector = IntVector.fromArray(I_SPECIES, intArray, 0, intIndices, 0);
|
|
vector.intoArray(res, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, intArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_I, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorLoadStoreScatter() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
IntVector vector = IntVector.fromArray(I_SPECIES, intArray, 0);
|
|
vector.intoArray(res, 0, intIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, intArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorLoadMaskedStore() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
IntVector vector = IntVector.fromArray(I_SPECIES, intArray, 0, intVectorMask);
|
|
vector.intoArray(res, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, intArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_I, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneIntVectorLoadStoreMasked() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
IntVector vector = IntVector.fromArray(I_SPECIES, intArray, 0);
|
|
vector.intoArray(res, 0, intVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, intArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testIntVectorStoreScatterLoadGatherDuplicateIndicesVector() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
IntVector vector = IntVector.fromArray(I_SPECIES, intArray, 0, duplicateIntIndices, 0);
|
|
vector.intoArray(res, 0, duplicateIntIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, intArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testIntVectorLoadMaskedStoreVector() {
|
|
int[] res = new int[I_SPECIES.length()];
|
|
IntVector vector = IntVector.fromArray(I_SPECIES, intArray, 0, intVectorMask);
|
|
vector.intoArray(res, 0, intVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, intArray));
|
|
}
|
|
|
|
|
|
// DoubleVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorLoadGatherStore() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
DoubleVector vector = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleIndices, 0);
|
|
vector.intoArray(res, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && Arrays.equals(res, doubleArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_D, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorLoadStoreScatter() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
DoubleVector vector = DoubleVector.fromArray(D_SPECIES, doubleArray, 0);
|
|
vector.intoArray(res, 0, doubleIndices, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && Arrays.equals(res, doubleArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorLoadMaskedStore() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
DoubleVector vector = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleVectorMask);
|
|
vector.intoArray(res, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, doubleArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_D, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneDoubleVectorLoadStoreMasked() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
DoubleVector vector = DoubleVector.fromArray(D_SPECIES, doubleArray, 0);
|
|
vector.intoArray(res, 0, doubleVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, doubleArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testDoubleVectorStoreScatterLoadGatherDuplicateIndicesVector() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
DoubleVector vector = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, duplicateDoubleIndices, 0);
|
|
vector.intoArray(res, 0, duplicateDoubleIndices, 0);
|
|
Asserts.assertFalse(D_SPECIES.length() != 1 && Arrays.equals(res, doubleArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testDoubleVectorLoadMaskedStoreVector() {
|
|
double[] res = new double[D_SPECIES.length()];
|
|
DoubleVector vector = DoubleVector.fromArray(D_SPECIES, doubleArray, 0, doubleVectorMask);
|
|
vector.intoArray(res, 0, doubleVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, doubleArray));
|
|
}
|
|
|
|
|
|
// FloatVector tests
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorLoadGatherStore() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
FloatVector vector = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatIndices, 0);
|
|
vector.intoArray(res, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, floatArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_F, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorLoadStoreScatter() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
FloatVector vector = FloatVector.fromArray(F_SPECIES, floatArray, 0);
|
|
vector.intoArray(res, 0, floatIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, floatArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorLoadMaskedStore() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
FloatVector vector = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatVectorMask);
|
|
vector.intoArray(res, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, floatArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_F, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testOneFloatVectorLoadStoreMasked() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
FloatVector vector = FloatVector.fromArray(F_SPECIES, floatArray, 0);
|
|
vector.intoArray(res, 0, floatVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, floatArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_SCATTER, ">= 1", IRNode.LOAD_VECTOR_GATHER, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testFloatVectorStoreScatterLoadGatherDuplicateIndicesVector() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
FloatVector vector = FloatVector.fromArray(F_SPECIES, floatArray, 0, duplicateFloatIndices, 0);
|
|
vector.intoArray(res, 0, duplicateFloatIndices, 0);
|
|
Asserts.assertFalse(Arrays.equals(res, floatArray));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.STORE_VECTOR_MASKED, ">= 1", IRNode.LOAD_VECTOR_MASKED, ">= 1" }, applyIfCPUFeatureOr = {"avx512", "true", "sve", "true"})
|
|
public static void testFloatVectorLoadMaskedStoreVector() {
|
|
float[] res = new float[F_SPECIES.length()];
|
|
FloatVector vector = FloatVector.fromArray(F_SPECIES, floatArray, 0, floatVectorMask);
|
|
vector.intoArray(res, 0, floatVectorMask);
|
|
Asserts.assertFalse(Arrays.equals(res, floatArray));
|
|
}
|
|
|
|
|
|
public static void main(String[] args) {
|
|
TestFramework testFramework = new TestFramework();
|
|
testFramework.setDefaultWarmup(10000)
|
|
.addFlags("--add-modules=jdk.incubator.vector", "-XX:+IgnoreUnrecognizedVMOptions", "-XX:+IncrementalInlineForceCleanup")
|
|
.start();
|
|
}
|
|
}
|