Skip to content

Commit 7002233

Browse files
author
Jatin Bhateja
committed
8351950: C2: AVX512 vector assembler routines causing SIGFPE / no valid evex tuple_table entry
Reviewed-by: epeter, sviswanathan
1 parent f825a51 commit 7002233

37 files changed

+4095
-48
lines changed

‎src/hotspot/cpu/x86/assembler_x86.cpp‎

Lines changed: 61 additions & 48 deletions
Large diffs are not rendered by default.

‎test/jdk/jdk/incubator/vector/Byte128VectorTests.java‎

Lines changed: 132 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -416,6 +416,17 @@ static void assertArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
416416
}
417417
}
418418

419+
static void assertArraysEquals(byte[] r, byte[] a, byte b, FBinOp f) {
420+
int i = 0;
421+
try {
422+
for (; i < a.length; i++) {
423+
Assert.assertEquals(r[i], f.apply(a[i], b));
424+
}
425+
} catch (AssertionError e) {
426+
Assert.assertEquals(r[i], f.apply(a[i], b), "(" + a[i] + ", " + b + ") at index #" + i);
427+
}
428+
}
429+
419430
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
420431
int i = 0;
421432
try {
@@ -455,6 +466,21 @@ static void assertArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBi
455466
}
456467
}
457468

469+
static void assertArraysEquals(byte[] r, byte[] a, byte b, boolean[] mask, FBinOp f) {
470+
assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
471+
}
472+
473+
static void assertArraysEquals(byte[] r, byte[] a, byte b, boolean[] mask, FBinMaskOp f) {
474+
int i = 0;
475+
try {
476+
for (; i < a.length; i++) {
477+
Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]));
478+
}
479+
} catch (AssertionError err) {
480+
Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b + ", mask = " + mask[i % SPECIES.length()]);
481+
}
482+
}
483+
458484
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
459485
assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
460486
}
@@ -2907,6 +2933,112 @@ static void ROLByte128VectorTestsScalarShiftMaskedConst(IntFunction<byte[]> fa,
29072933
}
29082934

29092935

2936+
static ByteVector bv_MIN = ByteVector.broadcast(SPECIES, (byte)10);
2937+
2938+
@Test(dataProvider = "byteUnaryOpProvider")
2939+
static void MINByte128VectorTestsWithMemOp(IntFunction<byte[]> fa) {
2940+
byte[] a = fa.apply(SPECIES.length());
2941+
byte[] r = fr.apply(SPECIES.length());
2942+
2943+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
2944+
for (int i = 0; i < a.length; i += SPECIES.length()) {
2945+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2946+
av.lanewise(VectorOperators.MIN, bv_MIN).intoArray(r, i);
2947+
}
2948+
}
2949+
2950+
assertArraysEquals(r, a, (byte)10, Byte128VectorTests::MIN);
2951+
}
2952+
2953+
static ByteVector bv_min = ByteVector.broadcast(SPECIES, (byte)10);
2954+
2955+
@Test(dataProvider = "byteUnaryOpProvider")
2956+
static void minByte128VectorTestsWithMemOp(IntFunction<byte[]> fa) {
2957+
byte[] a = fa.apply(SPECIES.length());
2958+
byte[] r = fr.apply(SPECIES.length());
2959+
2960+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
2961+
for (int i = 0; i < a.length; i += SPECIES.length()) {
2962+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2963+
av.min(bv_min).intoArray(r, i);
2964+
}
2965+
}
2966+
2967+
assertArraysEquals(r, a, (byte)10, Byte128VectorTests::min);
2968+
}
2969+
2970+
static ByteVector bv_MIN_M = ByteVector.broadcast(SPECIES, (byte)10);
2971+
2972+
@Test(dataProvider = "byteUnaryOpMaskProvider")
2973+
static void MINByte128VectorTestsMaskedWithMemOp(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
2974+
byte[] a = fa.apply(SPECIES.length());
2975+
byte[] r = fr.apply(SPECIES.length());
2976+
boolean[] mask = fm.apply(SPECIES.length());
2977+
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2978+
2979+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
2980+
for (int i = 0; i < a.length; i += SPECIES.length()) {
2981+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2982+
av.lanewise(VectorOperators.MIN, bv_MIN_M, vmask).intoArray(r, i);
2983+
}
2984+
}
2985+
2986+
assertArraysEquals(r, a, (byte)10, mask, Byte128VectorTests::MIN);
2987+
}
2988+
2989+
static ByteVector bv_MAX = ByteVector.broadcast(SPECIES, (byte)10);
2990+
2991+
@Test(dataProvider = "byteUnaryOpProvider")
2992+
static void MAXByte128VectorTestsWithMemOp(IntFunction<byte[]> fa) {
2993+
byte[] a = fa.apply(SPECIES.length());
2994+
byte[] r = fr.apply(SPECIES.length());
2995+
2996+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
2997+
for (int i = 0; i < a.length; i += SPECIES.length()) {
2998+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2999+
av.lanewise(VectorOperators.MAX, bv_MAX).intoArray(r, i);
3000+
}
3001+
}
3002+
3003+
assertArraysEquals(r, a, (byte)10, Byte128VectorTests::MAX);
3004+
}
3005+
3006+
static ByteVector bv_max = ByteVector.broadcast(SPECIES, (byte)10);
3007+
3008+
@Test(dataProvider = "byteUnaryOpProvider")
3009+
static void maxByte128VectorTestsWithMemOp(IntFunction<byte[]> fa) {
3010+
byte[] a = fa.apply(SPECIES.length());
3011+
byte[] r = fr.apply(SPECIES.length());
3012+
3013+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
3014+
for (int i = 0; i < a.length; i += SPECIES.length()) {
3015+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3016+
av.max(bv_max).intoArray(r, i);
3017+
}
3018+
}
3019+
3020+
assertArraysEquals(r, a, (byte)10, Byte128VectorTests::max);
3021+
}
3022+
3023+
static ByteVector bv_MAX_M = ByteVector.broadcast(SPECIES, (byte)10);
3024+
3025+
@Test(dataProvider = "byteUnaryOpMaskProvider")
3026+
static void MAXByte128VectorTestsMaskedWithMemOp(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3027+
byte[] a = fa.apply(SPECIES.length());
3028+
byte[] r = fr.apply(SPECIES.length());
3029+
boolean[] mask = fm.apply(SPECIES.length());
3030+
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3031+
3032+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
3033+
for (int i = 0; i < a.length; i += SPECIES.length()) {
3034+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3035+
av.lanewise(VectorOperators.MAX, bv_MAX_M, vmask).intoArray(r, i);
3036+
}
3037+
}
3038+
3039+
assertArraysEquals(r, a, (byte)10, mask, Byte128VectorTests::MAX);
3040+
}
3041+
29103042
static byte MIN(byte a, byte b) {
29113043
return (byte)(Math.min(a, b));
29123044
}

