ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

[NFC] math_brute_force: use getAllowedUlpError for double (#2351)

Browse Source 
Call `getAllowedUlpError` to obtain the allowed ULP error for all of the
double type (fp64) tests. The aim is to standardise obtaining the
desired ULP requirement and pave the way for adding the Embedded Profile
ULP errors.

Contributes to https://github.com/KhronosGroup/OpenCL-CTS/issues/867

Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
This commit is contained in:
Sven van Haastregt
2025-05-06 18:32:31 +02:00
committed by GitHub
parent 8aa47754de
commit 9917ed2790
9 changed files with 119 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test_conformance/math_brute_force/binary_double.cpp
View File

@@ -605,7 +605,7 @@ int TestFunc_Double_Double_Double(const Func *f, MTdata d, bool relaxedMode)
} }
test_info.f = f; test_info.f = f;
test_info.ulps = f->double_ulps; test_info.ulps = getAllowedUlpError(f, kdouble, relaxedMode);
test_info.ftz = f->ftz || gForceFTZ; test_info.ftz = f->ftz || gForceFTZ;
test_info.relaxedMode = relaxedMode; test_info.relaxedMode = relaxedMode;

2
test_conformance/math_brute_force/binary_i_double.cpp
View File

@@ -522,7 +522,7 @@ int TestFunc_Double_Double_Int(const Func *f, MTdata d, bool relaxedMode)
} }
test_info.f = f; test_info.f = f;
test_info.ulps = f->double_ulps; test_info.ulps = getAllowedUlpError(f, kdouble, relaxedMode);
test_info.ftz = f->ftz || gForceFTZ; test_info.ftz = f->ftz || gForceFTZ;
test_info.relaxedMode = relaxedMode; test_info.relaxedMode = relaxedMode;

2
test_conformance/math_brute_force/binary_operator_double.cpp
View File

@@ -571,7 +571,7 @@ int TestFunc_Double_Double_Double_Operator(const Func *f, MTdata d,
} }
test_info.f = f; test_info.f = f;
test_info.ulps = f->double_ulps; test_info.ulps = getAllowedUlpError(f, kdouble, relaxedMode);
test_info.ftz = f->ftz || gForceFTZ; test_info.ftz = f->ftz || gForceFTZ;
test_info.tinfo.resize(test_info.threadCount); test_info.tinfo.resize(test_info.threadCount);

41
test_conformance/math_brute_force/binary_two_results_i_double.cpp
View File

