mirror of
https://github.com/openjdk/jdk.git
synced 2026-01-28 12:09:14 +00:00
fca9b3e513
`VectorMaskCastNode` is used to cast a vector mask from one type to
another type. The cast may be generated by calling the vector API `cast`
or generated by the compiler. For example, some vector mask operations
like `trueCount` require the input mask to be integer types, so for
floating point type masks, the compiler will cast the mask to the
corresponding integer type mask automatically before doing the mask
operation. This kind of cast is very common.
If the vector element size is not changed, the `VectorMaskCastNode`
don't generate code, otherwise code will be generated to extend or narrow
the mask. This IR node is not free no matter it generates code or not
because it may block some optimizations. For example:
1. `(VectorStoremask (VectorMaskCast (VectorLoadMask x)))`
The middle `VectorMaskCast` prevented the following optimization:
`(VectorStoremask (VectorLoadMask x)) => (x)`
2. `(VectorMaskToLong (VectorMaskCast (VectorLongToMask x)))`, which
blocks the optimization `(VectorMaskToLong (VectorLongToMask x)) => (x)`.
In these IR patterns, the value of the input `x` is not changed, so we
can safely do the optimization. But if the input value is changed, we
can't eliminate the cast.
The general idea of this PR is introducing an `uncast_mask` helper
function, which can be used to uncast a chain of `VectorMaskCastNode`,
like the existing `Node::uncast(bool)` function. The funtion returns
the first non `VectorMaskCastNode`.
The intended use case is when the IR pattern to be optimized may
contain one or more consecutive `VectorMaskCastNode` and this does not
affect the correctness of the optimization. Then this function can be
called to eliminate the `VectorMaskCastNode` chain.
Current optimizations related to `VectorMaskCastNode` include:
1. `(VectorMaskCast (VectorMaskCast x)) => (x)`, see JDK-8356760.
2. `(XorV (VectorMaskCast (VectorMaskCmp src1 src2 cond)) (Replicate -1))
=> (VectorMaskCast (VectorMaskCmp src1 src2 ncond))`, see JDK-8354242.
This PR does the following optimizations:
1. Extends the optimization pattern `(VectorMaskCast (VectorMaskCast x)) => (x)`
as `(VectorMaskCast (VectorMaskCast ... (VectorMaskCast x))) => (x)`.
Because as long as types of the head and tail `VectorMaskCastNode` are
consistent, the optimization is correct.
2. Supports a new optimization pattern
`(VectorStoreMask (VectorMaskCast ... (VectorLoadMask x))) => (x)`.
Since the value before and after the pattern is a boolean vector, it
remains unchanged as long as the vector length remains the same, and
this is guranteed in the api level.
I conducted some simple research on different mask generation methods
and mask operations, and obtained the following table, which includes
some potential optimization opportunities that may use this `uncast_mask`
function.
```
mask_gen\op toLong anyTrue allTrue trueCount firstTrue lastTrue
compare N/A N/A N/A N/A N/A N/A
maskAll TBI TBI TBI TBI TBI TBI
fromLong TBI TBI N/A TBI TBI TBI
mask_gen\op and or xor andNot not laneIsSet
compare N/A N/A N/A N/A TBI N/A
maskAll TBI TBI TBI TBI TBI TBI
fromLong N/A N/A N/A N/A TBI TBI
```
`TBI` indicated that there may be potential optimizations here that
require further investigation.
Benchmarks:
On a Nvidia Grace machine with 128-bit SVE2:
```
Benchmark Unit Before Error After Error Uplift
microMaskLoadCastStoreByte64 ops/us 59.23 0.21 148.12 0.07 2.50
microMaskLoadCastStoreDouble128 ops/us 2.43 0.00 38.31 0.01 15.73
microMaskLoadCastStoreFloat128 ops/us 6.19 0.00 75.67 0.11 12.22
microMaskLoadCastStoreInt128 ops/us 6.19 0.00 75.67 0.03 12.22
microMaskLoadCastStoreLong128 ops/us 2.43 0.00 38.32 0.01 15.74
microMaskLoadCastStoreShort64 ops/us 28.89 0.02 75.60 0.09 2.62
```
On a Nvidia Grace machine with 128-bit NEON:
```
Benchmark Unit Before Error After Error Uplift
microMaskLoadCastStoreByte64 ops/us 75.75 0.19 149.74 0.08 1.98
microMaskLoadCastStoreDouble128 ops/us 8.71 0.03 38.71 0.05 4.44
microMaskLoadCastStoreFloat128 ops/us 24.05 0.03 76.49 0.05 3.18
microMaskLoadCastStoreInt128 ops/us 24.06 0.02 76.51 0.05 3.18
microMaskLoadCastStoreLong128 ops/us 8.72 0.01 38.71 0.02 4.44
microMaskLoadCastStoreShort64 ops/us 24.64 0.01 76.43 0.06 3.10
```
On an AMD EPYC 9124 16-Core Processor with AVX3:
```
Benchmark Unit Before Error After Error Uplift
microMaskLoadCastStoreByte64 ops/us 82.13 0.31 115.14 0.08 1.40
microMaskLoadCastStoreDouble128 ops/us 0.32 0.00 0.32 0.00 1.01
microMaskLoadCastStoreFloat128 ops/us 42.18 0.05 57.56 0.07 1.36
microMaskLoadCastStoreInt128 ops/us 42.19 0.01 57.53 0.08 1.36
microMaskLoadCastStoreLong128 ops/us 0.30 0.01 0.32 0.00 1.05
microMaskLoadCastStoreShort64 ops/us 42.18 0.05 57.59 0.01 1.37
```
On an AMD EPYC 9124 16-Core Processor with AVX2:
```
Benchmark Unit Before Error After Error Uplift
microMaskLoadCastStoreByte64 ops/us 73.53 0.20 114.98 0.03 1.56
microMaskLoadCastStoreDouble128 ops/us 0.29 0.01 0.30 0.00 1.00
microMaskLoadCastStoreFloat128 ops/us 30.78 0.14 57.50 0.01 1.87
microMaskLoadCastStoreInt128 ops/us 30.65 0.26 57.50 0.01 1.88
microMaskLoadCastStoreLong128 ops/us 0.30 0.00 0.30 0.00 0.99
microMaskLoadCastStoreShort64 ops/us 24.92 0.00 57.49 0.01 2.31
```
On an AMD EPYC 9124 16-Core Processor with AVX1:
```
Benchmark Unit Before Error After Error Uplift
microMaskLoadCastStoreByte64 ops/us 79.68 0.01 248.49 0.91 3.12
microMaskLoadCastStoreDouble128 ops/us 0.28 0.00 0.28 0.00 1.00
microMaskLoadCastStoreFloat128 ops/us 31.11 0.04 95.48 2.27 3.07
microMaskLoadCastStoreInt128 ops/us 31.10 0.03 99.94 1.87 3.21
microMaskLoadCastStoreLong128 ops/us 0.28 0.00 0.28 0.00 0.99
microMaskLoadCastStoreShort64 ops/us 31.11 0.02 94.97 2.30 3.05
```
This PR was tested on 128-bit, 256-bit, and 512-bit (QEMU) aarch64
environments, and two 512-bit x64 machines with various configurations,
including sve2, sve1, neon, avx3, avx2, avx1, sse4 and sse3, all tests
passed.
1020 lines
44 KiB
Java
1020 lines
44 KiB
Java
/*
|
|
* Copyright (c) 2021, 2023, Arm Limited. All rights reserved.
|
|
* Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package compiler.vectorapi;
|
|
|
|
import compiler.lib.ir_framework.*;
|
|
|
|
import java.util.Random;
|
|
|
|
import jdk.incubator.vector.ByteVector;
|
|
import jdk.incubator.vector.DoubleVector;
|
|
import jdk.incubator.vector.FloatVector;
|
|
import jdk.incubator.vector.IntVector;
|
|
import jdk.incubator.vector.LongVector;
|
|
import jdk.incubator.vector.ShortVector;
|
|
import jdk.incubator.vector.VectorMask;
|
|
|
|
import jdk.test.lib.Asserts;
|
|
import jdk.test.lib.Utils;
|
|
|
|
/**
|
|
* @test
|
|
* @bug 8273264 8292898
|
|
* @key randomness
|
|
* @library /test/lib /
|
|
* @summary Unify vector mask cast and add missing rules for VectorMaskCast
|
|
* @modules jdk.incubator.vector
|
|
*
|
|
* @run driver compiler.vectorapi.VectorMaskCastTest
|
|
*/
|
|
|
|
// Current vector mask cast test cases at test/jdk/jdk/incubator/vector/*ConversionTests.java
|
|
// could not be intrinsfied, hence not able to verify compiler codegen, see [1]. As a
|
|
// supplement, we add more tests for vector mask cast operations, which could be intrinsified
|
|
// by c2 compiler to generate vector/mask instructions on supported targets.
|
|
//
|
|
// [1] https://bugs.openjdk.org/browse/JDK-8259610
|
|
|
|
public class VectorMaskCastTest {
|
|
|
|
private static final Random rd = Utils.getRandomInstance();
|
|
|
|
private static final boolean[] mask_arr;
|
|
|
|
static {
|
|
mask_arr = new boolean[64];
|
|
// Making sure atleast one of the elements in the mask is "true" to ensure the result of trueCount()
|
|
// before and after the cast can be accurately verified.
|
|
mask_arr[0] = true;
|
|
for (int i = 1; i < 64; i++) {
|
|
mask_arr[i] = rd.nextBoolean();
|
|
}
|
|
}
|
|
|
|
// Byte
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
|
|
public static VectorMask<Short> testByte64ToShort128(VectorMask<Byte> v) {
|
|
// A not operation is introduced to prevent the cast from being optimized away.
|
|
return v.not().cast(ShortVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testByte64ToShort128")
|
|
public static void testByte64ToShort128_runner() {
|
|
VectorMask<Byte> mByte64 = VectorMask.fromArray(ByteVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Short> res = testByte64ToShort128(mByte64);
|
|
mByte64 = mByte64.not();
|
|
Asserts.assertEquals(res.toString(), mByte64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Integer> testByte64ToInt256(VectorMask<Byte> v) {
|
|
return v.not().cast(IntVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testByte64ToInt256")
|
|
public static void testByte64ToInt256_runner() {
|
|
VectorMask<Byte> mByte64 = VectorMask.fromArray(ByteVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Integer> res = testByte64ToInt256(mByte64);
|
|
mByte64 = mByte64.not();
|
|
Asserts.assertEquals(res.toString(), mByte64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Float> testByte64ToFloat256(VectorMask<Byte> v) {
|
|
return v.not().cast(FloatVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testByte64ToFloat256")
|
|
public static void testByte64ToFloat256_runner() {
|
|
VectorMask<Byte> mByte64 = VectorMask.fromArray(ByteVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Float> res = testByte64ToFloat256(mByte64);
|
|
mByte64 = mByte64.not();
|
|
Asserts.assertEquals(res.toString(), mByte64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Long> testByte64ToLong512(VectorMask<Byte> v) {
|
|
return v.not().cast(LongVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testByte64ToLong512")
|
|
public static void testByte64ToLong512_runner() {
|
|
VectorMask<Byte> mByte64 = VectorMask.fromArray(ByteVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Long> res = testByte64ToLong512(mByte64);
|
|
mByte64 = mByte64.not();
|
|
Asserts.assertEquals(res.toString(), mByte64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Double> testByte64ToDouble512(VectorMask<Byte> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testByte64ToDouble512")
|
|
public static void testByte64ToDouble512_runner() {
|
|
VectorMask<Byte> mByte64 = VectorMask.fromArray(ByteVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Double> res = testByte64ToDouble512(mByte64);
|
|
mByte64 = mByte64.not();
|
|
Asserts.assertEquals(res.toString(), mByte64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Short> testByte128ToShort256(VectorMask<Byte> v) {
|
|
return v.not().cast(ShortVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testByte128ToShort256")
|
|
public static void testByte128ToShort256_runner() {
|
|
VectorMask<Byte> mByte128 = VectorMask.fromArray(ByteVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Short> res = testByte128ToShort256(mByte128);
|
|
mByte128 = mByte128.not();
|
|
Asserts.assertEquals(res.toString(), mByte128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Integer> testByte128ToInt512(VectorMask<Byte> v) {
|
|
return v.not().cast(IntVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testByte128ToInt512")
|
|
public static void testByte128ToInt512_runner() {
|
|
VectorMask<Byte> mByte128 = VectorMask.fromArray(ByteVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Integer> res = testByte128ToInt512(mByte128);
|
|
mByte128 = mByte128.not();
|
|
Asserts.assertEquals(res.toString(), mByte128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Float> testByte128ToFloat512(VectorMask<Byte> v) {
|
|
return v.not().cast(FloatVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testByte128ToFloat512")
|
|
public static void testByte128ToFloat512_runner() {
|
|
VectorMask<Byte> mByte128 = VectorMask.fromArray(ByteVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Float> res = testByte128ToFloat512(mByte128);
|
|
mByte128 = mByte128.not();
|
|
Asserts.assertEquals(res.toString(), mByte128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Short> testByte256ToShort512(VectorMask<Byte> v) {
|
|
return v.not().cast(ShortVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testByte256ToShort512")
|
|
public static void testByte256ToShort512_runner() {
|
|
VectorMask<Byte> mByte256 = VectorMask.fromArray(ByteVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Short> res = testByte256ToShort512(mByte256);
|
|
mByte256 = mByte256.not();
|
|
Asserts.assertEquals(res.toString(), mByte256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mByte256.trueCount());
|
|
}
|
|
|
|
// Short
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
|
|
public static VectorMask<Integer> testShort64ToInt128(VectorMask<Short> v) {
|
|
return v.not().cast(IntVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testShort64ToInt128")
|
|
public static void testShort64ToInt128_runner() {
|
|
VectorMask<Short> mShort64 = VectorMask.fromArray(ShortVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Integer> res = testShort64ToInt128(mShort64);
|
|
mShort64 = mShort64.not();
|
|
Asserts.assertEquals(res.toString(), mShort64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
|
|
public static VectorMask<Float> testShort64ToFloat128(VectorMask<Short> v) {
|
|
return v.not().cast(FloatVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testShort64ToFloat128")
|
|
public static void testShort64ToFloat128_runner() {
|
|
VectorMask<Short> mShort64 = VectorMask.fromArray(ShortVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Float> res = testShort64ToFloat128(mShort64);
|
|
mShort64 = mShort64.not();
|
|
Asserts.assertEquals(res.toString(), mShort64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Long> testShort64ToLong256(VectorMask<Short> v) {
|
|
return v.not().cast(LongVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testShort64ToLong256")
|
|
public static void testShort64ToLong256_runner() {
|
|
VectorMask<Short> mShort64 = VectorMask.fromArray(ShortVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Long> res = testShort64ToLong256(mShort64);
|
|
mShort64 = mShort64.not();
|
|
Asserts.assertEquals(res.toString(), mShort64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Double> testShort64ToDouble256(VectorMask<Short> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testShort64ToDouble256")
|
|
public static void testShort64ToDouble256_runner() {
|
|
VectorMask<Short> mShort64 = VectorMask.fromArray(ShortVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Double> res = testShort64ToDouble256(mShort64);
|
|
mShort64 = mShort64.not();
|
|
Asserts.assertEquals(res.toString(), mShort64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
|
|
public static VectorMask<Byte> testShort128ToByte64(VectorMask<Short> v) {
|
|
return v.not().cast(ByteVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testShort128ToByte64")
|
|
public static void testShort128ToByte64_runner() {
|
|
VectorMask<Short> mShort128 = VectorMask.fromArray(ShortVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Byte> res = testShort128ToByte64(mShort128);
|
|
mShort128 = mShort128.not();
|
|
Asserts.assertEquals(res.toString(), mShort128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Integer> testShort128ToInt256(VectorMask<Short> v) {
|
|
return v.not().cast(IntVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testShort128ToInt256")
|
|
public static void testShort128ToInt256_runner() {
|
|
VectorMask<Short> mShort128 = VectorMask.fromArray(ShortVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Integer> res = testShort128ToInt256(mShort128);
|
|
mShort128 = mShort128.not();
|
|
Asserts.assertEquals(res.toString(), mShort128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Float> testShort128ToFloat256(VectorMask<Short> v) {
|
|
return v.not().cast(FloatVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testShort128ToFloat256")
|
|
public static void testShort128ToFloat256_runner() {
|
|
VectorMask<Short> mShort128 = VectorMask.fromArray(ShortVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Float> res = testShort128ToFloat256(mShort128);
|
|
mShort128 = mShort128.not();
|
|
Asserts.assertEquals(res.toString(), mShort128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Long> testShort128ToLong512(VectorMask<Short> v) {
|
|
return v.not().cast(LongVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testShort128ToLong512")
|
|
public static void testShort128ToLong512_runner() {
|
|
VectorMask<Short> mShort128 = VectorMask.fromArray(ShortVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Long> res = testShort128ToLong512(mShort128);
|
|
mShort128 = mShort128.not();
|
|
Asserts.assertEquals(res.toString(), mShort128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Double> testShort128ToDouble512(VectorMask<Short> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testShort128ToDouble512")
|
|
public static void testShort128ToDouble512_runner() {
|
|
VectorMask<Short> mShort128 = VectorMask.fromArray(ShortVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Double> res = testShort128ToDouble512(mShort128);
|
|
mShort128 = mShort128.not();
|
|
Asserts.assertEquals(res.toString(), mShort128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Byte> testShort256ToByte128(VectorMask<Short> v) {
|
|
return v.not().cast(ByteVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testShort256ToByte128")
|
|
public static void testShort256ToByte128_runner() {
|
|
VectorMask<Short> mShort256 = VectorMask.fromArray(ShortVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Byte> res = testShort256ToByte128(mShort256);
|
|
mShort256 = mShort256.not();
|
|
Asserts.assertEquals(res.toString(), mShort256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Integer> testShort256ToInt512(VectorMask<Short> v) {
|
|
return v.not().cast(IntVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testShort256ToInt512")
|
|
public static void testShort256ToInt512_runner() {
|
|
VectorMask<Short> mShort256 = VectorMask.fromArray(ShortVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Integer> res = testShort256ToInt512(mShort256);
|
|
mShort256 = mShort256.not();
|
|
Asserts.assertEquals(res.toString(), mShort256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Float> testShort256ToFloat512(VectorMask<Short> v) {
|
|
return v.not().cast(FloatVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testShort256ToFloat512")
|
|
public static void testShort256ToFloat512_runner() {
|
|
VectorMask<Short> mShort256 = VectorMask.fromArray(ShortVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Float> res = testShort256ToFloat512(mShort256);
|
|
mShort256 = mShort256.not();
|
|
Asserts.assertEquals(res.toString(), mShort256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Byte> testShort512ToByte256(VectorMask<Short> v) {
|
|
return v.not().cast(ByteVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testShort512ToByte256")
|
|
public static void testShort512ToByte256_runner() {
|
|
VectorMask<Short> mShort512 = VectorMask.fromArray(ShortVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Byte> res = testShort512ToByte256(mShort512);
|
|
mShort512 = mShort512.not();
|
|
Asserts.assertEquals(res.toString(), mShort512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mShort512.trueCount());
|
|
}
|
|
|
|
// Int
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"asimd", "true"})
|
|
public static VectorMask<Long> testInt64ToLong128(VectorMask<Integer> v) {
|
|
return v.not().cast(LongVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testInt64ToLong128")
|
|
public static void testInt64ToLong128_runner() {
|
|
VectorMask<Integer> mInt64 = VectorMask.fromArray(IntVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Long> res = testInt64ToLong128(mInt64);
|
|
mInt64 = mInt64.not();
|
|
Asserts.assertEquals(res.toString(), mInt64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"asimd", "true"})
|
|
public static VectorMask<Double> testInt64ToDouble128(VectorMask<Integer> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testInt64ToDouble128")
|
|
public static void testInt64ToDouble128_runner() {
|
|
VectorMask<Integer> mInt64 = VectorMask.fromArray(IntVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Double> res = testInt64ToDouble128(mInt64);
|
|
mInt64 = mInt64.not();
|
|
Asserts.assertEquals(res.toString(), mInt64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
|
|
public static VectorMask<Short> testInt128ToShort64(VectorMask<Integer> v) {
|
|
return v.not().cast(ShortVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testInt128ToShort64")
|
|
public static void testInt128ToShort64_runner() {
|
|
VectorMask<Integer> mInt128 = VectorMask.fromArray(IntVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Short> res = testInt128ToShort64(mInt128);
|
|
mInt128 = mInt128.not();
|
|
Asserts.assertEquals(res.toString(), mInt128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Long> testInt128ToLong256(VectorMask<Integer> v) {
|
|
return v.not().cast(LongVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testInt128ToLong256")
|
|
public static void testInt128ToLong256_runner() {
|
|
VectorMask<Integer> mInt128 = VectorMask.fromArray(IntVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Long> res = testInt128ToLong256(mInt128);
|
|
mInt128 = mInt128.not();
|
|
Asserts.assertEquals(res.toString(), mInt128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Double> testInt128ToDouble256(VectorMask<Integer> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testInt128ToDouble256")
|
|
public static void testInt128ToDouble256_runner() {
|
|
VectorMask<Integer> mInt128 = VectorMask.fromArray(IntVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Double> res = testInt128ToDouble256(mInt128);
|
|
mInt128 = mInt128.not();
|
|
Asserts.assertEquals(res.toString(), mInt128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Short> testInt256ToShort128(VectorMask<Integer> v) {
|
|
return v.not().cast(ShortVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testInt256ToShort128")
|
|
public static void testInt256ToShort128_runner() {
|
|
VectorMask<Integer> mInt256 = VectorMask.fromArray(IntVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Short> res = testInt256ToShort128(mInt256);
|
|
mInt256 = mInt256.not();
|
|
Asserts.assertEquals(res.toString(), mInt256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Byte> testInt256ToByte64(VectorMask<Integer> v) {
|
|
return v.not().cast(ByteVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testInt256ToByte64")
|
|
public static void testInt256ToByte64_runner() {
|
|
VectorMask<Integer> mInt256 = VectorMask.fromArray(IntVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Byte> res = testInt256ToByte64(mInt256);
|
|
mInt256 = mInt256.not();
|
|
Asserts.assertEquals(res.toString(), mInt256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Long> testInt256ToLong512(VectorMask<Integer> v) {
|
|
return v.not().cast(LongVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testInt256ToLong512")
|
|
public static void testInt256ToLong512_runner() {
|
|
VectorMask<Integer> mInt256 = VectorMask.fromArray(IntVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Long> res = testInt256ToLong512(mInt256);
|
|
mInt256 = mInt256.not();
|
|
Asserts.assertEquals(res.toString(), mInt256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Double> testInt256ToDouble512(VectorMask<Integer> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testInt256ToDouble512")
|
|
public static void testInt256ToDouble512_runner() {
|
|
VectorMask<Integer> mInt256 = VectorMask.fromArray(IntVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Double> res = testInt256ToDouble512(mInt256);
|
|
mInt256 = mInt256.not();
|
|
Asserts.assertEquals(res.toString(), mInt256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Short> testInt512ToShort256(VectorMask<Integer> v) {
|
|
return v.not().cast(ShortVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testInt512ToShort256")
|
|
public static void testInt512ToShort256_runner() {
|
|
VectorMask<Integer> mInt512 = VectorMask.fromArray(IntVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Short> res = testInt512ToShort256(mInt512);
|
|
mInt512 = mInt512.not();
|
|
Asserts.assertEquals(res.toString(), mInt512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt512.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Byte> testInt512ToByte128(VectorMask<Integer> v) {
|
|
return v.not().cast(ByteVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testInt512ToByte128")
|
|
public static void testInt512ToByte128_runner() {
|
|
VectorMask<Integer> mInt512 = VectorMask.fromArray(IntVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Byte> res = testInt512ToByte128(mInt512);
|
|
mInt512 = mInt512.not();
|
|
Asserts.assertEquals(res.toString(), mInt512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mInt512.trueCount());
|
|
}
|
|
|
|
// Float
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"asimd", "true"})
|
|
public static VectorMask<Long> testFloat64ToLong128(VectorMask<Float> v) {
|
|
return v.not().cast(LongVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testFloat64ToLong128")
|
|
public static void testFloat64ToLong128_runner() {
|
|
VectorMask<Float> mFloat64 = VectorMask.fromArray(FloatVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Long> res = testFloat64ToLong128(mFloat64);
|
|
mFloat64 = mFloat64.not();
|
|
Asserts.assertEquals(res.toString(), mFloat64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"asimd", "true"})
|
|
public static VectorMask<Double> testFloat64ToDouble128(VectorMask<Float> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testFloat64ToDouble128")
|
|
public static void testFloat64ToDouble128_runner() {
|
|
VectorMask<Float> mFloat64 = VectorMask.fromArray(FloatVector.SPECIES_64, mask_arr, 0);
|
|
VectorMask<Double> res = testFloat64ToDouble128(mFloat64);
|
|
mFloat64 = mFloat64.not();
|
|
Asserts.assertEquals(res.toString(), mFloat64.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat64.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true"})
|
|
public static VectorMask<Short> testFloat128ToShort64(VectorMask<Float> v) {
|
|
return v.not().cast(ShortVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testFloat128ToShort64")
|
|
public static void testFloat128ToShort64_runner() {
|
|
VectorMask<Float> mFloat128 = VectorMask.fromArray(FloatVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Short> res = testFloat128ToShort64(mFloat128);
|
|
mFloat128 = mFloat128.not();
|
|
Asserts.assertEquals(res.toString(), mFloat128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Long> testFloat128ToLong256(VectorMask<Float> v) {
|
|
return v.not().cast(LongVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testFloat128ToLong256")
|
|
public static void testFloat128ToLong256_runner() {
|
|
VectorMask<Float> mFloat128 = VectorMask.fromArray(FloatVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Long> res = testFloat128ToLong256(mFloat128);
|
|
mFloat128 = mFloat128.not();
|
|
Asserts.assertEquals(res.toString(), mFloat128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Double> testFloat128ToDouble256(VectorMask<Float> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testFloat128ToDouble256")
|
|
public static void testFloat128ToDouble256_runner() {
|
|
VectorMask<Float> mFloat128 = VectorMask.fromArray(FloatVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Double> res = testFloat128ToDouble256(mFloat128);
|
|
mFloat128 = mFloat128.not();
|
|
Asserts.assertEquals(res.toString(), mFloat128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Short> testFloat256ToShort128(VectorMask<Float> v) {
|
|
return v.not().cast(ShortVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testFloat256ToShort128")
|
|
public static void testFloat256ToShort128_runner() {
|
|
VectorMask<Float> mFloat256 = VectorMask.fromArray(FloatVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Short> res = testFloat256ToShort128(mFloat256);
|
|
mFloat256 = mFloat256.not();
|
|
Asserts.assertEquals(res.toString(), mFloat256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Byte> testFloat256ToByte64(VectorMask<Float> v) {
|
|
return v.not().cast(ByteVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testFloat256ToByte64")
|
|
public static void testFloat256ToByte64_runner() {
|
|
VectorMask<Float> mFloat256 = VectorMask.fromArray(FloatVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Byte> res = testFloat256ToByte64(mFloat256);
|
|
mFloat256 = mFloat256.not();
|
|
Asserts.assertEquals(res.toString(), mFloat256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Long> testFloat256ToLong512(VectorMask<Float> v) {
|
|
return v.not().cast(LongVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testFloat256ToLong512")
|
|
public static void testFloat256ToLong512_runner() {
|
|
VectorMask<Float> mFloat256 = VectorMask.fromArray(FloatVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Long> res = testFloat256ToLong512(mFloat256);
|
|
mFloat256 = mFloat256.not();
|
|
Asserts.assertEquals(res.toString(), mFloat256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Double> testFloat256ToDouble512(VectorMask<Float> v) {
|
|
return v.not().cast(DoubleVector.SPECIES_512);
|
|
}
|
|
|
|
@Run(test = "testFloat256ToDouble512")
|
|
public static void testFloat256ToDouble512_runner() {
|
|
VectorMask<Float> mFloat256 = VectorMask.fromArray(FloatVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Double> res = testFloat256ToDouble512(mFloat256);
|
|
mFloat256 = mFloat256.not();
|
|
Asserts.assertEquals(res.toString(), mFloat256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Short> testFloat512ToShort256(VectorMask<Float> v) {
|
|
return v.not().cast(ShortVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testFloat512ToShort256")
|
|
public static void testFloat512ToShort256_runner() {
|
|
VectorMask<Float> mFloat512 = VectorMask.fromArray(FloatVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Short> res = testFloat512ToShort256(mFloat512);
|
|
mFloat512 = mFloat512.not();
|
|
Asserts.assertEquals(res.toString(), mFloat512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat512.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Byte> testFloat512ToByte128(VectorMask<Float> v) {
|
|
return v.not().cast(ByteVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testFloat512ToByte128")
|
|
public static void testFloat512ToByte128_runner() {
|
|
VectorMask<Float> mFloat512 = VectorMask.fromArray(FloatVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Byte> res = testFloat512ToByte128(mFloat512);
|
|
mFloat512 = mFloat512.not();
|
|
Asserts.assertEquals(res.toString(), mFloat512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mFloat512.trueCount());
|
|
}
|
|
|
|
// Long
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"asimd", "true"})
|
|
public static VectorMask<Integer> testLong128ToInt64(VectorMask<Long> v) {
|
|
return v.not().cast(IntVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testLong128ToInt64")
|
|
public static void testLong128ToInt64_runner() {
|
|
VectorMask<Long> mLong128 = VectorMask.fromArray(LongVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Integer> res = testLong128ToInt64(mLong128);
|
|
mLong128 = mLong128.not();
|
|
Asserts.assertEquals(res.toString(), mLong128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"asimd", "true"})
|
|
public static VectorMask<Float> testLong128ToFloat64(VectorMask<Long> v) {
|
|
return v.not().cast(FloatVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testLong128ToFloat64")
|
|
public static void testLong128ToFloat64_runner() {
|
|
VectorMask<Long> mLong128 = VectorMask.fromArray(LongVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Float> res = testLong128ToFloat64(mLong128);
|
|
mLong128 = mLong128.not();
|
|
Asserts.assertEquals(res.toString(), mLong128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Integer> testLong256ToInt128(VectorMask<Long> v) {
|
|
return v.not().cast(IntVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testLong256ToInt128")
|
|
public static void testLong256ToInt128_runner() {
|
|
VectorMask<Long> mLong256 = VectorMask.fromArray(LongVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Integer> res = testLong256ToInt128(mLong256);
|
|
mLong256 = mLong256.not();
|
|
Asserts.assertEquals(res.toString(), mLong256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Float> testLong256ToFloat128(VectorMask<Long> v) {
|
|
return v.not().cast(FloatVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testLong256ToFloat128")
|
|
public static void testLong256ToFloat128_runner() {
|
|
VectorMask<Long> mLong256 = VectorMask.fromArray(LongVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Float> res = testLong256ToFloat128(mLong256);
|
|
mLong256 = mLong256.not();
|
|
Asserts.assertEquals(res.toString(), mLong256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Short> testLong256ToShort64(VectorMask<Long> v) {
|
|
return v.not().cast(ShortVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testLong256ToShort64")
|
|
public static void testLong256ToShort64_runner() {
|
|
VectorMask<Long> mLong256 = VectorMask.fromArray(LongVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Short> res = testLong256ToShort64(mLong256);
|
|
mLong256 = mLong256.not();
|
|
Asserts.assertEquals(res.toString(), mLong256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Integer> testLong512ToInt256(VectorMask<Long> v) {
|
|
return v.not().cast(IntVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testLong512ToInt256")
|
|
public static void testLong512ToInt256_runner() {
|
|
VectorMask<Long> mLong512 = VectorMask.fromArray(LongVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Integer> res = testLong512ToInt256(mLong512);
|
|
mLong512 = mLong512.not();
|
|
Asserts.assertEquals(res.toString(), mLong512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong512.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Float> testLong512ToFloat256(VectorMask<Long> v) {
|
|
return v.not().cast(FloatVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testLong512ToFloat256")
|
|
public static void testLong512ToFloat256_runner() {
|
|
VectorMask<Long> mLong512 = VectorMask.fromArray(LongVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Float> res = testLong512ToFloat256(mLong512);
|
|
mLong512 = mLong512.not();
|
|
Asserts.assertEquals(res.toString(), mLong512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong512.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Short> testLong512ToShort128(VectorMask<Long> v) {
|
|
return v.not().cast(ShortVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testLong512ToShort128")
|
|
public static void testLong512ToShort128_runner() {
|
|
VectorMask<Long> mLong512 = VectorMask.fromArray(LongVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Short> res = testLong512ToShort128(mLong512);
|
|
mLong512 = mLong512.not();
|
|
Asserts.assertEquals(res.toString(), mLong512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong512.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Byte> testLong512ToByte64(VectorMask<Long> v) {
|
|
return v.not().cast(ByteVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testLong512ToByte64")
|
|
public static void testLong512ToByte64_runner() {
|
|
VectorMask<Long> mLong512 = VectorMask.fromArray(LongVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Byte> res = testLong512ToByte64(mLong512);
|
|
mLong512 = mLong512.not();
|
|
Asserts.assertEquals(res.toString(), mLong512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mLong512.trueCount());
|
|
}
|
|
|
|
// Double
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"asimd", "true"})
|
|
public static VectorMask<Integer> testDouble128ToInt64(VectorMask<Double> v) {
|
|
return v.not().cast(IntVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testDouble128ToInt64")
|
|
public static void testDouble128ToInt64_runner() {
|
|
VectorMask<Double> mDouble128 = VectorMask.fromArray(DoubleVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Integer> res = testDouble128ToInt64(mDouble128);
|
|
mDouble128 = mDouble128.not();
|
|
Asserts.assertEquals(res.toString(), mDouble128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"asimd", "true"})
|
|
public static VectorMask<Float> testDouble128ToFloat64(VectorMask<Double> v) {
|
|
return v.not().cast(FloatVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testDouble128ToFloat64")
|
|
public static void testDouble128ToFloat64_runner() {
|
|
VectorMask<Double> mDouble128 = VectorMask.fromArray(DoubleVector.SPECIES_128, mask_arr, 0);
|
|
VectorMask<Float> res = testDouble128ToFloat64(mDouble128);
|
|
mDouble128 = mDouble128.not();
|
|
Asserts.assertEquals(res.toString(), mDouble128.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble128.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Integer> testDouble256ToInt128(VectorMask<Double> v) {
|
|
return v.not().cast(IntVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testDouble256ToInt128")
|
|
public static void testDouble256ToInt128_runner() {
|
|
VectorMask<Double> mDouble256 = VectorMask.fromArray(DoubleVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Integer> res = testDouble256ToInt128(mDouble256);
|
|
mDouble256 = mDouble256.not();
|
|
Asserts.assertEquals(res.toString(), mDouble256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Float> testDouble256ToFloat128(VectorMask<Double> v) {
|
|
return v.not().cast(FloatVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testDouble256ToFloat128")
|
|
public static void testDouble256ToFloat128_runner() {
|
|
VectorMask<Double> mDouble256 = VectorMask.fromArray(DoubleVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Float> res = testDouble256ToFloat128(mDouble256);
|
|
mDouble256 = mDouble256.not();
|
|
Asserts.assertEquals(res.toString(), mDouble256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx2", "true"})
|
|
public static VectorMask<Short> testDouble256ToShort64(VectorMask<Double> v) {
|
|
return v.not().cast(ShortVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testDouble256ToShort64")
|
|
public static void testDouble256ToShort64_runner() {
|
|
VectorMask<Double> mDouble256 = VectorMask.fromArray(DoubleVector.SPECIES_256, mask_arr, 0);
|
|
VectorMask<Short> res = testDouble256ToShort64(mDouble256);
|
|
mDouble256 = mDouble256.not();
|
|
Asserts.assertEquals(res.toString(), mDouble256.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble256.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Integer> testDouble512ToInt256(VectorMask<Double> v) {
|
|
return v.not().cast(IntVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testDouble512ToInt256")
|
|
public static void testDouble512ToInt256_runner() {
|
|
VectorMask<Double> mDouble512 = VectorMask.fromArray(DoubleVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Integer> res = testDouble512ToInt256(mDouble512);
|
|
mDouble512 = mDouble512.not();
|
|
Asserts.assertEquals(res.toString(), mDouble512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble512.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Float> testDouble512ToFloat256(VectorMask<Double> v) {
|
|
return v.not().cast(FloatVector.SPECIES_256);
|
|
}
|
|
|
|
@Run(test = "testDouble512ToFloat256")
|
|
public static void testDouble512ToFloat256_runner() {
|
|
VectorMask<Double> mDouble512 = VectorMask.fromArray(DoubleVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Float> res = testDouble512ToFloat256(mDouble512);
|
|
mDouble512 = mDouble512.not();
|
|
Asserts.assertEquals(res.toString(), mDouble512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble512.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Short> testDouble512ToShort128(VectorMask<Double> v) {
|
|
return v.not().cast(ShortVector.SPECIES_128);
|
|
}
|
|
|
|
@Run(test = "testDouble512ToShort128")
|
|
public static void testDouble512ToShort128_runner() {
|
|
VectorMask<Double> mDouble512 = VectorMask.fromArray(DoubleVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Short> res = testDouble512ToShort128(mDouble512);
|
|
mDouble512 = mDouble512.not();
|
|
Asserts.assertEquals(res.toString(), mDouble512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble512.trueCount());
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.VECTOR_MASK_CAST, "> 0" }, applyIfCPUFeature = {"avx512vl", "true"})
|
|
public static VectorMask<Byte> testDouble512ToByte64(VectorMask<Double> v) {
|
|
return v.not().cast(ByteVector.SPECIES_64);
|
|
}
|
|
|
|
@Run(test = "testDouble512ToByte64")
|
|
public static void testDouble512ToByte64_runner() {
|
|
VectorMask<Double> mDouble512 = VectorMask.fromArray(DoubleVector.SPECIES_512, mask_arr, 0);
|
|
VectorMask<Byte> res = testDouble512ToByte64(mDouble512);
|
|
mDouble512 = mDouble512.not();
|
|
Asserts.assertEquals(res.toString(), mDouble512.toString());
|
|
Asserts.assertEquals(res.trueCount(), mDouble512.trueCount());
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
TestFramework testFramework = new TestFramework();
|
|
testFramework.setDefaultWarmup(5000)
|
|
.addFlags("--add-modules=jdk.incubator.vector")
|
|
.start();
|
|
}
|
|
}
|