mirror of
https://github.com/openjdk/jdk.git
synced 2026-05-17 00:50:48 +00:00
1101 lines
36 KiB
Java
1101 lines
36 KiB
Java
/*
|
|
* Copyright (c) 2026, 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
|
|
* @bug 8358521
|
|
* @summary Optimize vector operations by reassociating broadcasted inputs
|
|
* @modules jdk.incubator.vector
|
|
* @library /test/lib /
|
|
* @run driver compiler.vectorapi.TestVectorBroadcastTransforms
|
|
*/
|
|
|
|
package compiler.vectorapi;
|
|
|
|
import compiler.lib.ir_framework.*;
|
|
import compiler.lib.verify.Verify;
|
|
import jdk.incubator.vector.*;
|
|
|
|
import jdk.test.lib.Utils;
|
|
import java.util.Random;
|
|
|
|
public class TestVectorBroadcastTransforms {
|
|
|
|
public static void main(String[] args) {
|
|
TestFramework.runWithFlags("--add-modules=jdk.incubator.vector");
|
|
}
|
|
|
|
private static final Random R = Utils.getRandomInstance();
|
|
|
|
/* =======================
|
|
* INT
|
|
* ======================= */
|
|
|
|
static final VectorSpecies<Integer> ISP = IntVector.SPECIES_PREFERRED;
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VI,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_I, ">= 1", IRNode.REPLICATE_I, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static int int_add(int ia, int ib) {
|
|
return IntVector.broadcast(ISP, ia)
|
|
.add(IntVector.broadcast(ISP, ib))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "int_add")
|
|
static void run_int_add() {
|
|
int ia = R.nextInt();
|
|
int ib = R.nextInt();
|
|
int ir = int_add(ia, ib);
|
|
Verify.checkEQ(ir, ia + ib);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VI,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_I, ">= 1", IRNode.REPLICATE_I, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static int int_sub(int ia, int ib) {
|
|
return IntVector.broadcast(ISP, ia)
|
|
.sub(IntVector.broadcast(ISP, ib))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "int_sub")
|
|
static void run_int_sub() {
|
|
int ia = R.nextInt();
|
|
int ib = R.nextInt();
|
|
int ir = int_sub(ia, ib);
|
|
Verify.checkEQ(ir, ia - ib);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MUL_VI,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MUL_I, ">= 1", IRNode.REPLICATE_I, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static int int_mul(int ia, int ib) {
|
|
return IntVector.broadcast(ISP, ia)
|
|
.mul(IntVector.broadcast(ISP, ib))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "int_mul")
|
|
static void run_int_mul() {
|
|
int ia = R.nextInt();
|
|
int ib = R.nextInt();
|
|
int ir = int_mul(ia, ib);
|
|
Verify.checkEQ(ir, ia * ib);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.AND_VI,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.AND_I, ">= 1", IRNode.REPLICATE_I, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static int int_and(int ia, int ib) {
|
|
return IntVector.broadcast(ISP, ia)
|
|
.and(IntVector.broadcast(ISP, ib))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "int_and")
|
|
static void run_int_and() {
|
|
int ia = R.nextInt();
|
|
int ib = R.nextInt();
|
|
int ir = int_and(ia, ib);
|
|
Verify.checkEQ(ir, ia & ib);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.OR_VI,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.OR_I, ">= 1", IRNode.REPLICATE_I, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static int int_or(int ia, int ib) {
|
|
return IntVector.broadcast(ISP, ia)
|
|
.or(IntVector.broadcast(ISP, ib))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "int_or")
|
|
static void run_int_or() {
|
|
int ia = R.nextInt();
|
|
int ib = R.nextInt();
|
|
int ir = int_or(ia, ib);
|
|
Verify.checkEQ(ir, ia | ib);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.XOR_VI,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.XOR_I, ">= 1", IRNode.REPLICATE_I, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static int int_xor(int ia, int ib) {
|
|
return IntVector.broadcast(ISP, ia)
|
|
.lanewise(VectorOperators.XOR, IntVector.broadcast(ISP, ib))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "int_xor")
|
|
static void run_int_xor() {
|
|
int ia = R.nextInt();
|
|
int ib = R.nextInt();
|
|
int ir = int_xor(ia, ib);
|
|
Verify.checkEQ(ir, ia ^ ib);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MIN_VI,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MIN_I, ">= 1", IRNode.REPLICATE_I, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static int int_min(int ia, int ib) {
|
|
return IntVector.broadcast(ISP, ia)
|
|
.min(IntVector.broadcast(ISP, ib))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "int_min")
|
|
static void run_int_min() {
|
|
int ia = R.nextInt();
|
|
int ib = R.nextInt();
|
|
int ir = int_min(ia, ib);
|
|
Verify.checkEQ(ir, Math.min(ia, ib));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MAX_VI,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MAX_I, ">= 1", IRNode.REPLICATE_I, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static int int_max(int ia, int ib) {
|
|
return IntVector.broadcast(ISP, ia)
|
|
.max(IntVector.broadcast(ISP, ib))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "int_max")
|
|
static void run_int_max() {
|
|
int ia = R.nextInt();
|
|
int ib = R.nextInt();
|
|
int ir = int_max(ia, ib);
|
|
Verify.checkEQ(ir, Math.max(ia, ib));
|
|
}
|
|
|
|
/* =======================
|
|
* LONG
|
|
* ======================= */
|
|
|
|
static final VectorSpecies<Long> LSP = LongVector.SPECIES_PREFERRED;
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VL,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_L, ">= 1", IRNode.REPLICATE_L, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static long long_add(long la, long lb) {
|
|
return LongVector.broadcast(LSP, la)
|
|
.add(LongVector.broadcast(LSP, lb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "long_add")
|
|
static void run_long_add() {
|
|
long la = R.nextLong();
|
|
long lb = R.nextLong();
|
|
long lr = long_add(la, lb);
|
|
Verify.checkEQ(lr, la + lb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VL,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_L, ">= 1", IRNode.REPLICATE_L, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static long long_sub(long la, long lb) {
|
|
return LongVector.broadcast(LSP, la)
|
|
.sub(LongVector.broadcast(LSP, lb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "long_sub")
|
|
static void run_long_sub() {
|
|
long la = R.nextLong();
|
|
long lb = R.nextLong();
|
|
long lr = long_sub(la, lb);
|
|
Verify.checkEQ(lr, la - lb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MUL_VL,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MUL_L, ">= 1", IRNode.REPLICATE_L, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static long long_mul(long la, long lb) {
|
|
return LongVector.broadcast(LSP, la)
|
|
.mul(LongVector.broadcast(LSP, lb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "long_mul")
|
|
static void run_long_mul() {
|
|
long la = R.nextLong();
|
|
long lb = R.nextLong();
|
|
long lr = long_mul(la, lb);
|
|
Verify.checkEQ(lr, la * lb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.AND_VL,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.AND_L, ">= 1", IRNode.REPLICATE_L, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static long long_and(long la, long lb) {
|
|
return LongVector.broadcast(LSP, la)
|
|
.and(LongVector.broadcast(LSP, lb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "long_and")
|
|
static void run_long_and() {
|
|
long la = R.nextLong();
|
|
long lb = R.nextLong();
|
|
long lr = long_and(la, lb);
|
|
Verify.checkEQ(lr, la & lb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.OR_VL,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.OR_L, ">= 1", IRNode.REPLICATE_L, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static long long_or(long la, long lb) {
|
|
return LongVector.broadcast(LSP, la)
|
|
.or(LongVector.broadcast(LSP, lb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "long_or")
|
|
static void run_long_or() {
|
|
long la = R.nextLong();
|
|
long lb = R.nextLong();
|
|
long lr = long_or(la, lb);
|
|
Verify.checkEQ(lr, la | lb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.XOR_VL,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.XOR_L, ">= 1", IRNode.REPLICATE_L, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static long long_xor(long la, long lb) {
|
|
return LongVector.broadcast(LSP, la)
|
|
.lanewise(VectorOperators.XOR, LongVector.broadcast(LSP, lb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "long_xor")
|
|
static void run_long_xor() {
|
|
long la = R.nextLong();
|
|
long lb = R.nextLong();
|
|
long lr = long_xor(la, lb);
|
|
Verify.checkEQ(lr, la ^ lb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MIN_VL,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = {IRNode.REPLICATE_L, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static long long_min(long la, long lb) {
|
|
return LongVector.broadcast(LSP, la)
|
|
.min(LongVector.broadcast(LSP, lb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "long_min")
|
|
static void run_long_min() {
|
|
long la = R.nextLong();
|
|
long lb = R.nextLong();
|
|
long lr = long_min(la, lb);
|
|
Verify.checkEQ(lr, Math.min(la, lb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MAX_VL,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = {IRNode.REPLICATE_L, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static long long_max(long la, long lb) {
|
|
return LongVector.broadcast(LSP, la)
|
|
.max(LongVector.broadcast(LSP, lb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "long_max")
|
|
static void run_long_max() {
|
|
long la = R.nextLong();
|
|
long lb = R.nextLong();
|
|
long lr = long_max(la, lb);
|
|
Verify.checkEQ(lr, Math.max(la, lb));
|
|
}
|
|
|
|
/* =======================
|
|
* FLOAT
|
|
* ======================= */
|
|
|
|
static final VectorSpecies<Float> FSP = FloatVector.SPECIES_PREFERRED;
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VF,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_F, ">= 1", IRNode.REPLICATE_F, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static float float_add(float fa, float fb) {
|
|
return FloatVector.broadcast(FSP, fa)
|
|
.add(FloatVector.broadcast(FSP, fb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "float_add")
|
|
static void run_float_add() {
|
|
float fa = R.nextFloat();
|
|
float fb = R.nextFloat();
|
|
float fr = float_add(fa, fb);
|
|
Verify.checkEQ(fr, fa + fb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VF,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_F, ">= 1", IRNode.REPLICATE_F, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static float float_sub(float fa, float fb) {
|
|
return FloatVector.broadcast(FSP, fa)
|
|
.sub(FloatVector.broadcast(FSP, fb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "float_sub")
|
|
static void run_float_sub() {
|
|
float fa = R.nextFloat();
|
|
float fb = R.nextFloat();
|
|
float fr = float_sub(fa, fb);
|
|
Verify.checkEQ(fr, fa - fb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MUL_VF,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MUL_F, ">= 1", IRNode.REPLICATE_F, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static float float_mul(float fa, float fb) {
|
|
return FloatVector.broadcast(FSP, fa)
|
|
.mul(FloatVector.broadcast(FSP, fb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "float_mul")
|
|
static void run_float_mul() {
|
|
float fa = R.nextFloat();
|
|
float fb = R.nextFloat();
|
|
float fr = float_mul(fa, fb);
|
|
Verify.checkEQ(fr, fa * fb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.DIV_VF,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.DIV_F, ">= 1", IRNode.REPLICATE_F, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static float float_div(float fa, float fb) {
|
|
return FloatVector.broadcast(FSP, fa)
|
|
.div(FloatVector.broadcast(FSP, fb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "float_div")
|
|
static void run_float_div() {
|
|
float fa = R.nextFloat();
|
|
float fb = R.nextFloat();
|
|
if (fb == 0f) fb = 1f;
|
|
float fr = float_div(fa, fb);
|
|
Verify.checkEQ(fr, fa / fb);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MIN_VF,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MIN_F, ">= 1", IRNode.REPLICATE_F, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static float float_min(float fa, float fb) {
|
|
return FloatVector.broadcast(FSP, fa)
|
|
.min(FloatVector.broadcast(FSP, fb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "float_min")
|
|
static void run_float_min() {
|
|
float fa = R.nextFloat();
|
|
float fb = R.nextFloat();
|
|
float fr = float_min(fa, fb);
|
|
Verify.checkEQ(fr, Math.min(fa, fb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MAX_VF,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MAX_F, ">= 1", IRNode.REPLICATE_F, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static float float_max(float fa, float fb) {
|
|
return FloatVector.broadcast(FSP, fa)
|
|
.max(FloatVector.broadcast(FSP, fb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "float_max")
|
|
static void run_float_max() {
|
|
float fa = R.nextFloat();
|
|
float fb = R.nextFloat();
|
|
float fr = float_max(fa, fb);
|
|
Verify.checkEQ(fr, Math.max(fa, fb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SQRT_VF,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SQRT_F, ">= 1", IRNode.REPLICATE_F, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static float float_sqrt(float fa) {
|
|
return FloatVector.broadcast(FSP, fa)
|
|
.sqrt()
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "float_sqrt")
|
|
static void run_float_sqrt() {
|
|
float fa = Math.abs(R.nextFloat()) + Float.MIN_VALUE;
|
|
float fr = float_sqrt(fa);
|
|
Verify.checkEQ(fr, (float) Math.sqrt(fa));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.FMA_VF,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.FMA_F, ">= 1", IRNode.REPLICATE_F, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static float float_fma(float fa, float fb, float fc) {
|
|
return FloatVector.broadcast(FSP, fa)
|
|
.fma(FloatVector.broadcast(FSP, fb),
|
|
FloatVector.broadcast(FSP, fc))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "float_fma")
|
|
static void run_float_fma() {
|
|
float fa = R.nextFloat();
|
|
float fb = R.nextFloat();
|
|
float fc = R.nextFloat();
|
|
float fr = float_fma(fa, fb, fc);
|
|
Verify.checkEQ(fr, Math.fma(fa, fb, fc));
|
|
}
|
|
|
|
/* =======================
|
|
* DOUBLE
|
|
* ======================= */
|
|
|
|
static final VectorSpecies<Double> DSP = DoubleVector.SPECIES_PREFERRED;
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VD,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_D, ">= 1", IRNode.REPLICATE_D, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static double double_add(double da, double db) {
|
|
return DoubleVector.broadcast(DSP, da)
|
|
.add(DoubleVector.broadcast(DSP, db))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "double_add")
|
|
static void run_double_add() {
|
|
double da = R.nextDouble();
|
|
double db = R.nextDouble();
|
|
double dr = double_add(da, db);
|
|
Verify.checkEQ(dr, da + db);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VD,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_D, ">= 1", IRNode.REPLICATE_D, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static double double_sub(double da, double db) {
|
|
return DoubleVector.broadcast(DSP, da)
|
|
.sub(DoubleVector.broadcast(DSP, db))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "double_sub")
|
|
static void run_double_sub() {
|
|
double da = R.nextDouble();
|
|
double db = R.nextDouble();
|
|
double dr = double_sub(da, db);
|
|
Verify.checkEQ(dr, da - db);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MUL_VD,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MUL_D, ">= 1", IRNode.REPLICATE_D, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static double double_mul(double da, double db) {
|
|
return DoubleVector.broadcast(DSP, da)
|
|
.mul(DoubleVector.broadcast(DSP, db))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "double_mul")
|
|
static void run_double_mul() {
|
|
double da = R.nextDouble();
|
|
double db = R.nextDouble();
|
|
double dr = double_mul(da, db);
|
|
Verify.checkEQ(dr, da * db);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.DIV_VD,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.DIV_D, ">= 1", IRNode.REPLICATE_D, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static double double_div(double da, double db) {
|
|
return DoubleVector.broadcast(DSP, da)
|
|
.div(DoubleVector.broadcast(DSP, db))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "double_div")
|
|
static void run_double_div() {
|
|
double da = R.nextDouble();
|
|
double db = R.nextDouble();
|
|
if (db == 0d) db = 1d;
|
|
double dr = double_div(da, db);
|
|
Verify.checkEQ(dr, da / db);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MIN_VD,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MIN_D, ">= 1", IRNode.REPLICATE_D, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static double double_min(double da, double db) {
|
|
return DoubleVector.broadcast(DSP, da)
|
|
.min(DoubleVector.broadcast(DSP, db))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "double_min")
|
|
static void run_double_min() {
|
|
double da = R.nextDouble();
|
|
double db = R.nextDouble();
|
|
double dr = double_min(da, db);
|
|
Verify.checkEQ(dr, Math.min(da, db));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MAX_VD,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MAX_D, ">= 1", IRNode.REPLICATE_D, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static double double_max(double da, double db) {
|
|
return DoubleVector.broadcast(DSP, da)
|
|
.max(DoubleVector.broadcast(DSP, db))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "double_max")
|
|
static void run_double_max() {
|
|
double da = R.nextDouble();
|
|
double db = R.nextDouble();
|
|
double dr = double_max(da, db);
|
|
Verify.checkEQ(dr, Math.max(da, db));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SQRT_VD,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SQRT_D, ">= 1", IRNode.REPLICATE_D, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static double double_sqrt(double da) {
|
|
return DoubleVector.broadcast(DSP, da)
|
|
.sqrt()
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "double_sqrt")
|
|
static void run_double_sqrt() {
|
|
double da = Math.abs(R.nextDouble()) + Double.MIN_VALUE;
|
|
double dr = double_sqrt(da);
|
|
Verify.checkEQ(dr, Math.sqrt(da));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.FMA_VD,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.FMA_D, ">= 1", IRNode.REPLICATE_D, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static double double_fma(double da, double db, double dc) {
|
|
return DoubleVector.broadcast(DSP, da)
|
|
.fma(DoubleVector.broadcast(DSP, db),
|
|
DoubleVector.broadcast(DSP, dc))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "double_fma")
|
|
static void run_double_fma() {
|
|
double da = R.nextDouble();
|
|
double db = R.nextDouble();
|
|
double dc = R.nextDouble();
|
|
double dr = double_fma(da, db, dc);
|
|
Verify.checkEQ(dr, Math.fma(da, db, dc));
|
|
}
|
|
|
|
/* =======================
|
|
* BYTE
|
|
* ======================= */
|
|
|
|
static final VectorSpecies<Byte> BSP = ByteVector.SPECIES_PREFERRED;
|
|
static byte B_MAX = Byte.MAX_VALUE, B_MIN = Byte.MIN_VALUE;
|
|
static byte B_ONE = (byte) 1, B_NEG_ONE = (byte) -1;
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_I, ">= 1",
|
|
IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_add(byte ba, byte bb) {
|
|
return ByteVector.broadcast(BSP, ba)
|
|
.add(ByteVector.broadcast(BSP, bb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_add")
|
|
static void run_byte_add() {
|
|
byte ba = (byte) R.nextInt();
|
|
byte bb = (byte) R.nextInt();
|
|
byte br = byte_add(ba, bb);
|
|
Verify.checkEQ(br, (byte) (ba + bb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_I, ">= 1",
|
|
IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_sub(byte ba, byte bb) {
|
|
return ByteVector.broadcast(BSP, ba)
|
|
.sub(ByteVector.broadcast(BSP, bb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_sub")
|
|
static void run_byte_sub() {
|
|
byte ba = (byte) R.nextInt();
|
|
byte bb = (byte) R.nextInt();
|
|
byte br = byte_sub(ba, bb);
|
|
Verify.checkEQ(br, (byte) (ba - bb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_I, ">= 1",
|
|
IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_add_overflow() {
|
|
return ByteVector.broadcast(BSP, B_MAX)
|
|
.add(ByteVector.broadcast(BSP, B_ONE))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_add_overflow")
|
|
static void run_byte_add_overflow() {
|
|
byte br = byte_add_overflow();
|
|
Verify.checkEQ(br, (byte) (B_MAX + B_ONE));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_I, ">= 1",
|
|
IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_add_underflow() {
|
|
return ByteVector.broadcast(BSP, B_MIN)
|
|
.add(ByteVector.broadcast(BSP, B_NEG_ONE))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_add_underflow")
|
|
static void run_byte_add_underflow() {
|
|
byte br = byte_add_underflow();
|
|
Verify.checkEQ(br, (byte) (B_MIN + B_NEG_ONE));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_I, ">= 1",
|
|
IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_sub_overflow() {
|
|
return ByteVector.broadcast(BSP, B_MAX)
|
|
.sub(ByteVector.broadcast(BSP, B_NEG_ONE))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_sub_overflow")
|
|
static void run_byte_sub_overflow() {
|
|
byte br = byte_sub_overflow();
|
|
Verify.checkEQ(br, (byte) (B_MAX - B_NEG_ONE));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_I, ">= 1",
|
|
IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_sub_underflow() {
|
|
return ByteVector.broadcast(BSP, B_MIN)
|
|
.sub(ByteVector.broadcast(BSP, B_ONE))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_sub_underflow")
|
|
static void run_byte_sub_underflow() {
|
|
byte br = byte_sub_underflow();
|
|
Verify.checkEQ(br, (byte) (B_MIN - B_ONE));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MUL_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MUL_I, ">= 1",
|
|
IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_mul(byte ba, byte bb) {
|
|
return ByteVector.broadcast(BSP, ba)
|
|
.mul(ByteVector.broadcast(BSP, bb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_mul")
|
|
static void run_byte_mul() {
|
|
byte ba = (byte) R.nextInt();
|
|
byte bb = (byte) R.nextInt();
|
|
byte br = byte_mul(ba, bb);
|
|
Verify.checkEQ(br, (byte) (ba * bb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.AND_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.AND_I, ">= 1", IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_and(byte ba, byte bb) {
|
|
return ByteVector.broadcast(BSP, ba)
|
|
.and(ByteVector.broadcast(BSP, bb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_and")
|
|
static void run_byte_and() {
|
|
byte ba = (byte) R.nextInt();
|
|
byte bb = (byte) R.nextInt();
|
|
byte br = byte_and(ba, bb);
|
|
Verify.checkEQ(br, (byte) (ba & bb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.OR_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.OR_I, ">= 1", IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_or(byte ba, byte bb) {
|
|
return ByteVector.broadcast(BSP, ba)
|
|
.or(ByteVector.broadcast(BSP, bb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_or")
|
|
static void run_byte_or() {
|
|
byte ba = (byte) R.nextInt();
|
|
byte bb = (byte) R.nextInt();
|
|
byte br = byte_or(ba, bb);
|
|
Verify.checkEQ(br, (byte) (ba | bb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.XOR_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.XOR_I, ">= 1", IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_xor(byte ba, byte bb) {
|
|
return ByteVector.broadcast(BSP, ba)
|
|
.lanewise(VectorOperators.XOR, ByteVector.broadcast(BSP, bb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_xor")
|
|
static void run_byte_xor() {
|
|
byte ba = (byte) R.nextInt();
|
|
byte bb = (byte) R.nextInt();
|
|
byte br = byte_xor(ba, bb);
|
|
Verify.checkEQ(br, (byte) (ba ^ bb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MIN_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MIN_I, ">= 1", IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_min(byte ba, byte bb) {
|
|
return ByteVector.broadcast(BSP, ba)
|
|
.min(ByteVector.broadcast(BSP, bb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_min")
|
|
static void run_byte_min() {
|
|
byte ba = (byte) R.nextInt();
|
|
byte bb = (byte) R.nextInt();
|
|
byte br = byte_min(ba, bb);
|
|
Verify.checkEQ(br, (byte) Math.min(ba, bb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MAX_VB,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MAX_I, ">= 1", IRNode.REPLICATE_B, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static byte byte_max(byte ba, byte bb) {
|
|
return ByteVector.broadcast(BSP, ba)
|
|
.max(ByteVector.broadcast(BSP, bb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "byte_max")
|
|
static void run_byte_max() {
|
|
byte ba = (byte) R.nextInt();
|
|
byte bb = (byte) R.nextInt();
|
|
byte br = byte_max(ba, bb);
|
|
Verify.checkEQ(br, (byte) Math.max(ba, bb));
|
|
}
|
|
|
|
/* =======================
|
|
* SHORT
|
|
* ======================= */
|
|
|
|
static final VectorSpecies<Short> SSP = ShortVector.SPECIES_PREFERRED;
|
|
static short S_MAX = Short.MAX_VALUE, S_MIN = Short.MIN_VALUE;
|
|
static short S_ONE = (short) 1, S_NEG_ONE = (short) -1;
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_I, ">= 1",
|
|
IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_add(short sa, short sb) {
|
|
return ShortVector.broadcast(SSP, sa)
|
|
.add(ShortVector.broadcast(SSP, sb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_add")
|
|
static void run_short_add() {
|
|
short sa = (short) R.nextInt();
|
|
short sb = (short) R.nextInt();
|
|
short sr = short_add(sa, sb);
|
|
Verify.checkEQ(sr, (short) (sa + sb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_I, ">= 1",
|
|
IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_sub(short sa, short sb) {
|
|
return ShortVector.broadcast(SSP, sa)
|
|
.sub(ShortVector.broadcast(SSP, sb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_sub")
|
|
static void run_short_sub() {
|
|
short sa = (short) R.nextInt();
|
|
short sb = (short) R.nextInt();
|
|
short sr = short_sub(sa, sb);
|
|
Verify.checkEQ(sr, (short) (sa - sb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_I, ">= 1",
|
|
IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_add_overflow() {
|
|
return ShortVector.broadcast(SSP, S_MAX)
|
|
.add(ShortVector.broadcast(SSP, S_ONE))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_add_overflow")
|
|
static void run_short_add_overflow() {
|
|
short sr = short_add_overflow();
|
|
Verify.checkEQ(sr, (short) (S_MAX + S_ONE));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.ADD_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.ADD_I, ">= 1",
|
|
IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_add_underflow() {
|
|
return ShortVector.broadcast(SSP, S_MIN)
|
|
.add(ShortVector.broadcast(SSP, S_NEG_ONE))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_add_underflow")
|
|
static void run_short_add_underflow() {
|
|
short sr = short_add_underflow();
|
|
Verify.checkEQ(sr, (short) (S_MIN + S_NEG_ONE));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_I, ">= 1",
|
|
IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_sub_overflow() {
|
|
return ShortVector.broadcast(SSP, S_MAX)
|
|
.sub(ShortVector.broadcast(SSP, S_NEG_ONE))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_sub_overflow")
|
|
static void run_short_sub_overflow() {
|
|
short sr = short_sub_overflow();
|
|
Verify.checkEQ(sr, (short) (S_MAX - S_NEG_ONE));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.SUB_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.SUB_I, ">= 1",
|
|
IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_sub_underflow() {
|
|
return ShortVector.broadcast(SSP, S_MIN)
|
|
.sub(ShortVector.broadcast(SSP, S_ONE))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_sub_underflow")
|
|
static void run_short_sub_underflow() {
|
|
short sr = short_sub_underflow();
|
|
Verify.checkEQ(sr, (short) (S_MIN - S_ONE));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MUL_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MUL_I, ">= 1",
|
|
IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_mul(short sa, short sb) {
|
|
return ShortVector.broadcast(SSP, sa)
|
|
.mul(ShortVector.broadcast(SSP, sb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_mul")
|
|
static void run_short_mul() {
|
|
short sa = (short) R.nextInt();
|
|
short sb = (short) R.nextInt();
|
|
short sr = short_mul(sa, sb);
|
|
Verify.checkEQ(sr, (short) (sa * sb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.AND_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.AND_I, ">= 1", IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_and(short sa, short sb) {
|
|
return ShortVector.broadcast(SSP, sa)
|
|
.and(ShortVector.broadcast(SSP, sb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_and")
|
|
static void run_short_and() {
|
|
short sa = (short) R.nextInt();
|
|
short sb = (short) R.nextInt();
|
|
short sr = short_and(sa, sb);
|
|
Verify.checkEQ(sr, (short) (sa & sb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.OR_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.OR_I, ">= 1", IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_or(short sa, short sb) {
|
|
return ShortVector.broadcast(SSP, sa)
|
|
.or(ShortVector.broadcast(SSP, sb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_or")
|
|
static void run_short_or() {
|
|
short sa = (short) R.nextInt();
|
|
short sb = (short) R.nextInt();
|
|
short sr = short_or(sa, sb);
|
|
Verify.checkEQ(sr, (short) (sa | sb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.XOR_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.XOR_I, ">= 1", IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_xor(short sa, short sb) {
|
|
return ShortVector.broadcast(SSP, sa)
|
|
.lanewise(VectorOperators.XOR, ShortVector.broadcast(SSP, sb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_xor")
|
|
static void run_short_xor() {
|
|
short sa = (short) R.nextInt();
|
|
short sb = (short) R.nextInt();
|
|
short sr = short_xor(sa, sb);
|
|
Verify.checkEQ(sr, (short) (sa ^ sb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MIN_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MIN_I, ">= 1", IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_min(short sa, short sb) {
|
|
return ShortVector.broadcast(SSP, sa)
|
|
.min(ShortVector.broadcast(SSP, sb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_min")
|
|
static void run_short_min() {
|
|
short sa = (short) R.nextInt();
|
|
short sb = (short) R.nextInt();
|
|
short sr = short_min(sa, sb);
|
|
Verify.checkEQ(sr, (short) Math.min(sa, sb));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = IRNode.MAX_VS,
|
|
applyIfCPUFeatureOr = {"avx", "true", "asimd", "true"},
|
|
counts = { IRNode.MAX_I, ">= 1", IRNode.REPLICATE_S, IRNode.VECTOR_SIZE_ANY, ">= 1" })
|
|
static short short_max(short sa, short sb) {
|
|
return ShortVector.broadcast(SSP, sa)
|
|
.max(ShortVector.broadcast(SSP, sb))
|
|
.lane(0);
|
|
}
|
|
|
|
@Run(test = "short_max")
|
|
static void run_short_max() {
|
|
short sa = (short) R.nextInt();
|
|
short sb = (short) R.nextInt();
|
|
short sr = short_max(sa, sb);
|
|
Verify.checkEQ(sr, (short) Math.max(sa, sb));
|
|
}
|
|
|
|
}
|