5573 lines
206 KiB
Java
5573 lines
206 KiB
Java
/*
|
|
* Copyright (c) 2018, 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.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @modules jdk.incubator.vector
|
|
* @run testng/othervm -ea -esa -Xbatch -XX:-TieredCompilation Int256VectorTests
|
|
*/
|
|
|
|
// -- This file was mechanically generated: Do not edit! -- //
|
|
|
|
import jdk.incubator.vector.VectorShape;
|
|
import jdk.incubator.vector.VectorSpecies;
|
|
import jdk.incubator.vector.VectorShuffle;
|
|
import jdk.incubator.vector.VectorMask;
|
|
import jdk.incubator.vector.VectorOperators;
|
|
import jdk.incubator.vector.Vector;
|
|
|
|
import jdk.incubator.vector.IntVector;
|
|
|
|
import org.testng.Assert;
|
|
import org.testng.annotations.DataProvider;
|
|
import org.testng.annotations.Test;
|
|
|
|
import java.lang.Integer;
|
|
import java.util.List;
|
|
import java.util.Arrays;
|
|
import java.util.function.BiFunction;
|
|
import java.util.function.IntFunction;
|
|
import java.util.Objects;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.Stream;
|
|
|
|
@Test
|
|
public class Int256VectorTests extends AbstractVectorTest {
|
|
|
|
static final VectorSpecies<Integer> SPECIES =
|
|
IntVector.SPECIES_256;
|
|
|
|
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
|
|
|
|
|
|
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256);
|
|
|
|
interface FUnOp {
|
|
int apply(int a);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, FUnOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
|
|
}
|
|
}
|
|
|
|
interface FUnArrayOp {
|
|
int[] apply(int a);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, FUnArrayOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(a[i]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(a[i]);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
|
|
+ ", res: " + Arrays.toString(res)
|
|
+ "), at index #" + i);
|
|
}
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, boolean[] mask, FUnOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i], "at index #" + i + ", input = " + a[i] + ", mask = " + mask[i % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
interface FReductionOp {
|
|
int apply(int[] a, int idx);
|
|
}
|
|
|
|
interface FReductionAllOp {
|
|
int apply(int[] a);
|
|
}
|
|
|
|
static void assertReductionArraysEquals(int[] r, int rc, int[] a,
|
|
FReductionOp f, FReductionAllOp fa) {
|
|
int i = 0;
|
|
try {
|
|
Assert.assertEquals(rc, fa.apply(a));
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(r[i], f.apply(a, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
|
|
Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FReductionMaskedOp {
|
|
int apply(int[] a, int idx, boolean[] mask);
|
|
}
|
|
|
|
interface FReductionAllMaskedOp {
|
|
int apply(int[] a, boolean[] mask);
|
|
}
|
|
|
|
static void assertReductionArraysEqualsMasked(int[] r, int rc, int[] a, boolean[] mask,
|
|
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
|
|
int i = 0;
|
|
try {
|
|
Assert.assertEquals(rc, fa.apply(a, mask));
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(r[i], f.apply(a, i, mask));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
|
|
Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FReductionOpLong {
|
|
long apply(int[] a, int idx);
|
|
}
|
|
|
|
interface FReductionAllOpLong {
|
|
long apply(int[] a);
|
|
}
|
|
|
|
static void assertReductionLongArraysEquals(long[] r, long rc, int[] a,
|
|
FReductionOpLong f, FReductionAllOpLong fa) {
|
|
int i = 0;
|
|
try {
|
|
Assert.assertEquals(rc, fa.apply(a));
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(r[i], f.apply(a, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
|
|
Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FReductionMaskedOpLong {
|
|
long apply(int[] a, int idx, boolean[] mask);
|
|
}
|
|
|
|
interface FReductionAllMaskedOpLong {
|
|
long apply(int[] a, boolean[] mask);
|
|
}
|
|
|
|
static void assertReductionLongArraysEqualsMasked(long[] r, long rc, int[] a, boolean[] mask,
|
|
FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
|
|
int i = 0;
|
|
try {
|
|
Assert.assertEquals(rc, fa.apply(a, mask));
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(r[i], f.apply(a, i, mask));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
|
|
Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FBoolReductionOp {
|
|
boolean apply(boolean[] a, int idx);
|
|
}
|
|
|
|
static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(r[i], f.apply(a, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FMaskReductionOp {
|
|
int apply(boolean[] a, int idx);
|
|
}
|
|
|
|
static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(r[i], f.apply(a, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
|
|
}
|
|
}
|
|
|
|
static void assertInsertArraysEquals(int[] r, int[] a, int element, int index) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += 1) {
|
|
if(i%SPECIES.length() == index) {
|
|
Assert.assertEquals(r[i], element);
|
|
} else {
|
|
Assert.assertEquals(r[i], a[i]);
|
|
}
|
|
}
|
|
} catch (AssertionError e) {
|
|
if (i%SPECIES.length() == index) {
|
|
Assert.assertEquals(r[i], element, "at index #" + i);
|
|
} else {
|
|
Assert.assertEquals(r[i], a[i], "at index #" + i);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
|
|
int i = 0, j = 0;
|
|
try {
|
|
for (; i < a.length; i += vector_len) {
|
|
for (j = 0; j < vector_len; j++) {
|
|
Assert.assertEquals(r[i+j], a[i+order[i+j]]);
|
|
}
|
|
}
|
|
} catch (AssertionError e) {
|
|
int idx = i + j;
|
|
Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
|
|
}
|
|
}
|
|
|
|
static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
|
|
int i = 0, j = 0;
|
|
try {
|
|
for (; i < a.length; i += vector_len) {
|
|
for (j = 0; j < vector_len; j++) {
|
|
Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
|
|
}
|
|
}
|
|
} catch (AssertionError e) {
|
|
int idx = i + j;
|
|
Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
|
|
}
|
|
}
|
|
|
|
static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
|
|
int i = 0, j = 0;
|
|
try {
|
|
for (; i < a.length; i += vector_len) {
|
|
for (j = 0; j < vector_len; j++) {
|
|
if (mask[j % SPECIES.length()])
|
|
Assert.assertEquals(r[i+j], a[i+order[i+j]]);
|
|
else
|
|
Assert.assertEquals(r[i+j], (int)0);
|
|
}
|
|
}
|
|
} catch (AssertionError e) {
|
|
int idx = i + j;
|
|
if (mask[j % SPECIES.length()])
|
|
Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
|
|
else
|
|
Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
|
|
int i = 0, j = 0;
|
|
try {
|
|
for (; i < a.length; i += vector_len) {
|
|
for (j = 0; j < vector_len; j++) {
|
|
if (mask[j % SPECIES.length()])
|
|
Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
|
|
else
|
|
Assert.assertEquals(r[i+j], (int)0);
|
|
}
|
|
}
|
|
} catch (AssertionError e) {
|
|
int idx = i + j;
|
|
if (mask[j % SPECIES.length()])
|
|
Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
|
|
else
|
|
Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertBroadcastArraysEquals(int[] r, int[] a) {
|
|
int i = 0;
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
int idx = i;
|
|
for (int j = idx; j < (idx + SPECIES.length()); j++)
|
|
a[j]=a[idx];
|
|
}
|
|
|
|
try {
|
|
for (i = 0; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], a[i]);
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
|
|
}
|
|
}
|
|
|
|
interface FBinOp {
|
|
int apply(int a, int b);
|
|
}
|
|
|
|
interface FBinMaskOp {
|
|
int apply(int a, int b, boolean m);
|
|
|
|
static FBinMaskOp lift(FBinOp f) {
|
|
return (a, b, m) -> m ? f.apply(a, b) : a;
|
|
}
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
|
|
}
|
|
}
|
|
|
|
static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
|
|
"(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
|
|
}
|
|
}
|
|
|
|
static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
|
|
"(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
|
|
}
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
|
|
assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError err) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
|
|
assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
|
|
}
|
|
|
|
static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError err) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
|
|
mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
|
|
", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
|
|
mask[i % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
|
|
assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
|
|
}
|
|
|
|
static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError err) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
|
|
mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
|
|
", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
|
|
mask[i % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertShiftArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
|
|
int i = 0;
|
|
int j = 0;
|
|
try {
|
|
for (; j < a.length; j += SPECIES.length()) {
|
|
for (i = 0; i < SPECIES.length(); i++) {
|
|
Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
|
|
}
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
|
|
}
|
|
}
|
|
|
|
static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
|
|
assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
|
|
}
|
|
|
|
static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
|
|
int i = 0;
|
|
int j = 0;
|
|
try {
|
|
for (; j < a.length; j += SPECIES.length()) {
|
|
for (i = 0; i < SPECIES.length(); i++) {
|
|
Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
|
|
}
|
|
}
|
|
} catch (AssertionError err) {
|
|
Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", input2 = " + b[j] + ", mask = " + mask[i]);
|
|
}
|
|
}
|
|
|
|
interface FTernOp {
|
|
int apply(int a, int b, int c);
|
|
}
|
|
|
|
interface FTernMaskOp {
|
|
int apply(int a, int b, int c, boolean m);
|
|
|
|
static FTernMaskOp lift(FTernOp f) {
|
|
return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
|
|
}
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
|
|
}
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernOp f) {
|
|
assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernMaskOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError err) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
|
|
+ b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
|
|
i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
|
|
c[(i / SPECIES.length()) * SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
|
|
i + ", input1 = " + a[i] + ", input2 = " +
|
|
b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " + c[i]);
|
|
}
|
|
}
|
|
|
|
static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
|
|
FTernOp f) {
|
|
assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
|
|
}
|
|
|
|
static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
|
|
FTernMaskOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
|
|
mask[i % SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError err) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
|
|
mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
|
|
b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
|
|
mask[i % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
|
|
FTernOp f) {
|
|
assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
|
|
}
|
|
|
|
static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
|
|
FTernMaskOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
|
|
mask[i % SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError err) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
|
|
mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
|
|
", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
|
|
", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
|
|
c[(i / SPECIES.length()) * SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
|
|
c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
|
|
+ ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
|
|
c[(i / SPECIES.length()) * SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
|
|
FTernOp f) {
|
|
assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
|
|
}
|
|
|
|
static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
|
|
FTernMaskOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
|
|
c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
|
|
}
|
|
} catch (AssertionError err) {
|
|
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
|
|
c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
|
|
+ i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
|
|
", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
|
|
mask[i % SPECIES.length()]);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
interface FBinArrayOp {
|
|
int apply(int[] a, int b);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, FBinArrayOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i++) {
|
|
Assert.assertEquals(r[i], f.apply(a, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FGatherScatterOp {
|
|
int[] apply(int[] a, int ix, int[] b, int iy);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, FGatherScatterOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(a, i, b, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(a, i, b, i);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref,
|
|
"(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
|
|
+ Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
|
|
+ ", b: "
|
|
+ Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
|
|
+ " at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FGatherMaskedOp {
|
|
int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy);
|
|
}
|
|
|
|
interface FScatterMaskedOp {
|
|
int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(a, i, mask, b, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(a, i, mask, b, i);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref,
|
|
"(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
|
|
+ Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
|
|
+ ", b: "
|
|
+ Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
|
|
+ ", mask: "
|
|
+ Arrays.toString(mask)
|
|
+ " at index #" + i);
|
|
}
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(r, a, i, mask, b, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(r, a, i, mask, b, i);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref,
|
|
"(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
|
|
+ Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
|
|
+ ", b: "
|
|
+ Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
|
|
+ ", r: "
|
|
+ Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
|
|
+ ", mask: "
|
|
+ Arrays.toString(mask)
|
|
+ " at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FLaneOp {
|
|
int[] apply(int[] a, int origin, int idx);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int origin, FLaneOp f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(a, origin, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(a, origin, i);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
|
|
+ ", res: " + Arrays.toString(res)
|
|
+ "), at index #" + i);
|
|
}
|
|
}
|
|
|
|
interface FLaneBop {
|
|
int[] apply(int[] a, int[] b, int origin, int idx);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, FLaneBop f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(a, b, origin, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(a, b, origin, i);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
|
|
+ ", res: " + Arrays.toString(res)
|
|
+ "), at index #" + i
|
|
+ ", at origin #" + origin);
|
|
}
|
|
}
|
|
|
|
interface FLaneMaskedBop {
|
|
int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(a, b, origin, mask, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(a, b, origin, mask, i);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
|
|
+ ", res: " + Arrays.toString(res)
|
|
+ "), at index #" + i
|
|
+ ", at origin #" + origin);
|
|
}
|
|
}
|
|
|
|
interface FLanePartBop {
|
|
int[] apply(int[] a, int[] b, int origin, int part, int idx);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, FLanePartBop f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(a, b, origin, part, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(a, b, origin, part, i);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
|
|
+ ", res: " + Arrays.toString(res)
|
|
+ "), at index #" + i
|
|
+ ", at origin #" + origin
|
|
+ ", with part #" + part);
|
|
}
|
|
}
|
|
|
|
interface FLanePartMaskedBop {
|
|
int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx);
|
|
}
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < a.length; i += SPECIES.length()) {
|
|
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
|
|
f.apply(a, b, origin, part, mask, i));
|
|
}
|
|
} catch (AssertionError e) {
|
|
int[] ref = f.apply(a, b, origin, part, mask, i);
|
|
int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
|
|
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
|
|
+ ", res: " + Arrays.toString(res)
|
|
+ "), at index #" + i
|
|
+ ", at origin #" + origin
|
|
+ ", with part #" + part);
|
|
}
|
|
}
|
|
|
|
|
|
static void assertArraysEquals(int[] r, int[] a, int offs) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < r.length; i++) {
|
|
Assert.assertEquals(r[i], (int)(a[i+offs]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void assertArraysEquals(long[] r, int[] a, int offs) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < r.length; i++) {
|
|
Assert.assertEquals(r[i], (long)(a[i+offs]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
|
|
}
|
|
}
|
|
|
|
static void assertArraysEquals(double[] r, int[] a, int offs) {
|
|
int i = 0;
|
|
try {
|
|
for (; i < r.length; i++) {
|
|
Assert.assertEquals(r[i], (double)(a[i+offs]));
|
|
}
|
|
} catch (AssertionError e) {
|
|
Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
|
|
}
|
|
}
|
|
|
|
|
|
static int bits(int e) {
|
|
return e;
|
|
}
|
|
|
|
static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
|
|
withToString("int[-i * 5]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> (int)(-i * 5));
|
|
}),
|
|
withToString("int[i * 5]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> (int)(i * 5));
|
|
}),
|
|
withToString("int[i + 1]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
|
|
}),
|
|
withToString("int[cornerCaseValue(i)]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> cornerCaseValue(i));
|
|
})
|
|
);
|
|
|
|
// Create combinations of pairs
|
|
// @@@ Might be sensitive to order e.g. div by 0
|
|
static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
|
|
Stream.of(INT_GENERATORS.get(0)).
|
|
flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
|
|
collect(Collectors.toList());
|
|
|
|
@DataProvider
|
|
public Object[][] boolUnaryOpProvider() {
|
|
return BOOL_ARRAY_GENERATORS.stream().
|
|
map(f -> new Object[]{f}).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES =
|
|
INT_GENERATOR_PAIRS.stream().
|
|
flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
|
|
collect(Collectors.toList());
|
|
|
|
@DataProvider
|
|
public Object[][] intBinaryOpProvider() {
|
|
return INT_GENERATOR_PAIRS.stream().map(List::toArray).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intIndexedOpProvider() {
|
|
return INT_GENERATOR_PAIRS.stream().map(List::toArray).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intBinaryOpMaskProvider() {
|
|
return BOOLEAN_MASK_GENERATORS.stream().
|
|
flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
|
|
return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
|
|
})).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intTernaryOpProvider() {
|
|
return INT_GENERATOR_TRIPLES.stream().map(List::toArray).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intTernaryOpMaskProvider() {
|
|
return BOOLEAN_MASK_GENERATORS.stream().
|
|
flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> {
|
|
return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
|
|
})).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intUnaryOpProvider() {
|
|
return INT_GENERATORS.stream().
|
|
map(f -> new Object[]{f}).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intUnaryOpMaskProvider() {
|
|
return BOOLEAN_MASK_GENERATORS.stream().
|
|
flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
|
|
return new Object[] {fa, fm};
|
|
})).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
|
|
|
|
@DataProvider
|
|
public Object[][] maskProvider() {
|
|
return BOOLEAN_MASK_GENERATORS.stream().
|
|
map(f -> new Object[]{f}).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] maskCompareOpProvider() {
|
|
return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] shuffleProvider() {
|
|
return INT_SHUFFLE_GENERATORS.stream().
|
|
map(f -> new Object[]{f}).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] shuffleCompareOpProvider() {
|
|
return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intUnaryOpShuffleProvider() {
|
|
return INT_SHUFFLE_GENERATORS.stream().
|
|
flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
|
|
return new Object[] {fa, fs};
|
|
})).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intUnaryOpShuffleMaskProvider() {
|
|
return BOOLEAN_MASK_GENERATORS.stream().
|
|
flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
|
|
flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
|
|
return new Object[] {fa, fs, fm};
|
|
}))).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
|
|
static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
|
|
withToString("int[i]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> (int)i);
|
|
}),
|
|
withToString("int[i - length / 2]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> (int)(i - (s * BUFFER_REPS / 2)));
|
|
}),
|
|
withToString("int[i + 1]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> (int)(i + 1));
|
|
}),
|
|
withToString("int[i - 2]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> (int)(i - 2));
|
|
}),
|
|
withToString("int[zigZag(i)]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
|
|
}),
|
|
withToString("int[cornerCaseValue(i)]", (int s) -> {
|
|
return fill(s * BUFFER_REPS,
|
|
i -> cornerCaseValue(i));
|
|
})
|
|
);
|
|
|
|
static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS =
|
|
INT_COMPARE_GENERATORS.stream().
|
|
map(fa -> List.of(fa)).
|
|
collect(Collectors.toList());
|
|
|
|
@DataProvider
|
|
public Object[][] intTestOpProvider() {
|
|
return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intTestOpMaskProvider() {
|
|
return BOOLEAN_MASK_GENERATORS.stream().
|
|
flatMap(fm -> INT_TEST_GENERATOR_ARGS.stream().map(lfa -> {
|
|
return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
|
|
})).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
|
|
INT_COMPARE_GENERATORS.stream().
|
|
flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
|
|
collect(Collectors.toList());
|
|
|
|
@DataProvider
|
|
public Object[][] intCompareOpProvider() {
|
|
return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
@DataProvider
|
|
public Object[][] intCompareOpMaskProvider() {
|
|
return BOOLEAN_MASK_GENERATORS.stream().
|
|
flatMap(fm -> INT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
|
|
return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
|
|
})).
|
|
toArray(Object[][]::new);
|
|
}
|
|
|
|
interface ToIntF {
|
|
int apply(int i);
|
|
}
|
|
|
|
static int[] fill(int s , ToIntF f) {
|
|
return fill(new int[s], f);
|
|
}
|
|
|
|
static int[] fill(int[] a, ToIntF f) {
|
|
for (int i = 0; i < a.length; i++) {
|
|
a[i] = f.apply(i);
|
|
}
|
|
return a;
|
|
}
|
|
|
|
static int cornerCaseValue(int i) {
|
|
switch(i % 5) {
|
|
case 0:
|
|
return Integer.MAX_VALUE;
|
|
case 1:
|
|
return Integer.MIN_VALUE;
|
|
case 2:
|
|
return Integer.MIN_VALUE;
|
|
case 3:
|
|
return Integer.MAX_VALUE;
|
|
default:
|
|
return (int)0;
|
|
}
|
|
}
|
|
|
|
static int get(int[] a, int i) {
|
|
return (int) a[i];
|
|
}
|
|
|
|
static final IntFunction<int[]> fr = (vl) -> {
|
|
int length = BUFFER_REPS * vl;
|
|
return new int[length];
|
|
};
|
|
|
|
static final IntFunction<boolean[]> fmr = (vl) -> {
|
|
int length = BUFFER_REPS * vl;
|
|
return new boolean[length];
|
|
};
|
|
|
|
static final IntFunction<long[]> lfr = (vl) -> {
|
|
int length = BUFFER_REPS * vl;
|
|
return new long[length];
|
|
};
|
|
|
|
static void replaceZero(int[] a, int v) {
|
|
for (int i = 0; i < a.length; i++) {
|
|
if (a[i] == 0) {
|
|
a[i] = v;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void replaceZero(int[] a, boolean[] mask, int v) {
|
|
for (int i = 0; i < a.length; i++) {
|
|
if (mask[i % mask.length] && a[i] == 0) {
|
|
a[i] = v;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int ROL_scalar(int a, int b) {
|
|
return Integer.rotateLeft(a, ((int)b));
|
|
}
|
|
|
|
static int ROR_scalar(int a, int b) {
|
|
return Integer.rotateRight(a, ((int)b));
|
|
}
|
|
|
|
static boolean eq(int a, int b) {
|
|
return a == b;
|
|
}
|
|
|
|
static boolean neq(int a, int b) {
|
|
return a != b;
|
|
}
|
|
|
|
static boolean lt(int a, int b) {
|
|
return a < b;
|
|
}
|
|
|
|
static boolean le(int a, int b) {
|
|
return a <= b;
|
|
}
|
|
|
|
static boolean gt(int a, int b) {
|
|
return a > b;
|
|
}
|
|
|
|
static boolean ge(int a, int b) {
|
|
return a >= b;
|
|
}
|
|
|
|
static boolean ult(int a, int b) {
|
|
return Integer.compareUnsigned(a, b) < 0;
|
|
}
|
|
|
|
static boolean ule(int a, int b) {
|
|
return Integer.compareUnsigned(a, b) <= 0;
|
|
}
|
|
|
|
static boolean ugt(int a, int b) {
|
|
return Integer.compareUnsigned(a, b) > 0;
|
|
}
|
|
|
|
static boolean uge(int a, int b) {
|
|
return Integer.compareUnsigned(a, b) >= 0;
|
|
}
|
|
|
|
@Test
|
|
static void smokeTest1() {
|
|
IntVector three = IntVector.broadcast(SPECIES, (byte)-3);
|
|
IntVector three2 = (IntVector) SPECIES.broadcast(-3);
|
|
assert(three.eq(three2).allTrue());
|
|
IntVector three3 = three2.broadcast(1).broadcast(-3);
|
|
assert(three.eq(three3).allTrue());
|
|
int scale = 2;
|
|
Class<?> ETYPE = int.class;
|
|
if (ETYPE == double.class || ETYPE == long.class)
|
|
scale = 1000000;
|
|
else if (ETYPE == byte.class && SPECIES.length() >= 64)
|
|
scale = 1;
|
|
IntVector higher = three.addIndex(scale);
|
|
VectorMask<Integer> m = three.compare(VectorOperators.LE, higher);
|
|
assert(m.allTrue());
|
|
m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE);
|
|
assert(m.allTrue());
|
|
int max = higher.reduceLanes(VectorOperators.MAX);
|
|
assert(max == -3 + scale * (SPECIES.length()-1));
|
|
}
|
|
|
|
private static int[]
|
|
bothToArray(IntVector a, IntVector b) {
|
|
int[] r = new int[a.length() + b.length()];
|
|
a.intoArray(r, 0);
|
|
b.intoArray(r, a.length());
|
|
return r;
|
|
}
|
|
|
|
@Test
|
|
static void smokeTest2() {
|
|
// Do some zipping and shuffling.
|
|
IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
|
|
IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
|
|
Assert.assertEquals(io, io2);
|
|
IntVector a = io.add((int)1); //[1,2]
|
|
IntVector b = a.neg(); //[-1,-2]
|
|
int[] abValues = bothToArray(a,b); //[1,2,-1,-2]
|
|
VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0);
|
|
VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1);
|
|
IntVector zab0 = a.rearrange(zip0,b); //[1,-1]
|
|
IntVector zab1 = a.rearrange(zip1,b); //[2,-2]
|
|
int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
|
|
// manually zip
|
|
int[] manual = new int[zabValues.length];
|
|
for (int i = 0; i < manual.length; i += 2) {
|
|
manual[i+0] = abValues[i/2];
|
|
manual[i+1] = abValues[a.length() + i/2];
|
|
}
|
|
Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
|
|
VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
|
|
VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
|
|
IntVector uab0 = zab0.rearrange(unz0,zab1);
|
|
IntVector uab1 = zab0.rearrange(unz1,zab1);
|
|
int[] abValues1 = bothToArray(uab0, uab1);
|
|
Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
|
|
}
|
|
|
|
static void iotaShuffle() {
|
|
IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
|
|
IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
|
|
Assert.assertEquals(io, io2);
|
|
}
|
|
|
|
@Test
|
|
// Test all shuffle related operations.
|
|
static void shuffleTest() {
|
|
// To test backend instructions, make sure that C2 is used.
|
|
for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
|
|
iotaShuffle();
|
|
}
|
|
}
|
|
|
|
@Test
|
|
void viewAsIntegeralLanesTest() {
|
|
Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
|
|
Assert.assertEquals(asIntegral.species(), SPECIES);
|
|
}
|
|
|
|
@Test
|
|
void viewAsFloatingLanesTest() {
|
|
Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
|
|
VectorSpecies<?> asFloatingSpecies = asFloating.species();
|
|
Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
|
|
Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
|
|
Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
|
|
Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
|
|
}
|
|
|
|
@Test
|
|
// Test div by 0.
|
|
static void bitwiseDivByZeroSmokeTest() {
|
|
try {
|
|
IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
|
|
IntVector b = (IntVector) SPECIES.broadcast(0);
|
|
a.div(b);
|
|
Assert.fail();
|
|
} catch (ArithmeticException e) {
|
|
}
|
|
|
|
try {
|
|
IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
|
|
IntVector b = (IntVector) SPECIES.broadcast(0);
|
|
VectorMask<Integer> m = a.lt((int) 1);
|
|
a.div(b, m);
|
|
Assert.fail();
|
|
} catch (ArithmeticException e) {
|
|
}
|
|
}
|
|
static int ADD(int a, int b) {
|
|
return (int)(a + b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ADDInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::ADD);
|
|
}
|
|
static int add(int a, int b) {
|
|
return (int)(a + b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void addInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.add(bv).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::add);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ADDInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::ADD);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void addInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.add(bv, vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::add);
|
|
}
|
|
static int SUB(int a, int b) {
|
|
return (int)(a - b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void SUBInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::SUB);
|
|
}
|
|
static int sub(int a, int b) {
|
|
return (int)(a - b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void subInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.sub(bv).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::sub);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void SUBInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::SUB);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void subInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.sub(bv, vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::sub);
|
|
}
|
|
static int MUL(int a, int b) {
|
|
return (int)(a * b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void MULInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::MUL);
|
|
}
|
|
static int mul(int a, int b) {
|
|
return (int)(a * b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void mulInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.mul(bv).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::mul);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void MULInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::MUL);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void mulInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.mul(bv, vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::mul);
|
|
}
|
|
|
|
|
|
|
|
static int DIV(int a, int b) {
|
|
return (int)(a / b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void DIVInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
replaceZero(b, (int) 1);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::DIV);
|
|
}
|
|
static int div(int a, int b) {
|
|
return (int)(a / b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void divInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
replaceZero(b, (int) 1);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.div(bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::div);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void DIVInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
replaceZero(b, mask, (int) 1);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::DIV);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void divInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
replaceZero(b, mask, (int) 1);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.div(bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::div);
|
|
}
|
|
|
|
static int FIRST_NONZERO(int a, int b) {
|
|
return (int)((a)!=0?a:b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void FIRST_NONZEROInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::FIRST_NONZERO);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void FIRST_NONZEROInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::FIRST_NONZERO);
|
|
}
|
|
|
|
static int AND(int a, int b) {
|
|
return (int)(a & b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ANDInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::AND);
|
|
}
|
|
static int and(int a, int b) {
|
|
return (int)(a & b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void andInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.and(bv).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::and);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ANDInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::AND);
|
|
}
|
|
|
|
|
|
static int AND_NOT(int a, int b) {
|
|
return (int)(a & ~b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void AND_NOTInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::AND_NOT);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void AND_NOTInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::AND_NOT);
|
|
}
|
|
|
|
|
|
static int OR(int a, int b) {
|
|
return (int)(a | b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ORInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::OR);
|
|
}
|
|
static int or(int a, int b) {
|
|
return (int)(a | b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void orInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.or(bv).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::or);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ORInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::OR);
|
|
}
|
|
|
|
|
|
static int XOR(int a, int b) {
|
|
return (int)(a ^ b);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void XORInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::XOR);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void XORInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::XOR);
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void addInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.add(b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::add);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void addInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.add(b[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::add);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void subInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.sub(b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::sub);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void subInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.sub(b[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::sub);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void mulInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.mul(b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::mul);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void mulInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.mul(b[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::mul);
|
|
}
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void divInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
replaceZero(b, (int) 1);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.div(b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::div);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void divInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
replaceZero(b, (int) 1);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.div(b[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::div);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ORInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::OR);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void orInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.or(b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::or);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ORInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::OR);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ANDInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::AND);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void andInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.and(b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::and);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ANDInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::AND);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ORInt256VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastLongArraysEquals(r, a, b, Int256VectorTests::OR);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ORInt256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastLongArraysEquals(r, a, b, mask, Int256VectorTests::OR);
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ADDInt256VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastLongArraysEquals(r, a, b, Int256VectorTests::ADD);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ADDInt256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastLongArraysEquals(r, a, b, mask, Int256VectorTests::ADD);
|
|
}
|
|
|
|
static int LSHL(int a, int b) {
|
|
return (int)((a << b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void LSHLInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::LSHL);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void LSHLInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::LSHL);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int ASHR(int a, int b) {
|
|
return (int)((a >> b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ASHRInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::ASHR);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ASHRInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::ASHR);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int LSHR(int a, int b) {
|
|
return (int)((a >>> b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void LSHRInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::LSHR);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void LSHRInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::LSHR);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int LSHL_unary(int a, int b) {
|
|
return (int)((a << b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void LSHLInt256VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, Int256VectorTests::LSHL_unary);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void LSHLInt256VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::LSHL_unary);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int LSHR_unary(int a, int b) {
|
|
return (int)((a >>> b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void LSHRInt256VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, Int256VectorTests::LSHR_unary);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void LSHRInt256VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::LSHR_unary);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int ASHR_unary(int a, int b) {
|
|
return (int)((a >> b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ASHRInt256VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, Int256VectorTests::ASHR_unary);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ASHRInt256VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::ASHR_unary);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int ROR(int a, int b) {
|
|
return (int)(ROR_scalar(a,b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void RORInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::ROR);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void RORInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::ROR);
|
|
}
|
|
|
|
|
|
static int ROL(int a, int b) {
|
|
return (int)(ROL_scalar(a,b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ROLInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::ROL);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ROLInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::ROL);
|
|
}
|
|
|
|
|
|
static int ROR_unary(int a, int b) {
|
|
return (int)(ROR_scalar(a,b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void RORInt256VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, Int256VectorTests::ROR_unary);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void RORInt256VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::ROR_unary);
|
|
}
|
|
|
|
|
|
static int ROL_unary(int a, int b) {
|
|
return (int)(ROL_scalar(a,b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void ROLInt256VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, Int256VectorTests::ROL_unary);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void ROLInt256VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::ROL_unary);
|
|
}
|
|
|
|
static int MIN(int a, int b) {
|
|
return (int)(Math.min(a, b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void MINInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::MIN);
|
|
}
|
|
static int min(int a, int b) {
|
|
return (int)(Math.min(a, b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void minInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.min(bv).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::min);
|
|
}
|
|
static int MAX(int a, int b) {
|
|
return (int)(Math.max(a, b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void MAXInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::MAX);
|
|
}
|
|
static int max(int a, int b) {
|
|
return (int)(Math.max(a, b));
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void maxInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.max(bv).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, Int256VectorTests::max);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void MINInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::MIN);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void minInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.min(b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::min);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void MAXInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::MAX);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void maxInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.max(b[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, Int256VectorTests::max);
|
|
}
|
|
|
|
static int ANDReduce(int[] a, int idx) {
|
|
int res = -1;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res &= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int ANDReduceAll(int[] a) {
|
|
int res = -1;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res &= ANDReduce(a, i);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void ANDReduceInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
int ra = -1;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.AND);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = -1;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra &= av.reduceLanes(VectorOperators.AND);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEquals(r, ra, a,
|
|
Int256VectorTests::ANDReduce, Int256VectorTests::ANDReduceAll);
|
|
}
|
|
|
|
|
|
static int ANDReduceMasked(int[] a, int idx, boolean[] mask) {
|
|
int res = -1;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
if (mask[i % SPECIES.length()])
|
|
res &= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int ANDReduceAllMasked(int[] a, boolean[] mask) {
|
|
int res = -1;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res &= ANDReduceMasked(a, i, mask);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void ANDReduceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
int ra = -1;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.AND, vmask);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = -1;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra &= av.reduceLanes(VectorOperators.AND, vmask);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEqualsMasked(r, ra, a, mask,
|
|
Int256VectorTests::ANDReduceMasked, Int256VectorTests::ANDReduceAllMasked);
|
|
}
|
|
|
|
|
|
static int ORReduce(int[] a, int idx) {
|
|
int res = 0;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res |= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int ORReduceAll(int[] a) {
|
|
int res = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res |= ORReduce(a, i);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void ORReduceInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
int ra = 0;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.OR);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra |= av.reduceLanes(VectorOperators.OR);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEquals(r, ra, a,
|
|
Int256VectorTests::ORReduce, Int256VectorTests::ORReduceAll);
|
|
}
|
|
|
|
|
|
static int ORReduceMasked(int[] a, int idx, boolean[] mask) {
|
|
int res = 0;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
if (mask[i % SPECIES.length()])
|
|
res |= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int ORReduceAllMasked(int[] a, boolean[] mask) {
|
|
int res = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res |= ORReduceMasked(a, i, mask);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void ORReduceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
int ra = 0;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.OR, vmask);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra |= av.reduceLanes(VectorOperators.OR, vmask);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEqualsMasked(r, ra, a, mask,
|
|
Int256VectorTests::ORReduceMasked, Int256VectorTests::ORReduceAllMasked);
|
|
}
|
|
|
|
|
|
static int XORReduce(int[] a, int idx) {
|
|
int res = 0;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res ^= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int XORReduceAll(int[] a) {
|
|
int res = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res ^= XORReduce(a, i);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void XORReduceInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
int ra = 0;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.XOR);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra ^= av.reduceLanes(VectorOperators.XOR);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEquals(r, ra, a,
|
|
Int256VectorTests::XORReduce, Int256VectorTests::XORReduceAll);
|
|
}
|
|
|
|
|
|
static int XORReduceMasked(int[] a, int idx, boolean[] mask) {
|
|
int res = 0;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
if (mask[i % SPECIES.length()])
|
|
res ^= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int XORReduceAllMasked(int[] a, boolean[] mask) {
|
|
int res = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res ^= XORReduceMasked(a, i, mask);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void XORReduceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
int ra = 0;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEqualsMasked(r, ra, a, mask,
|
|
Int256VectorTests::XORReduceMasked, Int256VectorTests::XORReduceAllMasked);
|
|
}
|
|
|
|
static int ADDReduce(int[] a, int idx) {
|
|
int res = 0;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res += a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int ADDReduceAll(int[] a) {
|
|
int res = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res += ADDReduce(a, i);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void ADDReduceInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
int ra = 0;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.ADD);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra += av.reduceLanes(VectorOperators.ADD);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEquals(r, ra, a,
|
|
Int256VectorTests::ADDReduce, Int256VectorTests::ADDReduceAll);
|
|
}
|
|
static int ADDReduceMasked(int[] a, int idx, boolean[] mask) {
|
|
int res = 0;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
if (mask[i % SPECIES.length()])
|
|
res += a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int ADDReduceAllMasked(int[] a, boolean[] mask) {
|
|
int res = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res += ADDReduceMasked(a, i, mask);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void ADDReduceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
int ra = 0;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra += av.reduceLanes(VectorOperators.ADD, vmask);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEqualsMasked(r, ra, a, mask,
|
|
Int256VectorTests::ADDReduceMasked, Int256VectorTests::ADDReduceAllMasked);
|
|
}
|
|
static int MULReduce(int[] a, int idx) {
|
|
int res = 1;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res *= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int MULReduceAll(int[] a) {
|
|
int res = 1;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res *= MULReduce(a, i);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void MULReduceInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
int ra = 1;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.MUL);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = 1;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra *= av.reduceLanes(VectorOperators.MUL);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEquals(r, ra, a,
|
|
Int256VectorTests::MULReduce, Int256VectorTests::MULReduceAll);
|
|
}
|
|
static int MULReduceMasked(int[] a, int idx, boolean[] mask) {
|
|
int res = 1;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
if (mask[i % SPECIES.length()])
|
|
res *= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int MULReduceAllMasked(int[] a, boolean[] mask) {
|
|
int res = 1;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res *= MULReduceMasked(a, i, mask);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void MULReduceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
int ra = 1;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = 1;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra *= av.reduceLanes(VectorOperators.MUL, vmask);
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEqualsMasked(r, ra, a, mask,
|
|
Int256VectorTests::MULReduceMasked, Int256VectorTests::MULReduceAllMasked);
|
|
}
|
|
static int MINReduce(int[] a, int idx) {
|
|
int res = Integer.MAX_VALUE;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res = (int)Math.min(res, a[i]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int MINReduceAll(int[] a) {
|
|
int res = Integer.MAX_VALUE;
|
|
for (int i = 0; i < a.length; i++) {
|
|
res = (int)Math.min(res, a[i]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void MINReduceInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
int ra = Integer.MAX_VALUE;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.MIN);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = Integer.MAX_VALUE;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN));
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEquals(r, ra, a,
|
|
Int256VectorTests::MINReduce, Int256VectorTests::MINReduceAll);
|
|
}
|
|
static int MINReduceMasked(int[] a, int idx, boolean[] mask) {
|
|
int res = Integer.MAX_VALUE;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
if(mask[i % SPECIES.length()])
|
|
res = (int)Math.min(res, a[i]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int MINReduceAllMasked(int[] a, boolean[] mask) {
|
|
int res = Integer.MAX_VALUE;
|
|
for (int i = 0; i < a.length; i++) {
|
|
if(mask[i % SPECIES.length()])
|
|
res = (int)Math.min(res, a[i]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void MINReduceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
int ra = Integer.MAX_VALUE;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = Integer.MAX_VALUE;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEqualsMasked(r, ra, a, mask,
|
|
Int256VectorTests::MINReduceMasked, Int256VectorTests::MINReduceAllMasked);
|
|
}
|
|
static int MAXReduce(int[] a, int idx) {
|
|
int res = Integer.MIN_VALUE;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res = (int)Math.max(res, a[i]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int MAXReduceAll(int[] a) {
|
|
int res = Integer.MIN_VALUE;
|
|
for (int i = 0; i < a.length; i++) {
|
|
res = (int)Math.max(res, a[i]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void MAXReduceInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
int ra = Integer.MIN_VALUE;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.MAX);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = Integer.MIN_VALUE;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX));
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEquals(r, ra, a,
|
|
Int256VectorTests::MAXReduce, Int256VectorTests::MAXReduceAll);
|
|
}
|
|
static int MAXReduceMasked(int[] a, int idx, boolean[] mask) {
|
|
int res = Integer.MIN_VALUE;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
if(mask[i % SPECIES.length()])
|
|
res = (int)Math.max(res, a[i]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int MAXReduceAllMasked(int[] a, boolean[] mask) {
|
|
int res = Integer.MIN_VALUE;
|
|
for (int i = 0; i < a.length; i++) {
|
|
if(mask[i % SPECIES.length()])
|
|
res = (int)Math.max(res, a[i]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void MAXReduceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
int ra = Integer.MIN_VALUE;
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
|
|
}
|
|
}
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
ra = Integer.MIN_VALUE;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
|
|
}
|
|
}
|
|
|
|
assertReductionArraysEqualsMasked(r, ra, a, mask,
|
|
Int256VectorTests::MAXReduceMasked, Int256VectorTests::MAXReduceAllMasked);
|
|
}
|
|
|
|
static boolean anyTrue(boolean[] a, int idx) {
|
|
boolean res = false;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res |= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "boolUnaryOpProvider")
|
|
static void anyTrueInt256VectorTests(IntFunction<boolean[]> fm) {
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
boolean[] r = fmr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < mask.length; i += SPECIES.length()) {
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
|
|
r[i] = vmask.anyTrue();
|
|
}
|
|
}
|
|
|
|
assertReductionBoolArraysEquals(r, mask, Int256VectorTests::anyTrue);
|
|
}
|
|
|
|
|
|
static boolean allTrue(boolean[] a, int idx) {
|
|
boolean res = true;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res &= a[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "boolUnaryOpProvider")
|
|
static void allTrueInt256VectorTests(IntFunction<boolean[]> fm) {
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
boolean[] r = fmr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < mask.length; i += SPECIES.length()) {
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
|
|
r[i] = vmask.allTrue();
|
|
}
|
|
}
|
|
|
|
assertReductionBoolArraysEquals(r, mask, Int256VectorTests::allTrue);
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void withInt256VectorTests(IntFunction<int []> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.withLane(0, (int)4).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertInsertArraysEquals(r, a, (int)4, 0);
|
|
}
|
|
static boolean testIS_DEFAULT(int a) {
|
|
return bits(a)==0;
|
|
}
|
|
|
|
@Test(dataProvider = "intTestOpProvider")
|
|
static void IS_DEFAULTInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intTestOpMaskProvider")
|
|
static void IS_DEFAULTMaskedInt256VectorTestsSmokeTest(IntFunction<int[]> fa,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
|
|
}
|
|
}
|
|
}
|
|
static boolean testIS_NEGATIVE(int a) {
|
|
return bits(a)<0;
|
|
}
|
|
|
|
@Test(dataProvider = "intTestOpProvider")
|
|
static void IS_NEGATIVEInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intTestOpMaskProvider")
|
|
static void IS_NEGATIVEMaskedInt256VectorTestsSmokeTest(IntFunction<int[]> fa,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void LTInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void ltInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.lt(bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void LTInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void GTInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void GTInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void EQInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void eqInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.eq(bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void EQInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void NEInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void NEInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void LEInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void LEInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void GEInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void GEInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void UNSIGNED_LTInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LT, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void UNSIGNED_LTInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LT, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void UNSIGNED_GTInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GT, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void UNSIGNED_GTInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GT, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void UNSIGNED_LEInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LE, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void UNSIGNED_LEInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LE, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void UNSIGNED_GEInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GE, bv);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void UNSIGNED_GEInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GE, bv, vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void LTInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i]);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void LTInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
|
|
IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i], vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void LTInt256VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i]);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (int)((long)b[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void LTInt256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
|
|
IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (int)((long)b[i])));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void EQInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i]);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void EQInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
|
|
IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i], vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void EQInt256VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i]);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (int)((long)b[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpMaskProvider")
|
|
static void EQInt256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
|
|
IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (int)((long)b[i])));
|
|
}
|
|
}
|
|
}
|
|
|
|
static int blend(int a, int b, boolean mask) {
|
|
return mask ? b : a;
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void blendInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.blend(bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, mask, Int256VectorTests::blend);
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpShuffleProvider")
|
|
static void RearrangeInt256VectorTests(IntFunction<int[]> fa,
|
|
BiFunction<Integer,Integer,int[]> fs) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] order = fs.apply(a.length, SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertRearrangeArraysEquals(r, a, order, SPECIES.length());
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpShuffleMaskProvider")
|
|
static void RearrangeInt256VectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
|
|
BiFunction<Integer,Integer,int[]> fs,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] order = fs.apply(a.length, SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
|
|
}
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void getInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
int num_lanes = SPECIES.length();
|
|
// Manually unroll because full unroll happens after intrinsification.
|
|
// Unroll is needed because get intrinsic requires for index to be a known constant.
|
|
if (num_lanes == 1) {
|
|
r[i]=av.lane(0);
|
|
} else if (num_lanes == 2) {
|
|
r[i]=av.lane(0);
|
|
r[i+1]=av.lane(1);
|
|
} else if (num_lanes == 4) {
|
|
r[i]=av.lane(0);
|
|
r[i+1]=av.lane(1);
|
|
r[i+2]=av.lane(2);
|
|
r[i+3]=av.lane(3);
|
|
} else if (num_lanes == 8) {
|
|
r[i]=av.lane(0);
|
|
r[i+1]=av.lane(1);
|
|
r[i+2]=av.lane(2);
|
|
r[i+3]=av.lane(3);
|
|
r[i+4]=av.lane(4);
|
|
r[i+5]=av.lane(5);
|
|
r[i+6]=av.lane(6);
|
|
r[i+7]=av.lane(7);
|
|
} else if (num_lanes == 16) {
|
|
r[i]=av.lane(0);
|
|
r[i+1]=av.lane(1);
|
|
r[i+2]=av.lane(2);
|
|
r[i+3]=av.lane(3);
|
|
r[i+4]=av.lane(4);
|
|
r[i+5]=av.lane(5);
|
|
r[i+6]=av.lane(6);
|
|
r[i+7]=av.lane(7);
|
|
r[i+8]=av.lane(8);
|
|
r[i+9]=av.lane(9);
|
|
r[i+10]=av.lane(10);
|
|
r[i+11]=av.lane(11);
|
|
r[i+12]=av.lane(12);
|
|
r[i+13]=av.lane(13);
|
|
r[i+14]=av.lane(14);
|
|
r[i+15]=av.lane(15);
|
|
} else if (num_lanes == 32) {
|
|
r[i]=av.lane(0);
|
|
r[i+1]=av.lane(1);
|
|
r[i+2]=av.lane(2);
|
|
r[i+3]=av.lane(3);
|
|
r[i+4]=av.lane(4);
|
|
r[i+5]=av.lane(5);
|
|
r[i+6]=av.lane(6);
|
|
r[i+7]=av.lane(7);
|
|
r[i+8]=av.lane(8);
|
|
r[i+9]=av.lane(9);
|
|
r[i+10]=av.lane(10);
|
|
r[i+11]=av.lane(11);
|
|
r[i+12]=av.lane(12);
|
|
r[i+13]=av.lane(13);
|
|
r[i+14]=av.lane(14);
|
|
r[i+15]=av.lane(15);
|
|
r[i+16]=av.lane(16);
|
|
r[i+17]=av.lane(17);
|
|
r[i+18]=av.lane(18);
|
|
r[i+19]=av.lane(19);
|
|
r[i+20]=av.lane(20);
|
|
r[i+21]=av.lane(21);
|
|
r[i+22]=av.lane(22);
|
|
r[i+23]=av.lane(23);
|
|
r[i+24]=av.lane(24);
|
|
r[i+25]=av.lane(25);
|
|
r[i+26]=av.lane(26);
|
|
r[i+27]=av.lane(27);
|
|
r[i+28]=av.lane(28);
|
|
r[i+29]=av.lane(29);
|
|
r[i+30]=av.lane(30);
|
|
r[i+31]=av.lane(31);
|
|
} else if (num_lanes == 64) {
|
|
r[i]=av.lane(0);
|
|
r[i+1]=av.lane(1);
|
|
r[i+2]=av.lane(2);
|
|
r[i+3]=av.lane(3);
|
|
r[i+4]=av.lane(4);
|
|
r[i+5]=av.lane(5);
|
|
r[i+6]=av.lane(6);
|
|
r[i+7]=av.lane(7);
|
|
r[i+8]=av.lane(8);
|
|
r[i+9]=av.lane(9);
|
|
r[i+10]=av.lane(10);
|
|
r[i+11]=av.lane(11);
|
|
r[i+12]=av.lane(12);
|
|
r[i+13]=av.lane(13);
|
|
r[i+14]=av.lane(14);
|
|
r[i+15]=av.lane(15);
|
|
r[i+16]=av.lane(16);
|
|
r[i+17]=av.lane(17);
|
|
r[i+18]=av.lane(18);
|
|
r[i+19]=av.lane(19);
|
|
r[i+20]=av.lane(20);
|
|
r[i+21]=av.lane(21);
|
|
r[i+22]=av.lane(22);
|
|
r[i+23]=av.lane(23);
|
|
r[i+24]=av.lane(24);
|
|
r[i+25]=av.lane(25);
|
|
r[i+26]=av.lane(26);
|
|
r[i+27]=av.lane(27);
|
|
r[i+28]=av.lane(28);
|
|
r[i+29]=av.lane(29);
|
|
r[i+30]=av.lane(30);
|
|
r[i+31]=av.lane(31);
|
|
r[i+32]=av.lane(32);
|
|
r[i+33]=av.lane(33);
|
|
r[i+34]=av.lane(34);
|
|
r[i+35]=av.lane(35);
|
|
r[i+36]=av.lane(36);
|
|
r[i+37]=av.lane(37);
|
|
r[i+38]=av.lane(38);
|
|
r[i+39]=av.lane(39);
|
|
r[i+40]=av.lane(40);
|
|
r[i+41]=av.lane(41);
|
|
r[i+42]=av.lane(42);
|
|
r[i+43]=av.lane(43);
|
|
r[i+44]=av.lane(44);
|
|
r[i+45]=av.lane(45);
|
|
r[i+46]=av.lane(46);
|
|
r[i+47]=av.lane(47);
|
|
r[i+48]=av.lane(48);
|
|
r[i+49]=av.lane(49);
|
|
r[i+50]=av.lane(50);
|
|
r[i+51]=av.lane(51);
|
|
r[i+52]=av.lane(52);
|
|
r[i+53]=av.lane(53);
|
|
r[i+54]=av.lane(54);
|
|
r[i+55]=av.lane(55);
|
|
r[i+56]=av.lane(56);
|
|
r[i+57]=av.lane(57);
|
|
r[i+58]=av.lane(58);
|
|
r[i+59]=av.lane(59);
|
|
r[i+60]=av.lane(60);
|
|
r[i+61]=av.lane(61);
|
|
r[i+62]=av.lane(62);
|
|
r[i+63]=av.lane(63);
|
|
} else {
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
r[i+j]=av.lane(j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, Int256VectorTests::get);
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void BroadcastInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector.broadcast(SPECIES, a[i]).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void ZeroInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector.zero(SPECIES).intoArray(a, i);
|
|
}
|
|
}
|
|
|
|
Assert.assertEquals(a, r);
|
|
}
|
|
|
|
|
|
|
|
|
|
static int[] sliceUnary(int[] a, int origin, int idx) {
|
|
int[] res = new int[SPECIES.length()];
|
|
for (int i = 0; i < SPECIES.length(); i++){
|
|
if(i+origin < SPECIES.length())
|
|
res[i] = a[idx+i+origin];
|
|
else
|
|
res[i] = (int)0;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void sliceUnaryInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
int origin = (new java.util.Random()).nextInt(SPECIES.length());
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.slice(origin).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, origin, Int256VectorTests::sliceUnary);
|
|
}
|
|
static int[] sliceBinary(int[] a, int[] b, int origin, int idx) {
|
|
int[] res = new int[SPECIES.length()];
|
|
for (int i = 0, j = 0; i < SPECIES.length(); i++){
|
|
if(i+origin < SPECIES.length())
|
|
res[i] = a[idx+i+origin];
|
|
else {
|
|
res[i] = b[idx+j];
|
|
j++;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void sliceBinaryInt256VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
int origin = (new java.util.Random()).nextInt(SPECIES.length());
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.slice(origin, bv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, origin, Int256VectorTests::sliceBinary);
|
|
}
|
|
static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) {
|
|
int[] res = new int[SPECIES.length()];
|
|
for (int i = 0, j = 0; i < SPECIES.length(); i++){
|
|
if(i+origin < SPECIES.length())
|
|
res[i] = mask[i] ? a[idx+i+origin] : (int)0;
|
|
else {
|
|
res[i] = mask[i] ? b[idx+j] : (int)0;
|
|
j++;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void sliceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
int[] r = new int[a.length];
|
|
int origin = (new java.util.Random()).nextInt(SPECIES.length());
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.slice(origin, bv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, origin, mask, Int256VectorTests::slice);
|
|
}
|
|
static int[] unsliceUnary(int[] a, int origin, int idx) {
|
|
int[] res = new int[SPECIES.length()];
|
|
for (int i = 0, j = 0; i < SPECIES.length(); i++){
|
|
if(i < origin)
|
|
res[i] = (int)0;
|
|
else {
|
|
res[i] = a[idx+j];
|
|
j++;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void unsliceUnaryInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
int origin = (new java.util.Random()).nextInt(SPECIES.length());
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.unslice(origin).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, origin, Int256VectorTests::unsliceUnary);
|
|
}
|
|
static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) {
|
|
int[] res = new int[SPECIES.length()];
|
|
for (int i = 0, j = 0; i < SPECIES.length(); i++){
|
|
if (part == 0) {
|
|
if (i < origin)
|
|
res[i] = b[idx+i];
|
|
else {
|
|
res[i] = a[idx+j];
|
|
j++;
|
|
}
|
|
} else if (part == 1) {
|
|
if (i < origin)
|
|
res[i] = a[idx+SPECIES.length()-origin+i];
|
|
else {
|
|
res[i] = b[idx+origin+j];
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpProvider")
|
|
static void unsliceBinaryInt256VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
int origin = (new java.util.Random()).nextInt(SPECIES.length());
|
|
int part = (new java.util.Random()).nextInt(2);
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.unslice(origin, bv, part).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, origin, part, Int256VectorTests::unsliceBinary);
|
|
}
|
|
static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) {
|
|
int[] res = new int[SPECIES.length()];
|
|
for (int i = 0, j = 0; i < SPECIES.length(); i++){
|
|
if(i+origin < SPECIES.length())
|
|
res[i] = b[idx+i+origin];
|
|
else {
|
|
res[i] = b[idx+j];
|
|
j++;
|
|
}
|
|
}
|
|
for (int i = 0; i < SPECIES.length(); i++){
|
|
res[i] = mask[i] ? a[idx+i] : res[i];
|
|
}
|
|
int[] res1 = new int[SPECIES.length()];
|
|
if (part == 0) {
|
|
for (int i = 0, j = 0; i < SPECIES.length(); i++){
|
|
if (i < origin)
|
|
res1[i] = b[idx+i];
|
|
else {
|
|
res1[i] = res[j];
|
|
j++;
|
|
}
|
|
}
|
|
} else if (part == 1) {
|
|
for (int i = 0, j = 0; i < SPECIES.length(); i++){
|
|
if (i < origin)
|
|
res1[i] = res[SPECIES.length()-origin+i];
|
|
else {
|
|
res1[i] = b[idx+origin+j];
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
return res1;
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void unsliceInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
int[] r = new int[a.length];
|
|
int origin = (new java.util.Random()).nextInt(SPECIES.length());
|
|
int part = (new java.util.Random()).nextInt(2);
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.unslice(origin, bv, part, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, origin, part, mask, Int256VectorTests::unslice);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int BITWISE_BLEND(int a, int b, int c) {
|
|
return (int)((a&~(c))|(b&c));
|
|
}
|
|
static int bitwiseBlend(int a, int b, int c) {
|
|
return (int)((a&~(c))|(b&c));
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intTernaryOpProvider")
|
|
static void BITWISE_BLENDInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
IntVector cv = IntVector.fromArray(SPECIES, c, i);
|
|
av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, c, Int256VectorTests::BITWISE_BLEND);
|
|
}
|
|
@Test(dataProvider = "intTernaryOpProvider")
|
|
static void bitwiseBlendInt256VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
IntVector cv = IntVector.fromArray(SPECIES, c, i);
|
|
av.bitwiseBlend(bv, cv).intoArray(r, i);
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, c, Int256VectorTests::bitwiseBlend);
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intTernaryOpMaskProvider")
|
|
static void BITWISE_BLENDInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
IntVector cv = IntVector.fromArray(SPECIES, c, i);
|
|
av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, b, c, mask, Int256VectorTests::BITWISE_BLEND);
|
|
}
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intTernaryOpProvider")
|
|
static void BITWISE_BLENDInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
|
|
}
|
|
assertBroadcastArraysEquals(r, a, b, c, Int256VectorTests::BITWISE_BLEND);
|
|
}
|
|
|
|
@Test(dataProvider = "intTernaryOpProvider")
|
|
static void BITWISE_BLENDInt256VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector cv = IntVector.fromArray(SPECIES, c, i);
|
|
av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
|
|
}
|
|
assertAltBroadcastArraysEquals(r, a, b, c, Int256VectorTests::BITWISE_BLEND);
|
|
}
|
|
@Test(dataProvider = "intTernaryOpProvider")
|
|
static void bitwiseBlendInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.bitwiseBlend(bv, c[i]).intoArray(r, i);
|
|
}
|
|
assertBroadcastArraysEquals(r, a, b, c, Int256VectorTests::bitwiseBlend);
|
|
}
|
|
|
|
@Test(dataProvider = "intTernaryOpProvider")
|
|
static void bitwiseBlendInt256VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector cv = IntVector.fromArray(SPECIES, c, i);
|
|
av.bitwiseBlend(b[i], cv).intoArray(r, i);
|
|
}
|
|
assertAltBroadcastArraysEquals(r, a, b, c, Int256VectorTests::bitwiseBlend);
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intTernaryOpMaskProvider")
|
|
static void BITWISE_BLENDInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, b, i);
|
|
av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertBroadcastArraysEquals(r, a, b, c, mask, Int256VectorTests::BITWISE_BLEND);
|
|
}
|
|
|
|
@Test(dataProvider = "intTernaryOpMaskProvider")
|
|
static void BITWISE_BLENDInt256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector cv = IntVector.fromArray(SPECIES, c, i);
|
|
av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertAltBroadcastArraysEquals(r, a, b, c, mask, Int256VectorTests::BITWISE_BLEND);
|
|
}
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intTernaryOpProvider")
|
|
static void BITWISE_BLENDInt256VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertDoubleBroadcastArraysEquals(r, a, b, c, Int256VectorTests::BITWISE_BLEND);
|
|
}
|
|
@Test(dataProvider = "intTernaryOpProvider")
|
|
static void bitwiseBlendInt256VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
|
|
}
|
|
|
|
assertDoubleBroadcastArraysEquals(r, a, b, c, Int256VectorTests::bitwiseBlend);
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intTernaryOpMaskProvider")
|
|
static void BITWISE_BLENDInt256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] c = fc.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int256VectorTests::BITWISE_BLEND);
|
|
}
|
|
|
|
|
|
static int NEG(int a) {
|
|
return (int)(-((int)a));
|
|
}
|
|
|
|
static int neg(int a) {
|
|
return (int)(-((int)a));
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void NEGInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.NEG).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, Int256VectorTests::NEG);
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void negInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.neg().intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, Int256VectorTests::neg);
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void NEGMaskedInt256VectorTests(IntFunction<int[]> fa,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, mask, Int256VectorTests::NEG);
|
|
}
|
|
|
|
static int ABS(int a) {
|
|
return (int)(Math.abs((int)a));
|
|
}
|
|
|
|
static int abs(int a) {
|
|
return (int)(Math.abs((int)a));
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void ABSInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ABS).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, Int256VectorTests::ABS);
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void absInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.abs().intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, Int256VectorTests::abs);
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void ABSMaskedInt256VectorTests(IntFunction<int[]> fa,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, mask, Int256VectorTests::ABS);
|
|
}
|
|
|
|
|
|
static int NOT(int a) {
|
|
return (int)(~((int)a));
|
|
}
|
|
|
|
static int not(int a) {
|
|
return (int)(~((int)a));
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void NOTInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.NOT).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, Int256VectorTests::NOT);
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void notInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.not().intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, Int256VectorTests::not);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void NOTMaskedInt256VectorTests(IntFunction<int[]> fa,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, mask, Int256VectorTests::NOT);
|
|
}
|
|
|
|
|
|
|
|
static int ZOMO(int a) {
|
|
return (int)((a==0?0:-1));
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void ZOMOInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, Int256VectorTests::ZOMO);
|
|
}
|
|
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void ZOMOMaskedInt256VectorTests(IntFunction<int[]> fa,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
|
|
assertArraysEquals(r, a, mask, Int256VectorTests::ZOMO);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void ltInt256VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.lt(b[i]);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intCompareOpProvider")
|
|
static void eqInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
VectorMask<Integer> mv = av.eq(b[i]);
|
|
|
|
// Check results as part of computation.
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void toIntArrayInt256VectorTestsSmokeTest(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
int[] r = av.toIntArray();
|
|
assertArraysEquals(r, a, i);
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void toLongArrayInt256VectorTestsSmokeTest(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
long[] r = av.toLongArray();
|
|
assertArraysEquals(r, a, i);
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void toDoubleArrayInt256VectorTestsSmokeTest(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
double[] r = av.toDoubleArray();
|
|
assertArraysEquals(r, a, i);
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void toStringInt256VectorTestsSmokeTest(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
String str = av.toString();
|
|
|
|
int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
|
|
Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void hashCodeInt256VectorTestsSmokeTest(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
int hash = av.hashCode();
|
|
|
|
int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
|
|
int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
|
|
Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
|
|
}
|
|
}
|
|
|
|
|
|
static long ADDReduceLong(int[] a, int idx) {
|
|
int res = 0;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
res += a[i];
|
|
}
|
|
|
|
return (long)res;
|
|
}
|
|
|
|
static long ADDReduceAllLong(int[] a) {
|
|
long res = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res += ADDReduceLong(a, i);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void ADDReduceLongInt256VectorTests(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
long[] r = lfr.apply(SPECIES.length());
|
|
long ra = 0;
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanesToLong(VectorOperators.ADD);
|
|
}
|
|
|
|
ra = 0;
|
|
for (int i = 0; i < a.length; i ++) {
|
|
ra += r[i];
|
|
}
|
|
|
|
assertReductionLongArraysEquals(r, ra, a,
|
|
Int256VectorTests::ADDReduceLong, Int256VectorTests::ADDReduceAllLong);
|
|
}
|
|
|
|
static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) {
|
|
int res = 0;
|
|
for (int i = idx; i < (idx + SPECIES.length()); i++) {
|
|
if(mask[i % SPECIES.length()])
|
|
res += a[i];
|
|
}
|
|
|
|
return (long)res;
|
|
}
|
|
|
|
static long ADDReduceAllLongMasked(int[] a, boolean[] mask) {
|
|
long res = 0;
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
res += ADDReduceLongMasked(a, i, mask);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpMaskProvider")
|
|
static void ADDReduceLongInt256VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
long[] r = lfr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
long ra = 0;
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
|
|
}
|
|
|
|
ra = 0;
|
|
for (int i = 0; i < a.length; i ++) {
|
|
ra += r[i];
|
|
}
|
|
|
|
assertReductionLongArraysEqualsMasked(r, ra, a, mask,
|
|
Int256VectorTests::ADDReduceLongMasked, Int256VectorTests::ADDReduceAllLongMasked);
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpProvider")
|
|
static void BroadcastLongInt256VectorTestsSmokeTest(IntFunction<int[]> fa) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
|
|
}
|
|
assertBroadcastArraysEquals(r, a);
|
|
}
|
|
|
|
@Test(dataProvider = "intBinaryOpMaskProvider")
|
|
static void blendInt256VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
av.blend((long)b[i], vmask).intoArray(r, i);
|
|
}
|
|
}
|
|
assertBroadcastLongArraysEquals(r, a, b, mask, Int256VectorTests::blend);
|
|
}
|
|
|
|
|
|
@Test(dataProvider = "intUnaryOpShuffleProvider")
|
|
static void SelectFromInt256VectorTests(IntFunction<int[]> fa,
|
|
BiFunction<Integer,Integer,int[]> fs) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] order = fs.apply(a.length, SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, order, i);
|
|
bv.selectFrom(av).intoArray(r, i);
|
|
}
|
|
|
|
assertSelectFromArraysEquals(r, a, order, SPECIES.length());
|
|
}
|
|
|
|
@Test(dataProvider = "intUnaryOpShuffleMaskProvider")
|
|
static void SelectFromInt256VectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
|
|
BiFunction<Integer,Integer,int[]> fs,
|
|
IntFunction<boolean[]> fm) {
|
|
int[] a = fa.apply(SPECIES.length());
|
|
int[] order = fs.apply(a.length, SPECIES.length());
|
|
int[] r = fr.apply(SPECIES.length());
|
|
boolean[] mask = fm.apply(SPECIES.length());
|
|
VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
IntVector av = IntVector.fromArray(SPECIES, a, i);
|
|
IntVector bv = IntVector.fromArray(SPECIES, order, i);
|
|
bv.selectFrom(av, vmask).intoArray(r, i);
|
|
}
|
|
|
|
assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
|
|
}
|
|
|
|
@Test(dataProvider = "shuffleProvider")
|
|
static void shuffleMiscellaneousInt256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
|
|
int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
|
|
int hash = shuffle.hashCode();
|
|
int length = shuffle.length();
|
|
|
|
int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
|
|
int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
|
|
Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
|
|
Assert.assertEquals(length, SPECIES.length());
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "shuffleProvider")
|
|
static void shuffleToStringInt256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
|
|
int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
|
|
String str = shuffle.toString();
|
|
|
|
int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
|
|
Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
|
|
i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "shuffleCompareOpProvider")
|
|
static void shuffleEqualsInt256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
|
|
int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
|
|
int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var av = VectorShuffle.fromArray(SPECIES, a, i);
|
|
var bv = VectorShuffle.fromArray(SPECIES, b, i);
|
|
boolean eq = av.equals(bv);
|
|
int to = i + SPECIES.length();
|
|
Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider = "maskCompareOpProvider")
|
|
static void maskEqualsInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
|
|
boolean[] a = fa.apply(SPECIES.length());
|
|
boolean[] b = fb.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var av = SPECIES.loadMask(a, i);
|
|
var bv = SPECIES.loadMask(b, i);
|
|
boolean equals = av.equals(bv);
|
|
int to = i + SPECIES.length();
|
|
Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
|
|
}
|
|
}
|
|
|
|
static boolean beq(boolean a, boolean b) {
|
|
return (a == b);
|
|
}
|
|
|
|
@Test(dataProvider = "maskCompareOpProvider")
|
|
static void maskEqInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
|
|
boolean[] a = fa.apply(SPECIES.length());
|
|
boolean[] b = fb.apply(SPECIES.length());
|
|
boolean[] r = new boolean[a.length];
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var av = SPECIES.loadMask(a, i);
|
|
var bv = SPECIES.loadMask(b, i);
|
|
var cv = av.eq(bv);
|
|
cv.intoArray(r, i);
|
|
}
|
|
assertArraysEquals(r, a, b, Int256VectorTests::beq);
|
|
}
|
|
|
|
@Test(dataProvider = "maskProvider")
|
|
static void maskHashCodeInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
|
|
boolean[] a = fa.apply(SPECIES.length());
|
|
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var vmask = SPECIES.loadMask(a, i);
|
|
int hash = vmask.hashCode();
|
|
|
|
boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
|
|
int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
|
|
Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
|
|
}
|
|
}
|
|
|
|
static int maskTrueCount(boolean[] a, int idx) {
|
|
int trueCount = 0;
|
|
for (int i = idx; i < idx + SPECIES.length(); i++) {
|
|
trueCount += a[i] ? 1 : 0;
|
|
}
|
|
return trueCount;
|
|
}
|
|
|
|
@Test(dataProvider = "maskProvider")
|
|
static void maskTrueCountInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
|
|
boolean[] a = fa.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var vmask = SPECIES.loadMask(a, i);
|
|
r[i] = vmask.trueCount();
|
|
}
|
|
}
|
|
|
|
assertMaskReductionArraysEquals(r, a, Int256VectorTests::maskTrueCount);
|
|
}
|
|
|
|
static int maskLastTrue(boolean[] a, int idx) {
|
|
int i = idx + SPECIES.length() - 1;
|
|
for (; i >= idx; i--) {
|
|
if (a[i]) {
|
|
break;
|
|
}
|
|
}
|
|
return i - idx;
|
|
}
|
|
|
|
@Test(dataProvider = "maskProvider")
|
|
static void maskLastTrueInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
|
|
boolean[] a = fa.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var vmask = SPECIES.loadMask(a, i);
|
|
r[i] = vmask.lastTrue();
|
|
}
|
|
}
|
|
|
|
assertMaskReductionArraysEquals(r, a, Int256VectorTests::maskLastTrue);
|
|
}
|
|
|
|
static int maskFirstTrue(boolean[] a, int idx) {
|
|
int i = idx;
|
|
for (; i < idx + SPECIES.length(); i++) {
|
|
if (a[i]) {
|
|
break;
|
|
}
|
|
}
|
|
return i - idx;
|
|
}
|
|
|
|
@Test(dataProvider = "maskProvider")
|
|
static void maskFirstTrueInt256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
|
|
boolean[] a = fa.apply(SPECIES.length());
|
|
int[] r = new int[a.length];
|
|
|
|
for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
|
|
for (int i = 0; i < a.length; i += SPECIES.length()) {
|
|
var vmask = SPECIES.loadMask(a, i);
|
|
r[i] = vmask.firstTrue();
|
|
}
|
|
}
|
|
|
|
assertMaskReductionArraysEquals(r, a, Int256VectorTests::maskFirstTrue);
|
|
}
|
|
|
|
@DataProvider
|
|
public static Object[][] longMaskProvider() {
|
|
return new Object[][]{
|
|
{0xFFFFFFFFFFFFFFFFL},
|
|
{0x0000000000000000L},
|
|
{0x5555555555555555L},
|
|
{0x0123456789abcdefL},
|
|
};
|
|
}
|
|
|
|
@Test(dataProvider = "longMaskProvider")
|
|
static void maskFromToLongInt256VectorTestsSmokeTest(long inputLong) {
|
|
var vmask = VectorMask.fromLong(SPECIES, inputLong);
|
|
long outputLong = vmask.toLong();
|
|
Assert.assertEquals(outputLong, inputLong & (((1L << (SPECIES.length() - 1)) << 1) - 1));
|
|
}
|
|
|
|
@DataProvider
|
|
public static Object[][] offsetProvider() {
|
|
return new Object[][]{
|
|
{0},
|
|
{-1},
|
|
{+1},
|
|
{+2},
|
|
{-2},
|
|
};
|
|
}
|
|
|
|
@Test(dataProvider = "offsetProvider")
|
|
static void indexInRangeInt256VectorTestsSmokeTest(int offset) {
|
|
int limit = SPECIES.length() * BUFFER_REPS;
|
|
for (int i = 0; i < limit; i += SPECIES.length()) {
|
|
var actualMask = SPECIES.indexInRange(i + offset, limit);
|
|
var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
|
|
assert(actualMask.equals(expectedMask));
|
|
for (int j = 0; j < SPECIES.length(); j++) {
|
|
int index = i + j + offset;
|
|
Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
|
|
}
|
|
}
|
|
}
|
|
|
|
@DataProvider
|
|
public static Object[][] lengthProvider() {
|
|
return new Object[][]{
|
|
{0},
|
|
{1},
|
|
{32},
|
|
{37},
|
|
{1024},
|
|
{1024+1},
|
|
{1024+5},
|
|
};
|
|
}
|
|
|
|
@Test(dataProvider = "lengthProvider")
|
|
static void loopBoundInt256VectorTestsSmokeTest(int length) {
|
|
int actualLoopBound = SPECIES.loopBound(length);
|
|
int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
|
|
Assert.assertEquals(actualLoopBound, expectedLoopBound);
|
|
}
|
|
|
|
@Test
|
|
static void ElementSizeInt256VectorTestsSmokeTest() {
|
|
IntVector av = IntVector.zero(SPECIES);
|
|
int elsize = av.elementSize();
|
|
Assert.assertEquals(elsize, Integer.SIZE);
|
|
}
|
|
|
|
@Test
|
|
static void VectorShapeInt256VectorTestsSmokeTest() {
|
|
IntVector av = IntVector.zero(SPECIES);
|
|
VectorShape vsh = av.shape();
|
|
assert(vsh.equals(VectorShape.S_256_BIT));
|
|
}
|
|
|
|
@Test
|
|
static void ShapeWithLanesInt256VectorTestsSmokeTest() {
|
|
IntVector av = IntVector.zero(SPECIES);
|
|
VectorShape vsh = av.shape();
|
|
VectorSpecies species = vsh.withLanes(int.class);
|
|
assert(species.equals(SPECIES));
|
|
}
|
|
|
|
@Test
|
|
static void ElementTypeInt256VectorTestsSmokeTest() {
|
|
IntVector av = IntVector.zero(SPECIES);
|
|
assert(av.species().elementType() == int.class);
|
|
}
|
|
|
|
@Test
|
|
static void SpeciesElementSizeInt256VectorTestsSmokeTest() {
|
|
IntVector av = IntVector.zero(SPECIES);
|
|
assert(av.species().elementSize() == Integer.SIZE);
|
|
}
|
|
|
|
@Test
|
|
static void VectorTypeInt256VectorTestsSmokeTest() {
|
|
IntVector av = IntVector.zero(SPECIES);
|
|
assert(av.species().vectorType() == av.getClass());
|
|
}
|
|
|
|
@Test
|
|
static void WithLanesInt256VectorTestsSmokeTest() {
|
|
IntVector av = IntVector.zero(SPECIES);
|
|
VectorSpecies species = av.species().withLanes(int.class);
|
|
assert(species.equals(SPECIES));
|
|
}
|
|
|
|
@Test
|
|
static void WithShapeInt256VectorTestsSmokeTest() {
|
|
IntVector av = IntVector.zero(SPECIES);
|
|
VectorShape vsh = av.shape();
|
|
VectorSpecies species = av.species().withShape(vsh);
|
|
assert(species.equals(SPECIES));
|
|
}
|
|
}
|
|
|