diff --git a/test/jdk/jdk/incubator/vector/Double128VectorTests.java b/test/jdk/jdk/incubator/vector/Double128VectorTests.java
index b00b0cbaaabece02875205324f57380ba4363335..bf9c717cc59ef871b5436a6056c2ebc75babda7c 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 008b4dcc34847ee932ef707b3e2f1778d6fc778e..bb4694966d814207a7356d26e34a47b97ce9f2ca 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 ce25f8ea70384a9dd55e248d545979ccf6f7f47d..72bb1a49c36df5fd2b8d74fd4b1f0767e70f9505 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 c4270d0f268d77686ab1d4226566be2aa0afd030..b445995543f284c895503c15784124afd71c65da 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 df037495d8980293b4e7fb1690924f139e7c3046..9db85a2f20e82031e6a72f67d7db2d2b89b4a875 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 ae38b606da9ad4b9fa4e31494d2d42e8117c3e63..c8a9aa4a80c176cc288ee4790ac59aef3dc41466 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 be55fa2b4582f3f6affa9cf77aea85874cf469a5..fcbf7df409bcf678a9f71c06f6c8d04dbfec58f5 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 f1f1b884d6b85453ecb8ba7d5aad3fd1e2fe7f53..597a590098a94f963600735419bfbaa699d7c724 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 47f0cf3f15b0687817e2c2ee1a3a3ce07327e95a..b5877b9de46473b9154c63944d08127ab58b9842 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 511afbb680e16455e69cd2598e33cd21ccb5cea3..9a40694f86996ad7e79ed89028b0fe74abac3596 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 70ffa79bf6fbd050211d7ced2dc90b8eb79dd90c..1ded00af608536956fa256c1e2f2b9016665f3e4 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 b86248f3f09f65cddf068ea5a54b9706db4bddf9..15a3ba8c66cb2d0f111a4cd22976c5289fa892c7 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 3e78d5897d5d5043822180bea5083fe8c785693d..089f9fef8d25718d043b352ab3126f2081538075 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));