‎test/jdk/jdk/incubator/vector/Byte256VectorTests.java‎

Lines changed: 132 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -416,6 +416,17 @@ static void assertArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
416416
}
417417
}
418418

419+
static void assertArraysEquals(byte[] r, byte[] a, byte b, FBinOp f) {
420+
int i = 0;
421+
try {
422+
for (; i < a.length; i++) {
423+
Assert.assertEquals(r[i], f.apply(a[i], b));
424+
}
425+
} catch (AssertionError e) {
426+
Assert.assertEquals(r[i], f.apply(a[i], b), "(" + a[i] + ", " + b + ") at index #" + i);
427+
}
428+
}
429+
419430
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
420431
int i = 0;
421432
try {
@@ -455,6 +466,21 @@ static void assertArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBi
455466
}
456467
}
457468

469+
static void assertArraysEquals(byte[] r, byte[] a, byte b, boolean[] mask, FBinOp f) {
470+
assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
471+
}
472+
473+
static void assertArraysEquals(byte[] r, byte[] a, byte b, boolean[] mask, FBinMaskOp f) {
474+
int i = 0;
475+
try {
476+
for (; i < a.length; i++) {
477+
Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]));
478+
}
479+
} catch (AssertionError err) {
480+
Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b + ", mask = " + mask[i % SPECIES.length()]);
481+
}
482+
}
483+
458484
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
459485
assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
460486
}
@@ -2907,6 +2933,112 @@ static void ROLByte256VectorTestsScalarShiftMaskedConst(IntFunction<byte[]> fa,
29072933
}
29082934

29092935

