From 03cbfaa733bc6a59da6ba5c0d0918245e534752a Mon Sep 17 00:00:00 2001
From: Amos Shi <ashi@openjdk.org>
Date: Mon, 26 Aug 2024 18:50:06 +0000
Subject: [PATCH] 8315024: Vector API FP reduction tests should not test for
exact equality
Reviewed-by: mdoerr
Backport-of: e6f23a90d4a53339a3c9c2b76fc5d317940e4472
---
.../vector/Double128VectorTests.java | 47 +++++++++++----
.../vector/Double256VectorTests.java | 47 +++++++++++----
.../vector/Double512VectorTests.java | 47 +++++++++++----
.../incubator/vector/Double64VectorTests.java | 47 +++++++++++----
.../vector/DoubleMaxVectorTests.java | 48 ++++++++++++----
.../incubator/vector/Float128VectorTests.java | 47 +++++++++++----
.../incubator/vector/Float256VectorTests.java | 47 +++++++++++----
.../incubator/vector/Float512VectorTests.java | 47 +++++++++++----
.../incubator/vector/Float64VectorTests.java | 47 +++++++++++----
.../incubator/vector/FloatMaxVectorTests.java | 48 ++++++++++++----
.../Unit-Reduction-Masked-op.template | 4 ++
.../templates/Unit-Reduction-op.template | 4 ++
.../vector/templates/Unit-header.template | 57 +++++++++++++++++++
13 files changed, 417 insertions(+), 120 deletions(-)
diff --git a/test/jdk/jdk/incubator/vector/Double128VectorTests.java b/test/jdk/jdk/incubator/vector/Double128VectorTests.java
index b00b0cbaaab..bf9c717cc59 100644
--- a/test/jdk/jdk/incubator/vector/Double128VectorTests.java
+++ b/test/jdk/jdk/incubator/vector/Double128VectorTests.java
@@ -59,6 +59,8 @@ public class Double128VectorTests extends AbstractVectorTest {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
+ // for floating point reduction ops that may introduce rounding errors
+ private static final double RELATIVE_ROUNDING_ERROR = (double)0.000001;
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128);
@@ -118,15 +120,21 @@ public class Double128VectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(double[] r, double rc, double[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEquals(double[] r, double rc, double[] a,
+ FReductionOp f, FReductionAllOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -140,15 +148,22 @@ public class Double128VectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -986,6 +1001,14 @@ public class Double128VectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
}),
+ withToString("double[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (double)0.01 + ((double)i / (i + 1)));
+ }),
+ withToString("double[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (double)0.01 + ((double)i / (i + 1)));
+ }),
withToString("double[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2135,7 +2158,7 @@ public class Double128VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Double128VectorTests::ADDReduce, Double128VectorTests::ADDReduceAll);
+ Double128VectorTests::ADDReduce, Double128VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double ADDReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 0;
@@ -2179,7 +2202,7 @@ public class Double128VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Double128VectorTests::ADDReduceMasked, Double128VectorTests::ADDReduceAllMasked);
+ Double128VectorTests::ADDReduceMasked, Double128VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MULReduce(double[] a, int idx) {
double res = 1;
@@ -2220,7 +2243,7 @@ public class Double128VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Double128VectorTests::MULReduce, Double128VectorTests::MULReduceAll);
+ Double128VectorTests::MULReduce, Double128VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double MULReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 1;
@@ -2264,7 +2287,7 @@ public class Double128VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Double128VectorTests::MULReduceMasked, Double128VectorTests::MULReduceAllMasked);
+ Double128VectorTests::MULReduceMasked, Double128VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MINReduce(double[] a, int idx) {
double res = Double.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/Double256VectorTests.java b/test/jdk/jdk/incubator/vector/Double256VectorTests.java
index 008b4dcc348..bb4694966d8 100644
--- a/test/jdk/jdk/incubator/vector/Double256VectorTests.java
+++ b/test/jdk/jdk/incubator/vector/Double256VectorTests.java
@@ -59,6 +59,8 @@ public class Double256VectorTests extends AbstractVectorTest {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
+ // for floating point reduction ops that may introduce rounding errors
+ private static final double RELATIVE_ROUNDING_ERROR = (double)0.000001;
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256);
@@ -118,15 +120,21 @@ public class Double256VectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(double[] r, double rc, double[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEquals(double[] r, double rc, double[] a,
+ FReductionOp f, FReductionAllOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -140,15 +148,22 @@ public class Double256VectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -986,6 +1001,14 @@ public class Double256VectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
}),
+ withToString("double[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (double)0.01 + ((double)i / (i + 1)));
+ }),
+ withToString("double[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (double)0.01 + ((double)i / (i + 1)));
+ }),
withToString("double[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2135,7 +2158,7 @@ public class Double256VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Double256VectorTests::ADDReduce, Double256VectorTests::ADDReduceAll);
+ Double256VectorTests::ADDReduce, Double256VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double ADDReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 0;
@@ -2179,7 +2202,7 @@ public class Double256VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Double256VectorTests::ADDReduceMasked, Double256VectorTests::ADDReduceAllMasked);
+ Double256VectorTests::ADDReduceMasked, Double256VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MULReduce(double[] a, int idx) {
double res = 1;
@@ -2220,7 +2243,7 @@ public class Double256VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Double256VectorTests::MULReduce, Double256VectorTests::MULReduceAll);
+ Double256VectorTests::MULReduce, Double256VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double MULReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 1;
@@ -2264,7 +2287,7 @@ public class Double256VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Double256VectorTests::MULReduceMasked, Double256VectorTests::MULReduceAllMasked);
+ Double256VectorTests::MULReduceMasked, Double256VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MINReduce(double[] a, int idx) {
double res = Double.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/Double512VectorTests.java b/test/jdk/jdk/incubator/vector/Double512VectorTests.java
index ce25f8ea703..72bb1a49c36 100644
--- a/test/jdk/jdk/incubator/vector/Double512VectorTests.java
+++ b/test/jdk/jdk/incubator/vector/Double512VectorTests.java
@@ -59,6 +59,8 @@ public class Double512VectorTests extends AbstractVectorTest {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
+ // for floating point reduction ops that may introduce rounding errors
+ private static final double RELATIVE_ROUNDING_ERROR = (double)0.000001;
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512);
@@ -118,15 +120,21 @@ public class Double512VectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(double[] r, double rc, double[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEquals(double[] r, double rc, double[] a,
+ FReductionOp f, FReductionAllOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -140,15 +148,22 @@ public class Double512VectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -986,6 +1001,14 @@ public class Double512VectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
}),
+ withToString("double[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (double)0.01 + ((double)i / (i + 1)));
+ }),
+ withToString("double[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (double)0.01 + ((double)i / (i + 1)));
+ }),
withToString("double[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2135,7 +2158,7 @@ public class Double512VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Double512VectorTests::ADDReduce, Double512VectorTests::ADDReduceAll);
+ Double512VectorTests::ADDReduce, Double512VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double ADDReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 0;
@@ -2179,7 +2202,7 @@ public class Double512VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Double512VectorTests::ADDReduceMasked, Double512VectorTests::ADDReduceAllMasked);
+ Double512VectorTests::ADDReduceMasked, Double512VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MULReduce(double[] a, int idx) {
double res = 1;
@@ -2220,7 +2243,7 @@ public class Double512VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Double512VectorTests::MULReduce, Double512VectorTests::MULReduceAll);
+ Double512VectorTests::MULReduce, Double512VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double MULReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 1;
@@ -2264,7 +2287,7 @@ public class Double512VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Double512VectorTests::MULReduceMasked, Double512VectorTests::MULReduceAllMasked);
+ Double512VectorTests::MULReduceMasked, Double512VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MINReduce(double[] a, int idx) {
double res = Double.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/Double64VectorTests.java b/test/jdk/jdk/incubator/vector/Double64VectorTests.java
index c4270d0f268..b445995543f 100644
--- a/test/jdk/jdk/incubator/vector/Double64VectorTests.java
+++ b/test/jdk/jdk/incubator/vector/Double64VectorTests.java
@@ -59,6 +59,8 @@ public class Double64VectorTests extends AbstractVectorTest {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
+ // for floating point reduction ops that may introduce rounding errors
+ private static final double RELATIVE_ROUNDING_ERROR = (double)0.000001;
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64);
@@ -118,15 +120,21 @@ public class Double64VectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(double[] r, double rc, double[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEquals(double[] r, double rc, double[] a,
+ FReductionOp f, FReductionAllOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -140,15 +148,22 @@ public class Double64VectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -986,6 +1001,14 @@ public class Double64VectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
}),
+ withToString("double[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (double)0.01 + ((double)i / (i + 1)));
+ }),
+ withToString("double[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (double)0.01 + ((double)i / (i + 1)));
+ }),
withToString("double[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2135,7 +2158,7 @@ public class Double64VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Double64VectorTests::ADDReduce, Double64VectorTests::ADDReduceAll);
+ Double64VectorTests::ADDReduce, Double64VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double ADDReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 0;
@@ -2179,7 +2202,7 @@ public class Double64VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Double64VectorTests::ADDReduceMasked, Double64VectorTests::ADDReduceAllMasked);
+ Double64VectorTests::ADDReduceMasked, Double64VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MULReduce(double[] a, int idx) {
double res = 1;
@@ -2220,7 +2243,7 @@ public class Double64VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Double64VectorTests::MULReduce, Double64VectorTests::MULReduceAll);
+ Double64VectorTests::MULReduce, Double64VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double MULReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 1;
@@ -2264,7 +2287,7 @@ public class Double64VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Double64VectorTests::MULReduceMasked, Double64VectorTests::MULReduceAllMasked);
+ Double64VectorTests::MULReduceMasked, Double64VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MINReduce(double[] a, int idx) {
double res = Double.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java b/test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java
index df037495d89..9db85a2f20e 100644
--- a/test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java
+++ b/test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java
@@ -65,6 +65,9 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
private static final int Max = 256; // juts so we can do N/Max
+ // for floating point reduction ops that may introduce rounding errors
+ private static final double RELATIVE_ROUNDING_ERROR = (double)0.000001;
+
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
interface FUnOp {
@@ -123,15 +126,21 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(double[] r, double rc, double[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEquals(double[] r, double rc, double[] a,
+ FReductionOp f, FReductionAllOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -145,15 +154,22 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (double)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ double relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -991,6 +1007,14 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
}),
+ withToString("double[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (double)0.01 + ((double)i / (i + 1)));
+ }),
+ withToString("double[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (double)0.01 + ((double)i / (i + 1)));
+ }),
withToString("double[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2140,7 +2164,7 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- DoubleMaxVectorTests::ADDReduce, DoubleMaxVectorTests::ADDReduceAll);
+ DoubleMaxVectorTests::ADDReduce, DoubleMaxVectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double ADDReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 0;
@@ -2184,7 +2208,7 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- DoubleMaxVectorTests::ADDReduceMasked, DoubleMaxVectorTests::ADDReduceAllMasked);
+ DoubleMaxVectorTests::ADDReduceMasked, DoubleMaxVectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MULReduce(double[] a, int idx) {
double res = 1;
@@ -2225,7 +2249,7 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- DoubleMaxVectorTests::MULReduce, DoubleMaxVectorTests::MULReduceAll);
+ DoubleMaxVectorTests::MULReduce, DoubleMaxVectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static double MULReduceMasked(double[] a, int idx, boolean[] mask) {
double res = 1;
@@ -2269,7 +2293,7 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- DoubleMaxVectorTests::MULReduceMasked, DoubleMaxVectorTests::MULReduceAllMasked);
+ DoubleMaxVectorTests::MULReduceMasked, DoubleMaxVectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static double MINReduce(double[] a, int idx) {
double res = Double.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/Float128VectorTests.java b/test/jdk/jdk/incubator/vector/Float128VectorTests.java
index ae38b606da9..c8a9aa4a80c 100644
--- a/test/jdk/jdk/incubator/vector/Float128VectorTests.java
+++ b/test/jdk/jdk/incubator/vector/Float128VectorTests.java
@@ -59,6 +59,8 @@ public class Float128VectorTests extends AbstractVectorTest {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
+ // for floating point reduction ops that may introduce rounding errors
+ private static final float RELATIVE_ROUNDING_ERROR = (float)0.000001;
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128);
@@ -118,15 +120,21 @@ public class Float128VectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(float[] r, float rc, float[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEquals(float[] r, float rc, float[] a,
+ FReductionOp f, FReductionAllOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -140,15 +148,22 @@ public class Float128VectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -996,6 +1011,14 @@ public class Float128VectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((float)(i + 1) == 0) ? 1 : (float)(i + 1)));
}),
+ withToString("float[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (float)0.01 + ((float)i / (i + 1)));
+ }),
+ withToString("float[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (float)0.01 + ((float)i / (i + 1)));
+ }),
withToString("float[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2145,7 +2168,7 @@ public class Float128VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Float128VectorTests::ADDReduce, Float128VectorTests::ADDReduceAll);
+ Float128VectorTests::ADDReduce, Float128VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float ADDReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 0;
@@ -2189,7 +2212,7 @@ public class Float128VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Float128VectorTests::ADDReduceMasked, Float128VectorTests::ADDReduceAllMasked);
+ Float128VectorTests::ADDReduceMasked, Float128VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MULReduce(float[] a, int idx) {
float res = 1;
@@ -2230,7 +2253,7 @@ public class Float128VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Float128VectorTests::MULReduce, Float128VectorTests::MULReduceAll);
+ Float128VectorTests::MULReduce, Float128VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float MULReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 1;
@@ -2274,7 +2297,7 @@ public class Float128VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Float128VectorTests::MULReduceMasked, Float128VectorTests::MULReduceAllMasked);
+ Float128VectorTests::MULReduceMasked, Float128VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MINReduce(float[] a, int idx) {
float res = Float.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/Float256VectorTests.java b/test/jdk/jdk/incubator/vector/Float256VectorTests.java
index be55fa2b458..fcbf7df409b 100644
--- a/test/jdk/jdk/incubator/vector/Float256VectorTests.java
+++ b/test/jdk/jdk/incubator/vector/Float256VectorTests.java
@@ -59,6 +59,8 @@ public class Float256VectorTests extends AbstractVectorTest {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
+ // for floating point reduction ops that may introduce rounding errors
+ private static final float RELATIVE_ROUNDING_ERROR = (float)0.000001;
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256);
@@ -118,15 +120,21 @@ public class Float256VectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(float[] r, float rc, float[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEquals(float[] r, float rc, float[] a,
+ FReductionOp f, FReductionAllOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -140,15 +148,22 @@ public class Float256VectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -996,6 +1011,14 @@ public class Float256VectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((float)(i + 1) == 0) ? 1 : (float)(i + 1)));
}),
+ withToString("float[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (float)0.01 + ((float)i / (i + 1)));
+ }),
+ withToString("float[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (float)0.01 + ((float)i / (i + 1)));
+ }),
withToString("float[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2145,7 +2168,7 @@ public class Float256VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Float256VectorTests::ADDReduce, Float256VectorTests::ADDReduceAll);
+ Float256VectorTests::ADDReduce, Float256VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float ADDReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 0;
@@ -2189,7 +2212,7 @@ public class Float256VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Float256VectorTests::ADDReduceMasked, Float256VectorTests::ADDReduceAllMasked);
+ Float256VectorTests::ADDReduceMasked, Float256VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MULReduce(float[] a, int idx) {
float res = 1;
@@ -2230,7 +2253,7 @@ public class Float256VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Float256VectorTests::MULReduce, Float256VectorTests::MULReduceAll);
+ Float256VectorTests::MULReduce, Float256VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float MULReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 1;
@@ -2274,7 +2297,7 @@ public class Float256VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Float256VectorTests::MULReduceMasked, Float256VectorTests::MULReduceAllMasked);
+ Float256VectorTests::MULReduceMasked, Float256VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MINReduce(float[] a, int idx) {
float res = Float.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/Float512VectorTests.java b/test/jdk/jdk/incubator/vector/Float512VectorTests.java
index f1f1b884d6b..597a590098a 100644
--- a/test/jdk/jdk/incubator/vector/Float512VectorTests.java
+++ b/test/jdk/jdk/incubator/vector/Float512VectorTests.java
@@ -59,6 +59,8 @@ public class Float512VectorTests extends AbstractVectorTest {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
+ // for floating point reduction ops that may introduce rounding errors
+ private static final float RELATIVE_ROUNDING_ERROR = (float)0.000001;
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512);
@@ -118,15 +120,21 @@ public class Float512VectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(float[] r, float rc, float[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEquals(float[] r, float rc, float[] a,
+ FReductionOp f, FReductionAllOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -140,15 +148,22 @@ public class Float512VectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -996,6 +1011,14 @@ public class Float512VectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((float)(i + 1) == 0) ? 1 : (float)(i + 1)));
}),
+ withToString("float[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (float)0.01 + ((float)i / (i + 1)));
+ }),
+ withToString("float[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (float)0.01 + ((float)i / (i + 1)));
+ }),
withToString("float[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2145,7 +2168,7 @@ public class Float512VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Float512VectorTests::ADDReduce, Float512VectorTests::ADDReduceAll);
+ Float512VectorTests::ADDReduce, Float512VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float ADDReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 0;
@@ -2189,7 +2212,7 @@ public class Float512VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Float512VectorTests::ADDReduceMasked, Float512VectorTests::ADDReduceAllMasked);
+ Float512VectorTests::ADDReduceMasked, Float512VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MULReduce(float[] a, int idx) {
float res = 1;
@@ -2230,7 +2253,7 @@ public class Float512VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Float512VectorTests::MULReduce, Float512VectorTests::MULReduceAll);
+ Float512VectorTests::MULReduce, Float512VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float MULReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 1;
@@ -2274,7 +2297,7 @@ public class Float512VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Float512VectorTests::MULReduceMasked, Float512VectorTests::MULReduceAllMasked);
+ Float512VectorTests::MULReduceMasked, Float512VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MINReduce(float[] a, int idx) {
float res = Float.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/Float64VectorTests.java b/test/jdk/jdk/incubator/vector/Float64VectorTests.java
index 47f0cf3f15b..b5877b9de46 100644
--- a/test/jdk/jdk/incubator/vector/Float64VectorTests.java
+++ b/test/jdk/jdk/incubator/vector/Float64VectorTests.java
@@ -59,6 +59,8 @@ public class Float64VectorTests extends AbstractVectorTest {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
+ // for floating point reduction ops that may introduce rounding errors
+ private static final float RELATIVE_ROUNDING_ERROR = (float)0.000001;
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64);
@@ -118,15 +120,21 @@ public class Float64VectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(float[] r, float rc, float[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEquals(float[] r, float rc, float[] a,
+ FReductionOp f, FReductionAllOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -140,15 +148,22 @@ public class Float64VectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -996,6 +1011,14 @@ public class Float64VectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((float)(i + 1) == 0) ? 1 : (float)(i + 1)));
}),
+ withToString("float[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (float)0.01 + ((float)i / (i + 1)));
+ }),
+ withToString("float[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (float)0.01 + ((float)i / (i + 1)));
+ }),
withToString("float[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2145,7 +2168,7 @@ public class Float64VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Float64VectorTests::ADDReduce, Float64VectorTests::ADDReduceAll);
+ Float64VectorTests::ADDReduce, Float64VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float ADDReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 0;
@@ -2189,7 +2212,7 @@ public class Float64VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Float64VectorTests::ADDReduceMasked, Float64VectorTests::ADDReduceAllMasked);
+ Float64VectorTests::ADDReduceMasked, Float64VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MULReduce(float[] a, int idx) {
float res = 1;
@@ -2230,7 +2253,7 @@ public class Float64VectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- Float64VectorTests::MULReduce, Float64VectorTests::MULReduceAll);
+ Float64VectorTests::MULReduce, Float64VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float MULReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 1;
@@ -2274,7 +2297,7 @@ public class Float64VectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- Float64VectorTests::MULReduceMasked, Float64VectorTests::MULReduceAllMasked);
+ Float64VectorTests::MULReduceMasked, Float64VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MINReduce(float[] a, int idx) {
float res = Float.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java b/test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java
index 511afbb680e..9a40694f869 100644
--- a/test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java
+++ b/test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java
@@ -65,6 +65,9 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
private static final int Max = 256; // juts so we can do N/Max
+ // for floating point reduction ops that may introduce rounding errors
+ private static final float RELATIVE_ROUNDING_ERROR = (float)0.000001;
+
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
interface FUnOp {
@@ -123,15 +126,21 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
static void assertReductionArraysEquals(float[] r, float rc, float[] a,
FReductionOp f, FReductionAllOp fa) {
+ assertReductionArraysEquals(r, rc, a, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEquals(float[] r, float rc, float[] a,
+ FReductionOp f, FReductionAllOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a));
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i));
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -145,15 +154,22 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (float)0.0);
+ }
+
+ static void assertReductionArraysEqualsMasked(float[] r, float rc, float[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ float relativeError) {
int i = 0;
try {
- Assert.assertEquals(rc, fa.apply(a, mask));
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
for (; i < a.length; i += SPECIES.length()) {
- Assert.assertEquals(r[i], f.apply(a, i, mask));
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
}
} catch (AssertionError e) {
- Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
- Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
}
}
@@ -1001,6 +1017,14 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> (((float)(i + 1) == 0) ? 1 : (float)(i + 1)));
}),
+ withToString("float[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> (float)0.01 + ((float)i / (i + 1)));
+ }),
+ withToString("float[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : (float)0.01 + ((float)i / (i + 1)));
+ }),
withToString("float[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
@@ -2150,7 +2174,7 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- FloatMaxVectorTests::ADDReduce, FloatMaxVectorTests::ADDReduceAll);
+ FloatMaxVectorTests::ADDReduce, FloatMaxVectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float ADDReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 0;
@@ -2194,7 +2218,7 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- FloatMaxVectorTests::ADDReduceMasked, FloatMaxVectorTests::ADDReduceAllMasked);
+ FloatMaxVectorTests::ADDReduceMasked, FloatMaxVectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MULReduce(float[] a, int idx) {
float res = 1;
@@ -2235,7 +2259,7 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
}
assertReductionArraysEquals(r, ra, a,
- FloatMaxVectorTests::MULReduce, FloatMaxVectorTests::MULReduceAll);
+ FloatMaxVectorTests::MULReduce, FloatMaxVectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR);
}
static float MULReduceMasked(float[] a, int idx, boolean[] mask) {
float res = 1;
@@ -2279,7 +2303,7 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
- FloatMaxVectorTests::MULReduceMasked, FloatMaxVectorTests::MULReduceAllMasked);
+ FloatMaxVectorTests::MULReduceMasked, FloatMaxVectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR);
}
static float MINReduce(float[] a, int idx) {
float res = Float.POSITIVE_INFINITY;
diff --git a/test/jdk/jdk/incubator/vector/templates/Unit-Reduction-Masked-op.template b/test/jdk/jdk/incubator/vector/templates/Unit-Reduction-Masked-op.template
index 70ffa79bf6f..1ded00af608 100644
--- a/test/jdk/jdk/incubator/vector/templates/Unit-Reduction-Masked-op.template
+++ b/test/jdk/jdk/incubator/vector/templates/Unit-Reduction-Masked-op.template
@@ -2,5 +2,9 @@
static void [[TEST]]Reduce$vectorteststype$Masked(IntFunction<$type$[]> fa, IntFunction<boolean[]> fm) {
[[KERNEL]]
assertReductionArraysEqualsMasked(r, ra, a, mask,
+#if[FP]
+ $vectorteststype$::[[TEST]]ReduceMasked, $vectorteststype$::[[TEST]]ReduceAllMasked, RELATIVE_ROUNDING_ERROR);
+#else[FP]
$vectorteststype$::[[TEST]]ReduceMasked, $vectorteststype$::[[TEST]]ReduceAllMasked);
+#end[FP]
}
diff --git a/test/jdk/jdk/incubator/vector/templates/Unit-Reduction-op.template b/test/jdk/jdk/incubator/vector/templates/Unit-Reduction-op.template
index b86248f3f09..15a3ba8c66c 100644
--- a/test/jdk/jdk/incubator/vector/templates/Unit-Reduction-op.template
+++ b/test/jdk/jdk/incubator/vector/templates/Unit-Reduction-op.template
@@ -2,5 +2,9 @@
static void [[TEST]]Reduce$vectorteststype$(IntFunction<$type$[]> fa) {
[[KERNEL]]
assertReductionArraysEquals(r, ra, a,
+#if[FP]
+ $vectorteststype$::[[TEST]]Reduce, $vectorteststype$::[[TEST]]ReduceAll, RELATIVE_ROUNDING_ERROR);
+#else[FP]
$vectorteststype$::[[TEST]]Reduce, $vectorteststype$::[[TEST]]ReduceAll);
+#end[FP]
}
diff --git a/test/jdk/jdk/incubator/vector/templates/Unit-header.template b/test/jdk/jdk/incubator/vector/templates/Unit-header.template
index 3e78d5897d5..089f9fef8d2 100644
--- a/test/jdk/jdk/incubator/vector/templates/Unit-header.template
+++ b/test/jdk/jdk/incubator/vector/templates/Unit-header.template
@@ -88,6 +88,10 @@ public class $vectorteststype$ extends AbstractVectorTest {
private static final int Max = 256; // juts so we can do N/$bits$
#end[MaxBit]
+#if[FP]
+ // for floating point reduction ops that may introduce rounding errors
+ private static final $type$ RELATIVE_ROUNDING_ERROR = ($type$)0.000001;
+#end[FP]
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / $bits$);
@@ -147,6 +151,9 @@ public class $vectorteststype$ extends AbstractVectorTest {
static void assertReductionArraysEquals($type$[] r, $type$ rc, $type$[] a,
FReductionOp f, FReductionAllOp fa) {
+#if[FP]
+ assertReductionArraysEquals(r, rc, a, f, fa, ($type$)0.0);
+#else[FP]
int i = 0;
try {
Assert.assertEquals(rc, fa.apply(a));
@@ -157,7 +164,25 @@ public class $vectorteststype$ extends AbstractVectorTest {
Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
}
+#end[FP]
+ }
+#if[FP]
+
+ static void assertReductionArraysEquals($type$[] r, $type$ rc, $type$[] a,
+ FReductionOp f, FReductionAllOp fa,
+ $type$ relativeError) {
+ int i = 0;
+ try {
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError));
+ for (; i < a.length; i += SPECIES.length()) {
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError));
+ }
+ } catch (AssertionError e) {
+ Assert.assertEquals(rc, fa.apply(a), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i), Math.abs(r[i] * relativeError), "at index #" + i);
+ }
}
+#end[FP]
interface FReductionMaskedOp {
$type$ apply($type$[] a, int idx, boolean[] mask);
@@ -169,6 +194,9 @@ public class $vectorteststype$ extends AbstractVectorTest {
static void assertReductionArraysEqualsMasked($type$[] r, $type$ rc, $type$[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
+#if[FP]
+ assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, ($type$)0.0);
+#else[FP]
int i = 0;
try {
Assert.assertEquals(rc, fa.apply(a, mask));
@@ -179,7 +207,26 @@ public class $vectorteststype$ extends AbstractVectorTest {
Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
}
+#end[FP]
+ }
+#if[FP]
+
+ static void assertReductionArraysEqualsMasked($type$[] r, $type$ rc, $type$[] a, boolean[] mask,
+ FReductionMaskedOp f, FReductionAllMaskedOp fa,
+ $type$ relativeError) {
+ int i = 0;
+ try {
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
+ for (; i < a.length; i += SPECIES.length()) {
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
+relativeError));
+ }
+ } catch (AssertionError e) {
+ Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
+ Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
+ }
}
+#end[FP]
#if[!Long]
interface FReductionOpLong {
@@ -1051,6 +1098,16 @@ public class $vectorteststype$ extends AbstractVectorTest {
return fill(s * BUFFER_REPS,
i -> ((($type$)(i + 1) == 0) ? 1 : ($type$)(i + 1)));
}),
+#if[FP]
+ withToString("$type$[0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> ($type$)0.01 + (($type$)i / (i + 1)));
+ }),
+ withToString("$type$[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
+ return fill(s * BUFFER_REPS,
+ i -> i % 17 == 0 ? cornerCaseValue(i) : ($type$)0.01 + (($type$)i / (i + 1)));
+ }),
+#end[FP]
withToString("$type$[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
--
GitLab