@@ -91,6 +91,7 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
cl_uint threadCount = GetThreadCount(); cl_uint threadCount = GetThreadCount();
Force64BitFPUPrecision(); Force64BitFPUPrecision();
float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode);
int testingRemquo = !strcmp(f->name, "remquo"); int testingRemquo = !strcmp(f->name, "remquo");
@@ -256,6 +257,7 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
// Verify data // Verify data
uint64_t *t = (uint64_t *)gOut_Ref; uint64_t *t = (uint64_t *)gOut_Ref;
int32_t *t2 = (int32_t *)gOut_Ref2; int32_t *t2 = (int32_t *)gOut_Ref2;
for (size_t j = 0; j < BUFFER_SIZE / sizeof(double); j++) for (size_t j = 0; j < BUFFER_SIZE / sizeof(double); j++)
{ {
for (auto k = gMinVectorSizeIndex; k < gMaxVectorSizeIndex; k++) for (auto k = gMinVectorSizeIndex; k < gMaxVectorSizeIndex; k++)
@@ -294,11 +296,11 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
|| isnan(((double *)gIn)[j]); || isnan(((double *)gIn)[j]);
if (iptrUndefined) iErr = 0; if (iptrUndefined) iErr = 0;
int fail = !(fabsf(err) <= f->double_ulps && iErr == 0); int fail = !(fabsf(err) <= double_ulps && iErr == 0);
if ((ftz || relaxedMode) && fail) if ((ftz || relaxedMode) && fail)
{ {
// retry per section 6.5.3.2 // retry per section 6.5.3.2
if (IsDoubleResultSubnormal(correct, f->double_ulps)) if (IsDoubleResultSubnormal(correct, double_ulps))
{ {
fail = fail && !(test == 0.0f && iErr == 0); fail = fail && !(test == 0.0f && iErr == 0);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
@@ -319,8 +321,8 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
int64_t iErr3 = (long long)q2[j] - (long long)correct3i; int64_t iErr3 = (long long)q2[j] - (long long)correct3i;
int64_t iErr4 = (long long)q2[j] - (long long)correct4i; int64_t iErr4 = (long long)q2[j] - (long long)correct4i;
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps && iErr3 == 0)) && ((!(fabsf(err2) <= double_ulps && iErr3 == 0))
&& (!(fabsf(err3) <= f->double_ulps && (!(fabsf(err3) <= double_ulps
&& iErr4 == 0))); && iErr4 == 0)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
@@ -328,9 +330,8 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
if (llabs(iErr4) < llabs(iErr)) iErr = iErr4; if (llabs(iErr4) < llabs(iErr)) iErr = iErr4;
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, f->double_ulps) if (IsDoubleResultSubnormal(correct2, double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3, double_ulps))
f->double_ulps))
{ {
fail = fail fail = fail
&& !(test == 0.0f && !(test == 0.0f
@@ -361,13 +362,13 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
int64_t iErr8 = int64_t iErr8 =
(long long)q2[j] - (long long)correct8i; (long long)q2[j] - (long long)correct8i;
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps && ((!(fabsf(err2) <= double_ulps
&& iErr3 == 0)) && iErr3 == 0))
&& (!(fabsf(err3) <= f->double_ulps && (!(fabsf(err3) <= double_ulps
&& iErr4 == 0)) && iErr4 == 0))
&& (!(fabsf(err4) <= f->double_ulps && (!(fabsf(err4) <= double_ulps
&& iErr7 == 0)) && iErr7 == 0))
&& (!(fabsf(err5) <= f->double_ulps && (!(fabsf(err5) <= double_ulps
&& iErr8 == 0))); && iErr8 == 0)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
@@ -379,14 +380,13 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
if (llabs(iErr8) < llabs(iErr)) iErr = iErr8; if (llabs(iErr8) < llabs(iErr)) iErr = iErr8;
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct3, if (IsDoubleResultSubnormal(correct3, double_ulps)
f->double_ulps)
|| IsDoubleResultSubnormal(correct4, || IsDoubleResultSubnormal(correct4,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct7, || IsDoubleResultSubnormal(correct7,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct8, || IsDoubleResultSubnormal(correct8,
f->double_ulps)) double_ulps))
{ {
fail = fail fail = fail
&& !(test == 0.0f && !(test == 0.0f
@@ -410,8 +410,8 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
int64_t iErr3 = (long long)q2[j] - (long long)correct3i; int64_t iErr3 = (long long)q2[j] - (long long)correct3i;
int64_t iErr4 = (long long)q2[j] - (long long)correct4i; int64_t iErr4 = (long long)q2[j] - (long long)correct4i;
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps && iErr3 == 0)) && ((!(fabsf(err2) <= double_ulps && iErr3 == 0))
&& (!(fabsf(err3) <= f->double_ulps && (!(fabsf(err3) <= double_ulps
&& iErr4 == 0))); && iErr4 == 0)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
@@ -419,9 +419,8 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode)
if (llabs(iErr4) < llabs(iErr)) iErr = iErr4; if (llabs(iErr4) < llabs(iErr)) iErr = iErr4;
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, f->double_ulps) if (IsDoubleResultSubnormal(correct2, double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3, double_ulps))
f->double_ulps))
{ {
fail = fail fail = fail
&& !(test == 0.0f && !(test == 0.0f

132
test_conformance/math_brute_force/ternary_double.cpp
View File

@@ -127,6 +127,8 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
double maxErrorVal3 = 0.0f; double maxErrorVal3 = 0.0f;
uint64_t step = getTestStep(sizeof(double), BUFFER_SIZE); uint64_t step = getTestStep(sizeof(double), BUFFER_SIZE);
float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode);
logFunctionInfo(f->name, sizeof(cl_double), relaxedMode); logFunctionInfo(f->name, sizeof(cl_double), relaxedMode);
Force64BitFPUPrecision(); Force64BitFPUPrecision();
@@ -295,7 +297,7 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
double test = ((double *)q)[j]; double test = ((double *)q)[j];
long double correct = f->dfunc.f_fff(s[j], s2[j], s3[j]); long double correct = f->dfunc.f_fff(s[j], s2[j], s3[j]);
float err = Bruteforce_Ulp_Error_Double(test, correct); float err = Bruteforce_Ulp_Error_Double(test, correct);
int fail = !(fabsf(err) <= f->double_ulps); int fail = !(fabsf(err) <= double_ulps);
if (fail && (ftz || relaxedMode)) if (fail && (ftz || relaxedMode))
{ {
@@ -318,16 +320,15 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
float err3 = float err3 =
Bruteforce_Ulp_Error_Double(test, correct3); Bruteforce_Ulp_Error_Double(test, correct3);
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps)) && ((!(fabsf(err2) <= double_ulps))
&& (!(fabsf(err3) <= f->double_ulps))); && (!(fabsf(err3) <= double_ulps)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, if (IsDoubleResultSubnormal(correct2, double_ulps)
f->double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3,
f->double_ulps)) double_ulps))
{ // look at me now, { // look at me now,
fail = fail && (test != 0.0f); fail = fail && (test != 0.0f);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
@@ -351,10 +352,10 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
float err5 = float err5 =
Bruteforce_Ulp_Error_Double(test, correct5); Bruteforce_Ulp_Error_Double(test, correct5);
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps)) && ((!(fabsf(err2) <= double_ulps))
&& (!(fabsf(err3) <= f->double_ulps)) && (!(fabsf(err3) <= double_ulps))
&& (!(fabsf(err4) <= f->double_ulps)) && (!(fabsf(err4) <= double_ulps))
&& (!(fabsf(err5) <= f->double_ulps))); && (!(fabsf(err5) <= double_ulps)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
if (fabsf(err4) < fabsf(err)) err = err4; if (fabsf(err4) < fabsf(err)) err = err4;
@@ -362,13 +363,13 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, if (IsDoubleResultSubnormal(correct2,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct4, || IsDoubleResultSubnormal(correct4,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct5, || IsDoubleResultSubnormal(correct5,
f->double_ulps)) double_ulps))
{ {
fail = fail && (test != 0.0f); fail = fail && (test != 0.0f);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
@@ -405,21 +406,14 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
float err9 = Bruteforce_Ulp_Error_Double( float err9 = Bruteforce_Ulp_Error_Double(
test, correct9); test, correct9);
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps)) && ((!(fabsf(err2) <= double_ulps))
&& (!(fabsf(err3) && (!(fabsf(err3) <= double_ulps))
<= f->double_ulps)) && (!(fabsf(err4) <= double_ulps))
&& (!(fabsf(err4) && (!(fabsf(err5) <= double_ulps))
<= f->double_ulps)) && (!(fabsf(err5) <= double_ulps))
&& (!(fabsf(err5) && (!(fabsf(err6) <= double_ulps))
<= f->double_ulps)) && (!(fabsf(err7) <= double_ulps))
&& (!(fabsf(err5) && (!(fabsf(err8) <= double_ulps)));
<= f->double_ulps))
&& (!(fabsf(err6)
<= f->double_ulps))
&& (!(fabsf(err7)
<= f->double_ulps))
&& (!(fabsf(err8)
<= f->double_ulps)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
if (fabsf(err4) < fabsf(err)) err = err4; if (fabsf(err4) < fabsf(err)) err = err4;
@@ -431,21 +425,21 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, if (IsDoubleResultSubnormal(correct2,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal( || IsDoubleResultSubnormal(correct3,
correct3, f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal( || IsDoubleResultSubnormal(correct4,
correct4, f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal( || IsDoubleResultSubnormal(correct5,
correct5, f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal( || IsDoubleResultSubnormal(correct6,
correct6, f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal( || IsDoubleResultSubnormal(correct7,
correct7, f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal( || IsDoubleResultSubnormal(correct8,
correct8, f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal( || IsDoubleResultSubnormal(correct9,
correct9, f->double_ulps)) double_ulps))
{ {
fail = fail && (test != 0.0f); fail = fail && (test != 0.0f);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
@@ -469,10 +463,10 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
float err5 = float err5 =
Bruteforce_Ulp_Error_Double(test, correct5); Bruteforce_Ulp_Error_Double(test, correct5);
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps)) && ((!(fabsf(err2) <= double_ulps))
&& (!(fabsf(err3) <= f->double_ulps)) && (!(fabsf(err3) <= double_ulps))
&& (!(fabsf(err4) <= f->double_ulps)) && (!(fabsf(err4) <= double_ulps))
&& (!(fabsf(err5) <= f->double_ulps))); && (!(fabsf(err5) <= double_ulps)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
if (fabsf(err4) < fabsf(err)) err = err4; if (fabsf(err4) < fabsf(err)) err = err4;
@@ -480,13 +474,13 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, if (IsDoubleResultSubnormal(correct2,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct4, || IsDoubleResultSubnormal(correct4,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct5, || IsDoubleResultSubnormal(correct5,
f->double_ulps)) double_ulps))
{ {
fail = fail && (test != 0.0f); fail = fail && (test != 0.0f);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
@@ -504,16 +498,15 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
float err3 = float err3 =
Bruteforce_Ulp_Error_Double(test, correct3); Bruteforce_Ulp_Error_Double(test, correct3);
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps)) && ((!(fabsf(err2) <= double_ulps))
&& (!(fabsf(err3) <= f->double_ulps))); && (!(fabsf(err3) <= double_ulps)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, if (IsDoubleResultSubnormal(correct2, double_ulps)
f->double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3,
f->double_ulps)) double_ulps))
{ {
fail = fail && (test != 0.0f); fail = fail && (test != 0.0f);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
@@ -537,10 +530,10 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
float err5 = float err5 =
Bruteforce_Ulp_Error_Double(test, correct5); Bruteforce_Ulp_Error_Double(test, correct5);
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps)) && ((!(fabsf(err2) <= double_ulps))
&& (!(fabsf(err3) <= f->double_ulps)) && (!(fabsf(err3) <= double_ulps))
&& (!(fabsf(err4) <= f->double_ulps)) && (!(fabsf(err4) <= double_ulps))
&& (!(fabsf(err5) <= f->double_ulps))); && (!(fabsf(err5) <= double_ulps)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
if (fabsf(err4) < fabsf(err)) err = err4; if (fabsf(err4) < fabsf(err)) err = err4;
@@ -548,13 +541,13 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, if (IsDoubleResultSubnormal(correct2,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct4, || IsDoubleResultSubnormal(correct4,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct5, || IsDoubleResultSubnormal(correct5,
f->double_ulps)) double_ulps))
{ {
fail = fail && (test != 0.0f); fail = fail && (test != 0.0f);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
@@ -572,16 +565,15 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d,
float err3 = float err3 =
Bruteforce_Ulp_Error_Double(test, correct3); Bruteforce_Ulp_Error_Double(test, correct3);
fail = fail fail = fail
&& ((!(fabsf(err2) <= f->double_ulps)) && ((!(fabsf(err2) <= double_ulps))
&& (!(fabsf(err3) <= f->double_ulps))); && (!(fabsf(err3) <= double_ulps)));
if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err2) < fabsf(err)) err = err2;
if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err3) < fabsf(err)) err = err3;
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correct2, if (IsDoubleResultSubnormal(correct2, double_ulps)
f->double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3,
f->double_ulps)) double_ulps))
{ {
fail = fail && (test != 0.0f); fail = fail && (test != 0.0f);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;

2
test_conformance/math_brute_force/unary_double.cpp
View File

@@ -354,7 +354,7 @@ int TestFunc_Double_Double(const Func *f, MTdata d, bool relaxedMode)
} }
test_info.f = f; test_info.f = f;
test_info.ulps = f->double_ulps; test_info.ulps = getAllowedUlpError(f, kdouble, relaxedMode);
test_info.ftz = f->ftz || gForceFTZ; test_info.ftz = f->ftz || gForceFTZ;
test_info.relaxedMode = relaxedMode; test_info.relaxedMode = relaxedMode;

43
test_conformance/math_brute_force/unary_two_results_double.cpp
View File

@@ -56,6 +56,7 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode)
logFunctionInfo(f->name, sizeof(cl_double), relaxedMode); logFunctionInfo(f->name, sizeof(cl_double), relaxedMode);
Force64BitFPUPrecision(); Force64BitFPUPrecision();
float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode);
// Init the kernels // Init the kernels
BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode, BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode,
@@ -214,15 +215,14 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode)
long double correct = f->dfunc.f_fpf(s[j], &correct2); long double correct = f->dfunc.f_fpf(s[j], &correct2);
float err = Bruteforce_Ulp_Error_Double(test, correct); float err = Bruteforce_Ulp_Error_Double(test, correct);
float err2 = Bruteforce_Ulp_Error_Double(test2, correct2); float err2 = Bruteforce_Ulp_Error_Double(test2, correct2);
int fail = !(fabsf(err) <= f->double_ulps int fail = !(fabsf(err) <= double_ulps
&& fabsf(err2) <= f->double_ulps); && fabsf(err2) <= double_ulps);
if (ftz || relaxedMode) if (ftz || relaxedMode)
{ {
// retry per section 6.5.3.2 // retry per section 6.5.3.2
if (IsDoubleResultSubnormal(correct, f->double_ulps)) if (IsDoubleResultSubnormal(correct, double_ulps))
{ {
if (IsDoubleResultSubnormal(correct2, if (IsDoubleResultSubnormal(correct2, double_ulps))
f->double_ulps))
{ {
fail = fail && !(test == 0.0f && test2 == 0.0f); fail = fail && !(test == 0.0f && test2 == 0.0f);
if (!fail) if (!fail)
@@ -235,16 +235,15 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode)
{ {
fail = fail fail = fail
&& !(test == 0.0f && !(test == 0.0f
&& fabsf(err2) <= f->double_ulps); && fabsf(err2) <= double_ulps);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
} }
} }
else if (IsDoubleResultSubnormal(correct2, else if (IsDoubleResultSubnormal(correct2, double_ulps))
f->double_ulps))
{ {
fail = fail fail = fail
&& !(test2 == 0.0f && !(test2 == 0.0f
&& fabsf(err) <= f->double_ulps); && fabsf(err) <= double_ulps);
if (!fail) err2 = 0.0f; if (!fail) err2 = 0.0f;
} }
@@ -265,26 +264,24 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode)
float err2n = float err2n =
Bruteforce_Ulp_Error_Double(test, correct2n); Bruteforce_Ulp_Error_Double(test, correct2n);
fail = fail fail = fail
&& ((!(fabsf(errp) <= f->double_ulps)) && ((!(fabsf(errp) <= double_ulps))
&& (!(fabsf(err2p) <= f->double_ulps)) && (!(fabsf(err2p) <= double_ulps))
&& ((!(fabsf(errn) <= f->double_ulps)) && ((!(fabsf(errn) <= double_ulps))
&& (!(fabsf(err2n) && (!(fabsf(err2n) <= double_ulps))));
<= f->double_ulps))));
if (fabsf(errp) < fabsf(err)) err = errp; if (fabsf(errp) < fabsf(err)) err = errp;
if (fabsf(errn) < fabsf(err)) err = errn; if (fabsf(errn) < fabsf(err)) err = errn;
if (fabsf(err2p) < fabsf(err2)) err2 = err2p; if (fabsf(err2p) < fabsf(err2)) err2 = err2p;
if (fabsf(err2n) < fabsf(err2)) err2 = err2n; if (fabsf(err2n) < fabsf(err2)) err2 = err2n;
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (IsDoubleResultSubnormal(correctp, if (IsDoubleResultSubnormal(correctp, double_ulps)
f->double_ulps)
|| IsDoubleResultSubnormal(correctn, || IsDoubleResultSubnormal(correctn,
f->double_ulps)) double_ulps))
{ {
if (IsDoubleResultSubnormal(correct2p, if (IsDoubleResultSubnormal(correct2p,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct2n, || IsDoubleResultSubnormal(correct2n,
f->double_ulps)) double_ulps))
{ {
fail = fail fail = fail
&& !(test == 0.0f && test2 == 0.0f); && !(test == 0.0f && test2 == 0.0f);
@@ -294,18 +291,18 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode)
{ {
fail = fail fail = fail
&& !(test == 0.0f && !(test == 0.0f
&& fabsf(err2) <= f->double_ulps); && fabsf(err2) <= double_ulps);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
} }
} }
else if (IsDoubleResultSubnormal(correct2p, else if (IsDoubleResultSubnormal(correct2p,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct2n, || IsDoubleResultSubnormal(correct2n,
f->double_ulps)) double_ulps))
{ {
fail = fail fail = fail
&& !(test2 == 0.0f && !(test2 == 0.0f
&& (fabsf(err) <= f->double_ulps)); && (fabsf(err) <= double_ulps));
if (!fail) err2 = 0.0f; if (!fail) err2 = 0.0f;
} }
} }

17
test_conformance/math_brute_force/unary_two_results_i_double.cpp
View File

@@ -56,7 +56,9 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode)
int ftz = f->ftz || gForceFTZ; int ftz = f->ftz || gForceFTZ;
double maxErrorVal = 0.0f; double maxErrorVal = 0.0f;
double maxErrorVal2 = 0.0f; double maxErrorVal2 = 0.0f;
cl_ulong maxiError = f->double_ulps == INFINITY ? CL_ULONG_MAX : 0; cl_ulong maxiError = getAllowedUlpError(f, kdouble, relaxedMode) == INFINITY
? CL_ULONG_MAX
: 0;
uint64_t step = getTestStep(sizeof(cl_double), BUFFER_SIZE); uint64_t step = getTestStep(sizeof(cl_double), BUFFER_SIZE);
int scale = int scale =
(int)((1ULL << 32) / (16 * BUFFER_SIZE / sizeof(cl_double)) + 1); (int)((1ULL << 32) / (16 * BUFFER_SIZE / sizeof(cl_double)) + 1);
@@ -64,6 +66,7 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode)
logFunctionInfo(f->name, sizeof(cl_double), relaxedMode); logFunctionInfo(f->name, sizeof(cl_double), relaxedMode);
Force64BitFPUPrecision(); Force64BitFPUPrecision();
float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode);
// Init the kernels // Init the kernels
BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode, BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode,
@@ -217,12 +220,12 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode)
long double correct = f->dfunc.f_fpI(s[j], &correct2); long double correct = f->dfunc.f_fpI(s[j], &correct2);
float err = Bruteforce_Ulp_Error_Double(test, correct); float err = Bruteforce_Ulp_Error_Double(test, correct);
cl_long iErr = (long long)q2[j] - (long long)correct2; cl_long iErr = (long long)q2[j] - (long long)correct2;
int fail = !(fabsf(err) <= f->double_ulps int fail = !(fabsf(err) <= double_ulps
&& abs_cl_long(iErr) <= maxiError); && abs_cl_long(iErr) <= maxiError);
if (ftz || relaxedMode) if (ftz || relaxedMode)
{ {
// retry per section 6.5.3.2 // retry per section 6.5.3.2
if (IsDoubleResultSubnormal(correct, f->double_ulps)) if (IsDoubleResultSubnormal(correct, double_ulps))
{ {
fail = fail && !(test == 0.0f && iErr == 0); fail = fail && !(test == 0.0f && iErr == 0);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;
@@ -246,7 +249,7 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode)
(long long)q2[j] - (long long)correct6; (long long)q2[j] - (long long)correct6;
// Did +0 work? // Did +0 work?
if (fabsf(err2) <= f->double_ulps if (fabsf(err2) <= double_ulps
&& abs_cl_long(iErr2) <= maxiError) && abs_cl_long(iErr2) <= maxiError)
{ {
err = err2; err = err2;
@@ -254,7 +257,7 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode)
fail = 0; fail = 0;
} }
// Did -0 work? // Did -0 work?
else if (fabsf(err3) <= f->double_ulps else if (fabsf(err3) <= double_ulps
&& abs_cl_long(iErr3) <= maxiError) && abs_cl_long(iErr3) <= maxiError)
{ {
err = err3; err = err3;
@@ -265,9 +268,9 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode)
// retry per section 6.5.3.4 // retry per section 6.5.3.4
if (fail if (fail
&& (IsDoubleResultSubnormal(correct2, && (IsDoubleResultSubnormal(correct2,
f->double_ulps) double_ulps)
|| IsDoubleResultSubnormal(correct3, || IsDoubleResultSubnormal(correct3,
f->double_ulps))) double_ulps)))
{ {
fail = fail fail = fail
&& !(test == 0.0f && !(test == 0.0f

6
test_conformance/math_brute_force/unary_u_double.cpp
View File

@@ -56,6 +56,7 @@ int TestFunc_Double_ULong(const Func *f, MTdata d, bool relaxedMode)
logFunctionInfo(f->name, sizeof(cl_double), relaxedMode); logFunctionInfo(f->name, sizeof(cl_double), relaxedMode);
Force64BitFPUPrecision(); Force64BitFPUPrecision();
float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode);
// Init the kernels // Init the kernels
BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode, BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode,
@@ -167,15 +168,14 @@ int TestFunc_Double_ULong(const Func *f, MTdata d, bool relaxedMode)
double test = ((double *)q)[j]; double test = ((double *)q)[j];
long double correct = f->dfunc.f_u(s[j]); long double correct = f->dfunc.f_u(s[j]);
float err = Bruteforce_Ulp_Error_Double(test, correct); float err = Bruteforce_Ulp_Error_Double(test, correct);
int fail = !(fabsf(err) <= f->double_ulps); int fail = !(fabsf(err) <= double_ulps);
if (fail) if (fail)
{ {
if (ftz || relaxedMode) if (ftz || relaxedMode)
{ {
// retry per section 6.5.3.2 // retry per section 6.5.3.2
if (IsDoubleResultSubnormal(correct, if (IsDoubleResultSubnormal(correct, double_ulps))
f->double_ulps))
{ {
fail = fail && (test != 0.0); fail = fail && (test != 0.0);
if (!fail) err = 0.0f; if (!fail) err = 0.0f;