2936+
static ByteVector bv_MIN = ByteVector.broadcast(SPECIES, (byte)10);
2937+
2938+
@Test(dataProvider = "byteUnaryOpProvider")
2939+
static void MINByte256VectorTestsWithMemOp(IntFunction<byte[]> fa) {
2940+
byte[] a = fa.apply(SPECIES.length());
2941+
byte[] r = fr.apply(SPECIES.length());
2942+
2943+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
2944+
for (int i = 0; i < a.length; i += SPECIES.length()) {
2945+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2946+
av.lanewise(VectorOperators.MIN, bv_MIN).intoArray(r, i);
2947+
}
2948+
}
2949+
2950+
assertArraysEquals(r, a, (byte)10, Byte256VectorTests::MIN);
2951+
}
2952+
2953+
static ByteVector bv_min = ByteVector.broadcast(SPECIES, (byte)10);
2954+
2955+
@Test(dataProvider = "byteUnaryOpProvider")
2956+
static void minByte256VectorTestsWithMemOp(IntFunction<byte[]> fa) {
2957+
byte[] a = fa.apply(SPECIES.length());
2958+
byte[] r = fr.apply(SPECIES.length());
2959+
2960+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
2961+
for (int i = 0; i < a.length; i += SPECIES.length()) {
2962+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2963+
av.min(bv_min).intoArray(r, i);
2964+
}
2965+
}
2966+
2967+
assertArraysEquals(r, a, (byte)10, Byte256VectorTests::min);
2968+
}
2969+
2970+
static ByteVector bv_MIN_M = ByteVector.broadcast(SPECIES, (byte)10);
2971+
2972+
@Test(dataProvider = "byteUnaryOpMaskProvider")
2973+
static void MINByte256VectorTestsMaskedWithMemOp(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
2974+
byte[] a = fa.apply(SPECIES.length());
2975+
byte[] r = fr.apply(SPECIES.length());
2976+
boolean[] mask = fm.apply(SPECIES.length());
2977+
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2978+
2979+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
2980+
for (int i = 0; i < a.length; i += SPECIES.length()) {
2981+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2982+
av.lanewise(VectorOperators.MIN, bv_MIN_M, vmask).intoArray(r, i);
2983+
}
2984+
}
2985+
2986+
assertArraysEquals(r, a, (byte)10, mask, Byte256VectorTests::MIN);
2987+
}
2988+
2989+
static ByteVector bv_MAX = ByteVector.broadcast(SPECIES, (byte)10);
2990+
2991+
@Test(dataProvider = "byteUnaryOpProvider")
2992+
static void MAXByte256VectorTestsWithMemOp(IntFunction<byte[]> fa) {
2993+
byte[] a = fa.apply(SPECIES.length());
2994+
byte[] r = fr.apply(SPECIES.length());
2995+
2996+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
2997+
for (int i = 0; i < a.length; i += SPECIES.length()) {
2998+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2999+
av.lanewise(VectorOperators.MAX, bv_MAX).intoArray(r, i);
3000+
}
3001+
}
3002+
3003+
assertArraysEquals(r, a, (byte)10, Byte256VectorTests::MAX);
3004+
}
3005+
3006+
static ByteVector bv_max = ByteVector.broadcast(SPECIES, (byte)10);
3007+
3008+
@Test(dataProvider = "byteUnaryOpProvider")
3009+
static void maxByte256VectorTestsWithMemOp(IntFunction<byte[]> fa) {
3010+
byte[] a = fa.apply(SPECIES.length());
3011+
byte[] r = fr.apply(SPECIES.length());
3012+
3013+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
3014+
for (int i = 0; i < a.length; i += SPECIES.length()) {
3015+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3016+
av.max(bv_max).intoArray(r, i);
3017+
}
3018+
}
3019+
3020+
assertArraysEquals(r, a, (byte)10, Byte256VectorTests::max);
3021+
}
3022+
3023+
static ByteVector bv_MAX_M = ByteVector.broadcast(SPECIES, (byte)10);
3024+
3025+
@Test(dataProvider = "byteUnaryOpMaskProvider")
3026+
static void MAXByte256VectorTestsMaskedWithMemOp(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3027+
byte[] a = fa.apply(SPECIES.length());
3028+
byte[] r = fr.apply(SPECIES.length());
3029+
boolean[] mask = fm.apply(SPECIES.length());
3030+
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3031+
3032+
for (int ic = 0; ic < INVOC_COUNT; ic++) {
3033+
for (int i = 0; i < a.length; i += SPECIES.length()) {
3034+
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3035+
av.lanewise(VectorOperators.MAX, bv_MAX_M, vmask).intoArray(r, i);
3036+
}
3037+
}
3038+
3039+
assertArraysEquals(r, a, (byte)10, mask, Byte256VectorTests::MAX);
3040+
}
3041+
29103042
static byte MIN(byte a, byte b) {
29113043
return (byte)(Math.min(a, b));
29123044
}

0 commit comments

Comments
 (0)