ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-26 08:49:02 +00:00
Code Packages Projects Releases Wiki Activity

Bruteforce - embedded, relaxed ulp requirements (#839)

Browse Source 
* Add embedded profile ULP requiremnts for relaxed tests.

* Fixed exp relaxed ULP for embedded.

* Added a utility function, getAllowedUlpError, for determining FP32 ULP.

* Collection of requested changes from PR.

Re-named float_embedded_relaxed_ulps -> relaxed_embedded_error.

Re-ordered Func struct members.
This commit is contained in:
Jeremy Kemp
2020-08-10 13:19:26 +01:00
committed by GitHub
parent ce484988ab
commit 93001e99a4
8 changed files with 286 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
test_conformance/math_brute_force/FunctionList.cpp
View File

@@ -27,10 +27,30 @@
// Only use ulps information in spir test // Only use ulps information in spir test
#ifdef FUNCTION_LIST_ULPS_ONLY #ifdef FUNCTION_LIST_ULPS_ONLY
#define ENTRY( _name, _ulp, _embedded_ulp, _rmode, _type ) { STRINGIFY(_name), STRINGIFY(_name), {NULL}, {NULL}, {NULL}, _ulp, _ulp, _embedded_ulp, INFINITY, _rmode, RELAXED_OFF, _type } #define ENTRY(_name, _ulp, _embedded_ulp, _rmode, _type) \
#define ENTRY_EXT( _name, _ulp, _embedded_ulp, _relaxed_ulp, _rmode, _type ) { STRINGIFY(_name), STRINGIFY(_name), {NULL}, {NULL}, {NULL}, _ulp, _ulp, _embedded_ulp, _relaxed_ulp, _rmode, RELAXED_ON, _type } { \
#define HALF_ENTRY( _name, _ulp, _embedded_ulp, _rmode, _type ) { "half_" STRINGIFY(_name), "half_" STRINGIFY(_name), {NULL}, {NULL}, {NULL}, _ulp, _ulp, _embedded_ulp, INFINITY, _rmode, RELAXED_OFF, _type } STRINGIFY(_name), STRINGIFY(_name), { NULL }, { NULL }, { NULL }, \
#define OPERATOR_ENTRY(_name, _operator, _ulp, _embedded_ulp, _rmode, _type) { STRINGIFY(_name), _operator, {NULL}, {NULL}, {NULL}, _ulp, _ulp, _embedded_ulp, INFINITY, _rmode, RELAXED_OFF, _type } _ulp, _ulp, _embedded_ulp, INFINITY, INFINITY, _rmode, \
RELAXED_OFF, _type \
}
#define ENTRY_EXT(_name, _ulp, _embedded_ulp, _relaxed_ulp, _rmode, _type, \
_relaxed_embedded_ulp) \
{ \
STRINGIFY(_name), STRINGIFY(_name), { NULL }, { NULL }, { NULL }, \
_ulp, _ulp, _embedded_ulp, _relaxed_ulp, _relaxed_embedded_ulp, \
_rmode, RELAXED_ON, _type \
}
#define HALF_ENTRY(_name, _ulp, _embedded_ulp, _rmode, _type) \
{ \
"half_" STRINGIFY(_name), "half_" STRINGIFY(_name), { NULL }, \
{ NULL }, { NULL }, _ulp, _ulp, _embedded_ulp, INFINITY, INFINITY, \
_rmode, RELAXED_OFF, _type \
}
#define OPERATOR_ENTRY(_name, _operator, _ulp, _embedded_ulp, _rmode, _type) \
{ \
STRINGIFY(_name), _operator, { NULL }, { NULL }, { NULL }, _ulp, _ulp, \
_embedded_ulp, INFINITY, INFINITY, _rmode, RELAXED_OFF, _type \
}
#define unaryF NULL #define unaryF NULL
#define i_unaryF NULL #define i_unaryF NULL
#define unaryF_u NULL #define unaryF_u NULL
@@ -54,10 +74,33 @@
#else // FUNCTION_LIST_ULPS_ONLY #else // FUNCTION_LIST_ULPS_ONLY
#define ENTRY( _name, _ulp, _embedded_ulp, _rmode, _type ) { STRINGIFY(_name), STRINGIFY(_name), {(void*)reference_##_name}, {(void*)reference_##_name##l}, {(void*)reference_##_name}, _ulp, _ulp, _embedded_ulp, INFINITY, _rmode, RELAXED_OFF, _type } #define ENTRY(_name, _ulp, _embedded_ulp, _rmode, _type) \
#define ENTRY_EXT( _name, _ulp, _embedded_ulp, _relaxed_ulp, _rmode, _type ) { STRINGIFY(_name), STRINGIFY(_name), {(void*)reference_##_name}, {(void*)reference_##_name##l}, {(void*)reference_##relaxed_##_name}, _ulp, _ulp, _embedded_ulp, _relaxed_ulp, _rmode, RELAXED_ON, _type } { \
#define HALF_ENTRY( _name, _ulp, _embedded_ulp, _rmode, _type ) { "half_" STRINGIFY(_name), "half_" STRINGIFY(_name), {(void*)reference_##_name}, {NULL}, {NULL}, _ulp, _ulp, _embedded_ulp, INFINITY, _rmode, RELAXED_OFF, _type } STRINGIFY(_name), STRINGIFY(_name), { (void*)reference_##_name }, \
#define OPERATOR_ENTRY(_name, _operator, _ulp, _embedded_ulp, _rmode, _type) { STRINGIFY(_name), _operator, {(void*)reference_##_name}, {(void*)reference_##_name##l}, {NULL}, _ulp, _ulp, _embedded_ulp, INFINITY, _rmode, RELAXED_OFF, _type } { (void*)reference_##_name##l }, { (void*)reference_##_name }, \
_ulp, _ulp, _embedded_ulp, INFINITY, INFINITY, _rmode, \
RELAXED_OFF, _type \
}
#define ENTRY_EXT(_name, _ulp, _embedded_ulp, _relaxed_ulp, _rmode, _type, \
_relaxed_embedded_ulp) \
{ \
STRINGIFY(_name), STRINGIFY(_name), { (void*)reference_##_name }, \
{ (void*)reference_##_name##l }, \
{ (void*)reference_##relaxed_##_name }, _ulp, _ulp, _embedded_ulp, \
_relaxed_ulp, _relaxed_embedded_ulp, _rmode, RELAXED_ON, _type \
}
#define HALF_ENTRY(_name, _ulp, _embedded_ulp, _rmode, _type) \
{ \
"half_" STRINGIFY(_name), "half_" STRINGIFY(_name), \
{ (void*)reference_##_name }, { NULL }, { NULL }, _ulp, _ulp, \
_embedded_ulp, INFINITY, INFINITY, _rmode, RELAXED_OFF, _type \
}
#define OPERATOR_ENTRY(_name, _operator, _ulp, _embedded_ulp, _rmode, _type) \
{ \
STRINGIFY(_name), _operator, { (void*)reference_##_name }, \
{ (void*)reference_##_name##l }, { NULL }, _ulp, _ulp, \
_embedded_ulp, INFINITY, INFINITY, _rmode, RELAXED_OFF, _type \
}
extern const vtbl _unary; // float foo( float ) extern const vtbl _unary; // float foo( float )
extern const vtbl _unary_u; // float foo( uint ), double foo( ulong ) extern const vtbl _unary_u; // float foo( uint ), double foo( ulong )
@@ -106,14 +149,26 @@ const Func functionList[] = {
ENTRY(cbrt, 2.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(cbrt, 2.0f, 4.0f, FTZ_OFF, unaryF),
ENTRY(ceil, 0.0f, 0.0f, FTZ_OFF, unaryF), ENTRY(ceil, 0.0f, 0.0f, FTZ_OFF, unaryF),
ENTRY(copysign, 0.0f, 0.0f, FTZ_OFF, binaryF), ENTRY(copysign, 0.0f, 0.0f, FTZ_OFF, binaryF),
ENTRY_EXT( cos, 4.0f, 4.0f, 0.00048828125f, FTZ_OFF, unaryF), //relaxed ulp 2^-11 ENTRY_EXT(cos, 4.0f, 4.0f, 0.00048828125f, FTZ_OFF, unaryF,
0.00048828125f), // relaxed ulp 2^-11
ENTRY(cosh, 4.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(cosh, 4.0f, 4.0f, FTZ_OFF, unaryF),
ENTRY(cospi, 4.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(cospi, 4.0f, 4.0f, FTZ_OFF, unaryF),
// ENTRY( erfc, 16.0f, 16.0f, FTZ_OFF, unaryF), //disabled for 1.0 due to lack of reference implementation // ENTRY( erfc, 16.0f,
// ENTRY( erf, 16.0f, 16.0f, FTZ_OFF, unaryF), //disabled for 1.0 due to lack of reference implementation // 16.0f, FTZ_OFF, unaryF),
ENTRY_EXT( exp, 3.0f, 4.0f, 3.0f, FTZ_OFF, unaryF), //relaxed error is actually overwritten in unary.c as it is 3+floor(fabs(2*x)) // //disabled for 1.0 due to lack of
ENTRY_EXT( exp2, 3.0f, 4.0f, 3.0f, FTZ_OFF, unaryF), //relaxed error is actually overwritten in unary.c as it is 3+floor(fabs(2*x)) // reference implementation ENTRY( erf,
ENTRY_EXT( exp10, 3.0f, 4.0f, 8192.0f, FTZ_OFF, unaryF), //relaxed error is actually overwritten in unary.c as it is 3+floor(fabs(2*x)) in derived mode, // 16.0f, 16.0f, FTZ_OFF,
// unaryF), //disabled for 1.0 due to lack
// of reference implementation
ENTRY_EXT(exp, 3.0f, 4.0f, 3.0f, FTZ_OFF, unaryF,
4.0f), // relaxed error is actually overwritten in unary.c as it
// is 3+floor(fabs(2*x))
ENTRY_EXT(exp2, 3.0f, 4.0f, 3.0f, FTZ_OFF, unaryF,
4.0f), // relaxed error is actually overwritten in unary.c as it
// is 3+floor(fabs(2*x))
ENTRY_EXT(exp10, 3.0f, 4.0f, 8192.0f, FTZ_OFF, unaryF,
8192.0f), // relaxed error is actually overwritten in unary.c as
// it is 3+floor(fabs(2*x)) in derived mode,
// in non-derived mode it uses the ulp error for half_exp10. // in non-derived mode it uses the ulp error for half_exp10.
ENTRY(expm1, 3.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(expm1, 3.0f, 4.0f, FTZ_OFF, unaryF),
ENTRY(fabs, 0.0f, 0.0f, FTZ_OFF, unaryF), ENTRY(fabs, 0.0f, 0.0f, FTZ_OFF, unaryF),
@@ -143,21 +198,29 @@ const Func functionList[] = {
ENTRY(ldexp, 0.0f, 0.0f, FTZ_OFF, binaryF_i), ENTRY(ldexp, 0.0f, 0.0f, FTZ_OFF, binaryF_i),
ENTRY(lgamma, INFINITY, INFINITY, FTZ_OFF, unaryF), ENTRY(lgamma, INFINITY, INFINITY, FTZ_OFF, unaryF),
ENTRY(lgamma_r, INFINITY, INFINITY, FTZ_OFF, unaryF_two_results_i), ENTRY(lgamma_r, INFINITY, INFINITY, FTZ_OFF, unaryF_two_results_i),
ENTRY_EXT( log, 3.0f, 4.0f, 4.76837158203125e-7f, FTZ_OFF, unaryF), //relaxed ulp 2^-21 ENTRY_EXT(log, 3.0f, 4.0f, 4.76837158203125e-7f, FTZ_OFF, unaryF,
ENTRY_EXT( log2, 3.0f, 4.0f, 4.76837158203125e-7f, FTZ_OFF, unaryF), //relaxed ulp 2^-21 4.76837158203125e-7f), // relaxed ulp 2^-21
ENTRY_EXT(log2, 3.0f, 4.0f, 4.76837158203125e-7f, FTZ_OFF, unaryF,
4.76837158203125e-7f), // relaxed ulp 2^-21
ENTRY(log10, 3.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(log10, 3.0f, 4.0f, FTZ_OFF, unaryF),
ENTRY(log1p, 2.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(log1p, 2.0f, 4.0f, FTZ_OFF, unaryF),
ENTRY(logb, 0.0f, 0.0f, FTZ_OFF, unaryF), ENTRY(logb, 0.0f, 0.0f, FTZ_OFF, unaryF),
ENTRY_EXT( mad, INFINITY, INFINITY, INFINITY, FTZ_OFF, mad_function), //in fast-relaxed-math mode it has to be either exactly rounded fma or exactly rounded a*b+c ENTRY_EXT(mad, INFINITY, INFINITY, INFINITY, FTZ_OFF, mad_function,
INFINITY), // in fast-relaxed-math mode it has to be either
// exactly rounded fma or exactly rounded a*b+c
ENTRY(maxmag, 0.0f, 0.0f, FTZ_OFF, binaryF), ENTRY(maxmag, 0.0f, 0.0f, FTZ_OFF, binaryF),
ENTRY(minmag, 0.0f, 0.0f, FTZ_OFF, binaryF), ENTRY(minmag, 0.0f, 0.0f, FTZ_OFF, binaryF),
ENTRY(modf, 0.0f, 0.0f, FTZ_OFF, unaryF_two_results), ENTRY(modf, 0.0f, 0.0f, FTZ_OFF, unaryF_two_results),
ENTRY(nan, 0.0f, 0.0f, FTZ_OFF, unaryF_u), ENTRY(nan, 0.0f, 0.0f, FTZ_OFF, unaryF_u),
ENTRY(nextafter, 0.0f, 0.0f, FTZ_OFF, binaryF_nextafter), ENTRY(nextafter, 0.0f, 0.0f, FTZ_OFF, binaryF_nextafter),
ENTRY_EXT( pow, 16.0f, 16.0f, 8192.0f, FTZ_OFF, binaryF), //in derived mode the ulp error is calculated as exp2(y*log2(x)) and in non-derived it is the same as half_pow ENTRY_EXT(pow, 16.0f, 16.0f, 8192.0f, FTZ_OFF, binaryF,
8192.0f), // in derived mode the ulp error is calculated as
// exp2(y*log2(x)) and in non-derived it is the same as
// half_pow
ENTRY(pown, 16.0f, 16.0f, FTZ_OFF, binaryF_i), ENTRY(pown, 16.0f, 16.0f, FTZ_OFF, binaryF_i),
ENTRY(powr, 16.0f, 16.0f, FTZ_OFF, binaryF), ENTRY(powr, 16.0f, 16.0f, FTZ_OFF, binaryF),
// ENTRY( reciprocal, 1.0f, 1.0f, FTZ_OFF, unaryF), // ENTRY( reciprocal, 1.0f,
// 1.0f, FTZ_OFF, unaryF),
ENTRY(remainder, 0.0f, 0.0f, FTZ_OFF, binaryF), ENTRY(remainder, 0.0f, 0.0f, FTZ_OFF, binaryF),
ENTRY(remquo, 0.0f, 0.0f, FTZ_OFF, binaryF_two_results_i), ENTRY(remquo, 0.0f, 0.0f, FTZ_OFF, binaryF_two_results_i),
ENTRY(rint, 0.0f, 0.0f, FTZ_OFF, unaryF), ENTRY(rint, 0.0f, 0.0f, FTZ_OFF, unaryF),
@@ -165,16 +228,48 @@ const Func functionList[] = {
ENTRY(round, 0.0f, 0.0f, FTZ_OFF, unaryF), ENTRY(round, 0.0f, 0.0f, FTZ_OFF, unaryF),
ENTRY(rsqrt, 2.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(rsqrt, 2.0f, 4.0f, FTZ_OFF, unaryF),
ENTRY(signbit, 0.0f, 0.0f, FTZ_OFF, macro_unaryF), ENTRY(signbit, 0.0f, 0.0f, FTZ_OFF, macro_unaryF),
ENTRY_EXT( sin, 4.0f, 4.0f, 0.00048828125f, FTZ_OFF, unaryF), //relaxed ulp 2^-11 ENTRY_EXT(sin, 4.0f, 4.0f, 0.00048828125f, FTZ_OFF, unaryF,
ENTRY_EXT( sincos, 4.0f, 4.0f, 0.00048828125f, FTZ_OFF, unaryF_two_results), //relaxed ulp 2^-11 0.00048828125f), // relaxed ulp 2^-11
ENTRY_EXT(sincos, 4.0f, 4.0f, 0.00048828125f, FTZ_OFF, unaryF_two_results,
0.00048828125f), // relaxed ulp 2^-11
ENTRY(sinh, 4.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(sinh, 4.0f, 4.0f, FTZ_OFF, unaryF),
ENTRY(sinpi, 4.0f, 4.0f, FTZ_OFF, unaryF), ENTRY(sinpi, 4.0f, 4.0f, FTZ_OFF, unaryF),
{ "sqrt", "sqrt", {(void*)reference_sqrt}, {(void*)reference_sqrtl}, {NULL}, 3.0f, 0.0f, 4.0f, INFINITY, FTZ_OFF, RELAXED_OFF, unaryF }, { "sqrt",
{ "sqrt_cr", "sqrt", {(void*)reference_sqrt}, {(void*)reference_sqrtl}, {NULL}, 0.0f, 0.0f, 0.0f, INFINITY, FTZ_OFF, RELAXED_OFF, unaryF }, "sqrt",
ENTRY_EXT( tan, 5.0f, 5.0f, 8192.0f, FTZ_OFF, unaryF), //in derived mode it the ulp error is calculated as sin/cos and in non-derived mode it is the same as half_tan. { (void*)reference_sqrt },
{ (void*)reference_sqrtl },
{ NULL },
3.0f,
0.0f,
4.0f,
INFINITY,
INFINITY,
FTZ_OFF,
RELAXED_OFF,
unaryF },
{ "sqrt_cr",
"sqrt",
{ (void*)reference_sqrt },
{ (void*)reference_sqrtl },
{ NULL },
0.0f,
0.0f,
0.0f,
INFINITY,
INFINITY,
FTZ_OFF,
RELAXED_OFF,
unaryF },
ENTRY_EXT(
tan, 5.0f, 5.0f, 8192.0f, FTZ_OFF, unaryF,
8192.0f), // in derived mode it the ulp error is calculated as sin/cos
// and in non-derived mode it is the same as half_tan.
ENTRY(tanh, 5.0f, 5.0f, FTZ_OFF, unaryF), ENTRY(tanh, 5.0f, 5.0f, FTZ_OFF, unaryF),
ENTRY(tanpi, 6.0f, 6.0f, FTZ_OFF, unaryF), ENTRY(tanpi, 6.0f, 6.0f, FTZ_OFF, unaryF),
// ENTRY( tgamma, 16.0f, 16.0f, FTZ_OFF, unaryF), // Commented this out until we can be sure this requirement is realistic // ENTRY( tgamma, 16.0f,
// 16.0f, FTZ_OFF, unaryF),
// // Commented this out until we can be
// sure this requirement is realistic
ENTRY(trunc, 0.0f, 0.0f, FTZ_OFF, unaryF), ENTRY(trunc, 0.0f, 0.0f, FTZ_OFF, unaryF),
HALF_ENTRY(cos, 8192.0f, 8192.0f, FTZ_ON, unaryF), HALF_ENTRY(cos, 8192.0f, 8192.0f, FTZ_ON, unaryF),
@@ -195,10 +290,35 @@ const Func functionList[] = {
// basic operations // basic operations
OPERATOR_ENTRY(add, "+", 0.0f, 0.0f, FTZ_OFF, binaryOperatorF), OPERATOR_ENTRY(add, "+", 0.0f, 0.0f, FTZ_OFF, binaryOperatorF),
OPERATOR_ENTRY(subtract, "-", 0.0f, 0.0f, FTZ_OFF, binaryOperatorF), OPERATOR_ENTRY(subtract, "-", 0.0f, 0.0f, FTZ_OFF, binaryOperatorF),
{ "divide", "/", {(void*)reference_divide}, {(void*)reference_dividel}, {(void*)reference_relaxed_divide}, 2.5f, 0.0f, 3.0f, 2.5f, FTZ_OFF, RELAXED_ON, binaryOperatorF }, { "divide",
{ "divide_cr", "/", {(void*)reference_divide}, {(void*)reference_dividel}, {(void*)reference_relaxed_divide}, 0.0f, 0.0f, 0.0f, 0.f, FTZ_OFF, RELAXED_OFF, binaryOperatorF }, "/",
{ (void*)reference_divide },
{ (void*)reference_dividel },
{ (void*)reference_relaxed_divide },
2.5f,
0.0f,
3.0f,
2.5f,
INFINITY,
FTZ_OFF,
RELAXED_ON,
binaryOperatorF },
{ "divide_cr",
"/",
{ (void*)reference_divide },
{ (void*)reference_dividel },
{ (void*)reference_relaxed_divide },
0.0f,
0.0f,
0.0f,
0.f,
INFINITY,
FTZ_OFF,
RELAXED_OFF,
binaryOperatorF },
OPERATOR_ENTRY(multiply, "*", 0.0f, 0.0f, FTZ_OFF, binaryOperatorF), OPERATOR_ENTRY(multiply, "*", 0.0f, 0.0f, FTZ_OFF, binaryOperatorF),
OPERATOR_ENTRY( assignment, "", 0.0f, 0.0f, FTZ_OFF, unaryF), // A simple copy operation OPERATOR_ENTRY(assignment, "", 0.0f, 0.0f, FTZ_OFF,
unaryF), // A simple copy operation
OPERATOR_ENTRY(not, "!", 0.0f, 0.0f, FTZ_OFF, macro_unaryF), OPERATOR_ENTRY(not, "!", 0.0f, 0.0f, FTZ_OFF, macro_unaryF),
}; };

1
test_conformance/math_brute_force/FunctionList.h
View File

@@ -85,6 +85,7 @@ typedef struct Func
float double_ulps; float double_ulps;
float float_embedded_ulps; float float_embedded_ulps;
float relaxed_error; float relaxed_error;
float relaxed_embedded_error;
int ftz; int ftz;
int relaxed; int relaxed;
const vtbl *vtbl_ptr; const vtbl *vtbl_ptr;

30
test_conformance/math_brute_force/Utility.cpp
View File

@@ -14,6 +14,7 @@
// limitations under the License. // limitations under the License.
// //
#include "Utility.h" #include "Utility.h"
#include "FunctionList.h"
#if defined(__PPC__) #if defined(__PPC__)
// Global varaiable used to hold the FPU control register state. The FPSCR register can not // Global varaiable used to hold the FPU control register state. The FPSCR register can not
@@ -167,3 +168,32 @@ void logFunctionInfo(const char *fname, unsigned int float_size, unsigned int is
vlog("%15s %4s %4s",fname, fpSizeStr, fpFastRelaxedStr); vlog("%15s %4s %4s",fname, fpSizeStr, fpFastRelaxedStr);
} }
float getAllowedUlpError(const Func *f, const bool relaxed)
{
float ulp;
if (relaxed)
{
if (gIsEmbedded)
{
ulp = f->relaxed_embedded_error;
}
else
{
ulp = f->relaxed_error;
}
}
else
{
if (gIsEmbedded)
{
ulp = f->float_embedded_ulps;
}
else
{
ulp = f->float_ulps;
}
}
return ulp;
}

5
test_conformance/math_brute_force/Utility.h
View File

@@ -29,6 +29,7 @@
#include "harness/testHarness.h" #include "harness/testHarness.h"
#include "harness/ThreadPool.h" #include "harness/ThreadPool.h"
#include "harness/conversions.h" #include "harness/conversions.h"
#define BUFFER_SIZE (1024*1024*2) #define BUFFER_SIZE (1024*1024*2)
#if defined( __GNUC__ ) #if defined( __GNUC__ )
@@ -37,6 +38,8 @@
#define UNUSED #define UNUSED
#endif #endif
struct Func;
extern int gWimpyBufferSize; extern int gWimpyBufferSize;
extern int gWimpyReductionFactor; extern int gWimpyReductionFactor;
@@ -224,6 +227,8 @@ int compareDoubles(double x, double y);
void logFunctionInfo(const char *fname, unsigned int float_size, unsigned int isFastRelaxed); void logFunctionInfo(const char *fname, unsigned int float_size, unsigned int isFastRelaxed);
float getAllowedUlpError(const Func *f, const bool relaxed);
#endif /* UTILITY_H */ #endif /* UTILITY_H */

3
test_conformance/math_brute_force/binary.cpp
View File

@@ -500,10 +500,10 @@ static cl_int TestFloat( cl_uint job_id, cl_uint thread_id, void *data )
size_t buffer_size = buffer_elements * sizeof( cl_float ); size_t buffer_size = buffer_elements * sizeof( cl_float );
cl_uint base = job_id * (cl_uint) job->step; cl_uint base = job_id * (cl_uint) job->step;
ThreadInfo *tinfo = job->tinfo + thread_id; ThreadInfo *tinfo = job->tinfo + thread_id;
float ulps = job->ulps;
fptr func = job->f->func; fptr func = job->f->func;
int ftz = job->ftz; int ftz = job->ftz;
bool relaxedMode = job->relaxedMode; bool relaxedMode = job->relaxedMode;
float ulps = getAllowedUlpError(job->f, relaxedMode);
MTdata d = tinfo->d; MTdata d = tinfo->d;
cl_uint j, k; cl_uint j, k;
cl_int error; cl_int error;
@@ -528,7 +528,6 @@ static cl_int TestFloat( cl_uint job_id, cl_uint thread_id, void *data )
}else }else
{ {
func = job->f->rfunc; func = job->f->rfunc;
ulps = job->f->relaxed_error;
} }
} }

4
test_conformance/math_brute_force/binaryOperator.cpp
View File

@@ -491,9 +491,9 @@ static cl_int TestFloat(cl_uint job_id, cl_uint thread_id, void *data)
size_t buffer_size = buffer_elements * sizeof( cl_float ); size_t buffer_size = buffer_elements * sizeof( cl_float );
cl_uint base = job_id * (cl_uint) job->step; cl_uint base = job_id * (cl_uint) job->step;
ThreadInfo *tinfo = job->tinfo + thread_id; ThreadInfo *tinfo = job->tinfo + thread_id;
float ulps = job->ulps;
fptr func = job->f->func; fptr func = job->f->func;
bool relaxedMode = job->relaxedMode; bool relaxedMode = job->relaxedMode;
float ulps = getAllowedUlpError(job->f, relaxedMode);
if (relaxedMode) if (relaxedMode)
{ {
func = job->f->rfunc; func = job->f->rfunc;
@@ -731,8 +731,6 @@ static cl_int TestFloat(cl_uint job_id, cl_uint thread_id, void *data)
float err = Ulp_Error( test, correct ); float err = Ulp_Error( test, correct );
float errB = Ulp_Error( test, (float) correct ); float errB = Ulp_Error( test, (float) correct );
if (relaxedMode) ulps = job->f->relaxed_error;
int fail = ((!(fabsf(err) <= ulps)) && (!(fabsf(errB) <= ulps))); int fail = ((!(fabsf(err) <= ulps)) && (!(fabsf(errB) <= ulps)));
if( fabsf( errB ) < fabsf(err ) ) if( fabsf( errB ) < fabsf(err ) )
err = errB; err = errB;

10
test_conformance/math_brute_force/unary.cpp
View File

@@ -463,13 +463,12 @@ static cl_int TestFloat( cl_uint job_id, cl_uint thread_id, void *data )
cl_uint scale = job->scale; cl_uint scale = job->scale;
cl_uint base = job_id * (cl_uint) job->step; cl_uint base = job_id * (cl_uint) job->step;
ThreadInfo *tinfo = job->tinfo + thread_id; ThreadInfo *tinfo = job->tinfo + thread_id;
float ulps = job->ulps;
fptr func = job->f->func; fptr func = job->f->func;
const char * fname = job->f->name; const char * fname = job->f->name;
bool relaxedMode = job->relaxedMode; bool relaxedMode = job->relaxedMode;
float ulps = getAllowedUlpError(job->f, relaxedMode);
if (relaxedMode) if (relaxedMode)
{ {
ulps = job->f->relaxed_error;
func = job->f->rfunc; func = job->f->rfunc;
} }
@@ -634,8 +633,13 @@ static cl_int TestFloat( cl_uint job_id, cl_uint thread_id, void *data )
if ( strcmp(fname, "exp") == 0 || strcmp(fname, "exp2") == 0 ) if ( strcmp(fname, "exp") == 0 || strcmp(fname, "exp2") == 0 )
{ {
float exp_error = ulps;
if (!gIsEmbedded)
{
exp_error += floor(fabs(2 * s[j]));
}
float exp_error = 3+floor(fabs(2*s[j]));
fail = ! (fabsf(err) <= exp_error); fail = ! (fabsf(err) <= exp_error);
ulps = exp_error; ulps = exp_error;
} }

8
test_conformance/math_brute_force/unary_two_results.cpp
View File

@@ -208,19 +208,13 @@ int TestFunc_Float2_Float(const Func *f, MTdata d, bool relaxedMode)
cl_uchar overflow[BUFFER_SIZE / sizeof( float )]; cl_uchar overflow[BUFFER_SIZE / sizeof( float )];
int isFract = 0 == strcmp( "fract", f->nameInCode ); int isFract = 0 == strcmp( "fract", f->nameInCode );
int skipNanInf = isFract && ! gInfNanSupport; int skipNanInf = isFract && ! gInfNanSupport;
float float_ulps; float float_ulps = getAllowedUlpError(f, relaxedMode);
logFunctionInfo(f->name, sizeof(cl_float), relaxedMode); logFunctionInfo(f->name, sizeof(cl_float), relaxedMode);
if( gWimpyMode ) if( gWimpyMode )
{ {
step = (1ULL<<32) * gWimpyReductionFactor / (512); step = (1ULL<<32) * gWimpyReductionFactor / (512);
} }
if( gIsEmbedded )
float_ulps = f->float_embedded_ulps;
else
float_ulps = f->float_ulps;
if (relaxedMode) float_ulps = f->relaxed_error;
// Init the kernels // Init the kernels
BuildKernelInfo build_info = { gMinVectorSizeIndex, kernels, programs, BuildKernelInfo build_info = { gMinVectorSizeIndex, kernels, programs,