amd/blis
1
0
Fork 0
mirror of https://github.com/amd/blis.git synced 2026-05-22 17:38:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

GTestSuite: More threshold changes

Browse Source 
Various changes from testing code paths with both gcc and aocc.

AMD-Internal: [CPUPL-4378]
Change-Id: I8964d8ab4e1f5669026af606598c2eb3dfddde16
This commit is contained in:
Edward Smyth
2024-09-20 16:04:18 -04:00
parent 06d776b025
commit ef5cbf7c9a
61 changed files with 655 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
gtestsuite/testsuite/level1/axpbyv/caxpbyv/caxpbyv_generic.cpp
View File

@@ -67,7 +67,6 @@ TEST_P( caxpbyvGeneric, API )
// Check gtestsuite axpbyv.h (no netlib version) for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
// NOTE : Every mul for complex types involves 3 ops(2 muls + 1 add)
double thresh;
double adj = 3;

1
gtestsuite/testsuite/level1/axpbyv/caxpbyv/evt/caxpbyv_evt.cpp
View File

@@ -82,7 +82,6 @@ TEST_P( caxpbyvEVT, API )
// Check gtestsuite axpbyv.h (no netlib version) for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
// NOTE : Every mul for complex types involves 3 ops(2 muls + 1 add)
double thresh;
double adj = 3;

1
gtestsuite/testsuite/level1/axpbyv/zaxpbyv/evt/zaxpbyv_evt.cpp
View File

@@ -82,7 +82,6 @@ TEST_P( zaxpbyvEVT, API )
// Check gtestsuite axpbyv.h (no netlib version) for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
// NOTE : Every mul for complex types involves 3 ops(2 muls + 1 add)
double thresh;
double adj = 3;

1
gtestsuite/testsuite/level1/axpbyv/zaxpbyv/zaxpbyv_generic.cpp
View File

@@ -67,7 +67,6 @@ TEST_P( zaxpbyvGeneric, API )
// Check gtestsuite axpbyv.h (no netlib version) for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
// NOTE : Every mul for complex types involves 3 ops(2 muls + 1 add)
double thresh;
double adj = 3;

21
gtestsuite/testsuite/level1/axpyf/daxpyf_generic.cpp
View File

@@ -78,10 +78,25 @@ TEST_P( daxpyfGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else if (alpha == testinghelpers::ONE<T>())
thresh = (b+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 6.6;
#endif
thresh = adj*(b+1)*testinghelpers::getEpsilon<T>();
}
else
thresh = (2*b+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 6.9;
#endif
thresh = adj*(2*b+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call generic test body using those parameters
//----------------------------------------------------------

11
gtestsuite/testsuite/level1/axpyv/zaxpyv/zaxpyv_evt.cpp
View File

@@ -79,8 +79,6 @@ TEST_P( zaxpyvEVT, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
// Small adjustment has been applied for complex data.
double adj = 1.5;
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>())
@@ -88,8 +86,15 @@ TEST_P( zaxpyvEVT, API )
else if (alpha == testinghelpers::ONE<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.5;
#endif
thresh = adj*2*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call generic test body using those parameters
//----------------------------------------------------------

16
gtestsuite/testsuite/level1/axpyv/zaxpyv/zaxpyv_generic.cpp
View File

@@ -64,14 +64,7 @@ TEST_P( zaxpyvGeneric, API )
// Check gtestsuite axpyv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With small adjustment applied for complex data.
double thresh;
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.02;
#else
double adj = 1.0;
#endif
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>())
@@ -79,8 +72,15 @@ TEST_P( zaxpyvGeneric, API )
else if (alpha == testinghelpers::ONE<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.02;
#else
double adj = 1.0;
#endif
thresh = adj*2*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call generic test body using those parameters
//----------------------------------------------------------

6
gtestsuite/testsuite/level1/dotxf/ddotxf_generic.cpp
View File

@@ -81,7 +81,7 @@ TEST_P( ddotxfGeneric, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
// Threshold adjustment
// Threshold adjustment
if (m == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>())
@@ -97,7 +97,7 @@ TEST_P( ddotxfGeneric, API )
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 3.9;
double adj = 4.4;
#endif
thresh = adj*(m+1)*testinghelpers::getEpsilon<T>();
}
@@ -111,7 +111,7 @@ TEST_P( ddotxfGeneric, API )
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 5.2;
double adj = 5.3;
#endif
thresh = adj*(2*m+1)*testinghelpers::getEpsilon<T>();
}

13
gtestsuite/testsuite/level1/scalv/cscalv/cscalv_generic.cpp
View File

@@ -63,15 +63,22 @@ TEST_P( cscalvGeneric, API )
// Check gtestsuite scalv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
// With adjustment applied for complex data.
double thresh;
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() || alpha == testinghelpers::ONE<T>())
thresh = 0.0;
else
thresh = testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.01;
#else
double adj = 1.01;
#endif
thresh = adj*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call generic test body using those parameters
//----------------------------------------------------------

14
gtestsuite/testsuite/level2/gemv/cgemv/cgemv_generic.cpp
View File

@@ -85,7 +85,6 @@ TEST_P( cgemvGeneric, API )
// Check gtestsuite gemv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -94,11 +93,18 @@ TEST_P( cgemvGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.1;
#endif
if(( transa == 'n' ) || ( transa == 'N' ))
thresh = (3*n+1)*testinghelpers::getEpsilon<T>();
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
else
thresh = (3*m+1)*testinghelpers::getEpsilon<T>();
thresh = adj*(3*m+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

14
gtestsuite/testsuite/level2/gemv/zgemv/zgemv_generic.cpp
View File

@@ -85,7 +85,6 @@ TEST_P( zgemvGeneric, API )
// Check gtestsuite gemv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -94,11 +93,18 @@ TEST_P( zgemvGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.1;
#endif
if(( transa == 'n' ) || ( transa == 'N' ))
thresh = (3*n+1)*testinghelpers::getEpsilon<T>();
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
else
thresh = (3*m+1)*testinghelpers::getEpsilon<T>();
thresh = adj*(3*m+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

13
gtestsuite/testsuite/level2/ger/cger/cger_generic.cpp
View File

@@ -78,14 +78,19 @@ TEST_P( cgerGeneric, API )
// Check gtestsuite ger.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
double adj = 3.0;
if (m == 0 || n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.8;
#endif
thresh = adj*3*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------
@@ -231,4 +236,4 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Values( gtint_t(0), gtint_t(3) )
),
::gerGenericPrint<scomplex>()
);
);

13
gtestsuite/testsuite/level2/ger/zger/zger_generic.cpp
View File

@@ -82,8 +82,15 @@ TEST_P( zgerGeneric, API )
if (m == 0 || n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else
thresh = 7*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.9;
#endif
thresh = adj*3*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------
@@ -189,4 +196,4 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Values( gtint_t(0), gtint_t(3) )
),
::gerGenericPrint<dcomplex>()
);
);

8
gtestsuite/testsuite/level2/hemv/chemv_generic.cpp
View File

@@ -83,6 +83,12 @@ TEST_P( chemvGeneric, API )
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.2;
#endif
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() && (beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
@@ -90,7 +96,7 @@ TEST_P( chemvGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
thresh = (3*n+1)*testinghelpers::getEpsilon<T>();
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Call test body using these parameters

14
gtestsuite/testsuite/level2/hemv/zhemv_generic.cpp
View File

@@ -83,11 +83,6 @@ TEST_P( zhemvGeneric, API )
// of output, and hence the multipler for epsilon.
// With adjustment applied for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.4;
#endif
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() && (beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
@@ -95,8 +90,15 @@ TEST_P( zhemvGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.4;
#endif
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

15
gtestsuite/testsuite/level2/her/cher_generic.cpp
View File

@@ -72,18 +72,19 @@ TEST_P( cherGeneric, API )
// Check gtestsuite her.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.0;
#endif
if (n == 0 || alpha == 0.0f)
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.0;
#endif
thresh = adj*3*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

15
gtestsuite/testsuite/level2/her/zher_generic.cpp
View File

@@ -72,18 +72,19 @@ TEST_P( zherGeneric, API )
// Check gtestsuite her.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.0;
#endif
if (n == 0 || alpha == 0.0)
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.0;
#endif
thresh = adj*3*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

18
gtestsuite/testsuite/level2/her2/cher2_generic.cpp
View File

@@ -78,21 +78,19 @@ TEST_P( cher2Generic, API )
// Check gtestsuite her2.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 4.0;
#ifdef REF_IS_MKL
adj = 6.0;
#endif
#endif
if (n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 6.1;
#endif
thresh = adj*6*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

15
gtestsuite/testsuite/level2/her2/zher2_generic.cpp
View File

@@ -78,18 +78,19 @@ TEST_P( zher2Generic, API )
// Check gtestsuite her2.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 6.0;
#endif
if (n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 14.1;
#endif
thresh = adj*6*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

17
gtestsuite/testsuite/level2/symv/dsymv_generic.cpp
View File

@@ -82,14 +82,6 @@ TEST_P( dsymvGeneric, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.4;
#else
double adj = 1.7;
#ifdef REF_IS_MKL
adj = 1.4;
#endif
#endif
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() && (beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
@@ -97,8 +89,15 @@ TEST_P( dsymvGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.5;
#else
double adj = 2.5;
#endif
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

17
gtestsuite/testsuite/level2/symv/ssymv_generic.cpp
View File

@@ -82,14 +82,6 @@ TEST_P( ssymvGeneric, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 3.4;
#else
double adj = 2.0;
#ifdef REF_IS_MKL
adj = 1.4;
#endif
#endif
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() && (beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
@@ -97,8 +89,15 @@ TEST_P( ssymvGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 3.4;
#else
double adj = 2.3;
#endif
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

14
gtestsuite/testsuite/level2/syr2/dsyr2_generic.cpp
View File

@@ -79,16 +79,18 @@ TEST_P( dsyr2Generic, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.34;
#else
double adj = 4.0;
#endif
if (n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 2.8;
#else
double adj = 4.0;
#endif
thresh = adj*6*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

14
gtestsuite/testsuite/level2/syr2/ssyr2_generic.cpp
View File

@@ -79,16 +79,18 @@ TEST_P( ssyr2Generic, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 3.0;
#endif
if (n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.4;
#else
double adj = 4.0;
#endif
thresh = adj*6*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

10
gtestsuite/testsuite/level2/trmv/ctrmv/ctrmv_generic.cpp
View File

@@ -77,20 +77,14 @@ TEST_P( ctrmvGeneric, API )
// Check gtestsuite trmv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.0;
#endif
if (n == 0 || alpha == T{0.0})
thresh = 0.0;
else
if(alpha == T{1.0})
thresh = adj*2*n*testinghelpers::getEpsilon<T>();
thresh = 2*n*testinghelpers::getEpsilon<T>();
else
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
thresh = 3*n*testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Call test body using these parameters

10
gtestsuite/testsuite/level2/trmv/dtrmv/dtrmv_generic.cpp
View File

@@ -78,19 +78,13 @@ TEST_P( dtrmvGeneric, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.0;
#endif
if (n == 0 || alpha == T{0.0})
thresh = 0.0;
else
if(alpha == T{1.0})
thresh = adj*2*n*testinghelpers::getEpsilon<T>();
thresh = 2*n*testinghelpers::getEpsilon<T>();
else
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
thresh = 3*n*testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Call test body using these parameters

10
gtestsuite/testsuite/level2/trmv/strmv/strmv_generic.cpp
View File

@@ -78,19 +78,13 @@ TEST_P( strmvGeneric, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.0;
#endif
if (n == 0 || alpha == T{0.0})
thresh = 0.0;
else
if(alpha == T{1.0})
thresh = adj*2*n*testinghelpers::getEpsilon<T>();
thresh = 2*n*testinghelpers::getEpsilon<T>();
else
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
thresh = 3*n*testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Call test body using these parameters

10
gtestsuite/testsuite/level2/trmv/ztrmv/ztrmv_generic.cpp
View File

@@ -77,20 +77,14 @@ TEST_P( ztrmvGeneric, API )
// Check gtestsuite trmv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.0;
#endif
if (n == 0 || alpha == T{0.0})
thresh = 0.0;
else
if(alpha == T{1.0})
thresh = adj*2*n*testinghelpers::getEpsilon<T>();
thresh = 2*n*testinghelpers::getEpsilon<T>();
else
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
thresh = 3*n*testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Call test body using these parameters

15
gtestsuite/testsuite/level2/trsv/ctrsv/ctrsv_generic.cpp
View File

@@ -77,21 +77,22 @@ TEST_P( ctrsvGeneric, API )
// Check gtestsuite trsv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.5;
#endif
if (n == 0 || alpha == T{0.0})
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.5;
#endif
if(alpha == T{1.0})
thresh = adj*2*n*testinghelpers::getEpsilon<T>();
else
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

18
gtestsuite/testsuite/level2/trsv/dtrsv/dtrsv_generic.cpp
View File

@@ -78,23 +78,21 @@ TEST_P( dtrsvGeneric, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 7.5;
#ifdef REF_IS_MKL
adj = 8.3;
#endif
#endif
if (n == 0 || alpha == T{0.0})
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 7.5;
#endif
if(alpha == T{1.0})
thresh = adj*2*n*testinghelpers::getEpsilon<T>();
else
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

21
gtestsuite/testsuite/level2/trsv/strsv/strsv_generic.cpp
View File

@@ -78,26 +78,21 @@ TEST_P( strsvGeneric, API )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 9.0;
#ifdef REF_IS_MKL
adj = 12.0;
#endif
#else
double adj = 12.0;
#ifdef REF_IS_MKL
adj = 14.0;
#endif
#endif
if (n == 0 || alpha == T{0.0})
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 9.0;
#else
double adj = 18.0;
#endif
if(alpha == T{1.0})
thresh = adj*2*n*testinghelpers::getEpsilon<T>();
else
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

15
gtestsuite/testsuite/level2/trsv/ztrsv/ztrsv_generic.cpp
View File

@@ -77,21 +77,22 @@ TEST_P( ztrsvGeneric, API )
// Check gtestsuite trsv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.0;
#endif
if (n == 0 || alpha == T{0.0})
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.0;
#endif
if(alpha == T{1.0})
thresh = adj*2*n*testinghelpers::getEpsilon<T>();
else
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

11
gtestsuite/testsuite/level3/gemm/cgemm/cgemm_generic.cpp
View File

@@ -82,7 +82,6 @@ TEST_P( cgemmGeneric, API )
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -90,7 +89,15 @@ TEST_P( cgemmGeneric, API )
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.1;
#endif
thresh = adj*testinghelpers::getEpsilon<T>();
}
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();

12
gtestsuite/testsuite/level3/gemm/dgemm/dgemm_generic.cpp
View File

@@ -93,9 +93,15 @@ TEST_P( dgemmGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
//thresh = (15*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 3.0;
#else
double adj = 3.2;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

14
gtestsuite/testsuite/level3/gemm/sgemm/sgemm_generic.cpp
View File

@@ -93,9 +93,15 @@ TEST_P( sgemmGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
//thresh = (24*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 3.9;
#else
double adj = 3.8;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------
@@ -194,4 +200,4 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Values(0, 17) // increment to the leading dim of c
),
::gemmGenericPrint<float>()
);
);

12
gtestsuite/testsuite/level3/gemm/zgemm/zgemm_generic.cpp
View File

@@ -92,9 +92,15 @@ TEST_P( zgemmGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
thresh = (7*k+3)*testinghelpers::getEpsilon<T>();
//thresh = (15*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.2;
#else
double adj = 2.5;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

126
gtestsuite/testsuite/level3/gemm_compute/IIT_ERS/gemm_compute_IIT_ERS.cpp
View File

@@ -569,7 +569,39 @@ TYPED_TEST(gemm_compute_IIT_ERS, k_zero_beta_one)
}
// zero alpha and zero beta - set C to 0
TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_ZeroBeta)
// Not packing A and not packing B, so alpha is actually one.
TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_ZeroBeta_UU)
{
using T = TypeParam;
T alpha, beta;
testinghelpers::initzero<T>( alpha );
testinghelpers::initzero<T>( beta );
double adj = 2.7;
double thresh = adj*(2*K)*testinghelpers::getEpsilon<T>();
// Test with all arguments correct except for the value we are choosing to test.
std::vector<T> a = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, K, LDA);
std::vector<T> b = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', K, N, LDB);
std::vector<T> c = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, N, LDC);
// Copy so that we check that the elements of C are not modified.
std::vector<T> c_ref(c);
testinghelpers::ref_gemm_compute<T>( STORAGE, TRANS, TRANS, 'U', 'U', M, N, K, alpha,
a.data(), LDA, b.data(), LDB, beta, c_ref.data(), LDC );
// Enable packing of A matrix to accound for alpha = 0 scaling.
gemm_compute<T>( STORAGE, TRANS, TRANS, 'U', 'U', M, N, K, &alpha, a.data(), LDA, b.data(), LDB, &beta, c.data(), LDC );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, c.data(), c_ref.data(), LDC, thresh);
#ifdef CAN_TEST_INFO_VALUE
gtint_t info = bli_info_get_info_value();
computediff<gtint_t>( "info", info, 0 );
#endif
}
TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_ZeroBeta_PU)
{
using T = TypeParam;
@@ -596,15 +628,43 @@ TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_ZeroBeta)
#endif
}
TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_ZeroBeta_UP)
{
using T = TypeParam;
T alpha, beta;
testinghelpers::initzero<T>( alpha );
testinghelpers::initzero<T>( beta );
std::vector<T> c = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, N, LDC);
// Copy so that we check that the elements of C are not modified.
std::vector<T> zero_mat = testinghelpers::get_random_matrix<T>(0, 0, STORAGE, 'n', M, N, LDB);
// Test with all arguments correct except for the value we are choosing to test.
std::vector<T> a = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, K, LDA);
std::vector<T> b = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', K, N, LDB);
// Enable packing of A matrix to accound for alpha = 0 scaling.
gemm_compute<T>( STORAGE, TRANS, TRANS, 'U', 'P', M, N, K, &alpha, a.data(), LDA, b.data(), LDB, &beta, c.data(), LDC );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, c.data(), zero_mat.data(), LDC);
#ifdef CAN_TEST_INFO_VALUE
gtint_t info = bli_info_get_info_value();
computediff<gtint_t>( "info", info, 0 );
#endif
}
// zero alpha and non-zero/non-unit beta - scale C only
TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_OtherBeta)
// Not packing A and not packing B, so alpha is actually one.
TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_OtherBeta_UU)
{
using T = TypeParam;
T alpha, beta;
testinghelpers::initzero<T>( alpha );
beta = T{2.0};
double thresh = testinghelpers::getEpsilon<T>();
double thresh = (2*K+1)*testinghelpers::getEpsilon<T>();
std::vector<T> a = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, K, LDA);
std::vector<T> b = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', K, N, LDB);
@@ -626,4 +686,64 @@ TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_OtherBeta)
#endif
}
// zero alpha and non-zero/non-unit beta - scale C only
TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_OtherBeta_PU)
{
using T = TypeParam;
T alpha, beta;
testinghelpers::initzero<T>( alpha );
beta = T{2.0};
double thresh = testinghelpers::getEpsilon<T>();
std::vector<T> a = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, K, LDA);
std::vector<T> b = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', K, N, LDB);
std::vector<T> c = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, N, LDC);
// Copy so that we check that the elements of C are not modified.
std::vector<T> c_ref(c);
testinghelpers::ref_gemm_compute<T>( STORAGE, TRANS, TRANS, 'P', 'U', M, N, K, alpha,
a.data(), LDA, b.data(), LDB, beta, c_ref.data(), LDC );
// Test with all arguments correct except for the value we are choosing to test.
gemm_compute<T>( STORAGE, TRANS, TRANS, 'P', 'U', M, N, K, &alpha, a.data(), LDA, b.data(), LDB, &beta, c.data(), LDC );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, c.data(), c_ref.data(), LDC, thresh);
#ifdef CAN_TEST_INFO_VALUE
gtint_t info = bli_info_get_info_value();
computediff<gtint_t>( "info", info, 0 );
#endif
}
// zero alpha and non-zero/non-unit beta - scale C only
TYPED_TEST(gemm_compute_IIT_ERS, ZeroAlpha_OtherBeta_UP)
{
using T = TypeParam;
T alpha, beta;
testinghelpers::initzero<T>( alpha );
beta = T{2.0};
double thresh = testinghelpers::getEpsilon<T>();
std::vector<T> a = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, K, LDA);
std::vector<T> b = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', K, N, LDB);
std::vector<T> c = testinghelpers::get_random_matrix<T>(-10, 10, STORAGE, 'N', M, N, LDC);
// Copy so that we check that the elements of C are not modified.
std::vector<T> c_ref(c);
testinghelpers::ref_gemm_compute<T>( STORAGE, TRANS, TRANS, 'U', 'P', M, N, K, alpha,
a.data(), LDA, b.data(), LDB, beta, c_ref.data(), LDC );
// Test with all arguments correct except for the value we are choosing to test.
gemm_compute<T>( STORAGE, TRANS, TRANS, 'U', 'P', M, N, K, &alpha, a.data(), LDA, b.data(), LDB, &beta, c.data(), LDC );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, c.data(), c_ref.data(), LDC, thresh);
#ifdef CAN_TEST_INFO_VALUE
gtint_t info = bli_info_get_info_value();
computediff<gtint_t>( "info", info, 0 );
#endif
}
#endif

30
gtestsuite/testsuite/level3/gemm_compute/dgemm_compute/dgemm_compute_generic.cpp
View File

@@ -91,13 +91,35 @@ TEST_P( dgemmComputeGeneric, API )
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
else if ((alpha == testinghelpers::ZERO<T>() || k == 0) &&
else if ((k == 0) &&
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
thresh = 0.0;
else if ((alpha == testinghelpers::ZERO<T>()) &&
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.3;
#endif
if (( packa == 'u' || packa == 'U' ) &&
( packb == 'u' || packb == 'U' ))
// alpha is actually 1.0 when both matrices are unpacked
thresh = adj*(2*k)*testinghelpers::getEpsilon<T>();
else
thresh = 0.0;
}
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
//thresh = (7*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 2.3;
#else
double adj = 2.7;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

30
gtestsuite/testsuite/level3/gemm_compute/sgemm_compute/sgemm_compute_generic.cpp
View File

@@ -92,13 +92,35 @@ TEST_P( sgemmComputeGeneric, API )
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
else if ((alpha == testinghelpers::ZERO<T>() || k == 0) &&
else if ((k == 0) &&
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
thresh = 0.0;
else if ((alpha == testinghelpers::ZERO<T>()) &&
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 2.7;
#else
double adj = 1.7;
#endif
if (( packa == 'u' || packa == 'U' ) &&
( packb == 'u' || packb == 'U' ))
// alpha is actually 1.0 when both matrices are unpacked
thresh = adj*(2*k)*testinghelpers::getEpsilon<T>();
else
thresh = 0.0;
}
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
//thresh = (8*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 2.7;
#else
double adj = 3.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

12
gtestsuite/testsuite/level3/gemmt/cgemmt/cgemmt_generic.cpp
View File

@@ -84,7 +84,6 @@ TEST_P( cgemmtGeneric, API )
// Check gtestsuite gemmt.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
if (n == 0)
thresh = 0.0;
@@ -92,8 +91,15 @@ TEST_P( cgemmtGeneric, API )
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
thresh = 0.0;
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.2;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

11
gtestsuite/testsuite/level3/gemmt/dgemmt/dgemmt_generic.cpp
View File

@@ -93,8 +93,15 @@ TEST_P( dgemmtGeneric, API )
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
thresh = 0.0;
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 4.1;
#else
double adj = 4.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

11
gtestsuite/testsuite/level3/gemmt/sgemmt/sgemmt_generic.cpp
View File

@@ -91,8 +91,15 @@ TEST_P( sgemmtGeneric, API )
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
thresh = 0.0;
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.5;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

3
gtestsuite/testsuite/level3/gemmt/test_gemmt.h
View File

@@ -83,7 +83,8 @@ void test_gemmt( char storage, char uploc, char transa, char transb, gtint_t n,
dim_t size_c = testinghelpers::matsize(storage, 'n', n, n, ldc) * sizeof(T);
testinghelpers::ProtectedBuffer c(size_c, false, is_mem_test );
c_ptr = (T*)c.greenzone_1;
if (beta != testinghelpers::ZERO<T>())
//if (beta != testinghelpers::ZERO<T>())
if (1)
{
testinghelpers::datagenerators::randomgenerators<T>( -3, 5, storage, n, n, c_ptr, 'n', ldc);
if ( is_evt_test )

11
gtestsuite/testsuite/level3/hemm/chemm_generic.cpp
View File

@@ -86,20 +86,25 @@ TEST_P( chemmGeneric, API )
// Check gtestsuite hemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
double adj = 2.5;
if (m == 0 || n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() &&
(beta == testinghelpers::ZERO<T>() || beta == testinghelpers::ONE<T>()))
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.5;
#endif
if ( side == 'l' || side == 'L' )
thresh = adj*(3*m+1)*testinghelpers::getEpsilon<T>();
else
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

11
gtestsuite/testsuite/level3/her2k/cher2k_generic.cpp
View File

@@ -83,16 +83,21 @@ TEST_P( cher2kGeneric, API )
// Check gtestsuite her2k.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
double adj = 2.5;
if (n == 0)
thresh = 0.0;
else if ((alpha == testinghelpers::ZERO<T>() || k == 0) && (beta == 0.0f || beta == 1.0f))
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 5.3;
#endif
thresh = adj*(6*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

11
gtestsuite/testsuite/level3/her2k/zher2k_generic.cpp
View File

@@ -83,16 +83,21 @@ TEST_P( zher2kGeneric, API )
// Check gtestsuite her2k.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
double adj = 2.5;
if (n == 0)
thresh = 0.0;
else if ((alpha == testinghelpers::ZERO<T>() || k == 0) && (beta == 0.0 || beta == 1.0))
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 3.3;
#endif
thresh = adj*(6*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

12
gtestsuite/testsuite/level3/herk/cherk_generic.cpp
View File

@@ -78,15 +78,21 @@ TEST_P( cherkGeneric, API )
// Check gtestsuite herk.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
if (n == 0)
thresh = 0.0;
else if ((alpha == 0.0f || k == 0) && (beta == 0.0f || beta == 1.0f))
thresh = 0.0;
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 4.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

12
gtestsuite/testsuite/level3/herk/zherk_generic.cpp
View File

@@ -78,15 +78,21 @@ TEST_P( zherkGeneric, API )
// Check gtestsuite herk.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
if (n == 0)
thresh = 0.0;
else if ((alpha == 0.0 || k == 0) && (beta == 0.0 || beta == 1.0))
thresh = 0.0;
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 4.1;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

11
gtestsuite/testsuite/level3/symm/csymm_generic.cpp
View File

@@ -86,9 +86,7 @@ TEST_P( csymmGeneric, API )
// Check gtestsuite symm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// With adjustment for complex data.
double thresh;
double adj = 1.5;
if (m == 0 || n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() &&
@@ -97,11 +95,18 @@ TEST_P( csymmGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 3.5;
#endif
if ( side == 'l' || side == 'L' )
thresh = adj*(3*m+1)*testinghelpers::getEpsilon<T>();
else
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

14
gtestsuite/testsuite/level3/symm/zsymm_generic.cpp
View File

@@ -86,7 +86,6 @@ TEST_P( zsymmGeneric, API )
// Check gtestsuite symm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -96,11 +95,18 @@ TEST_P( zsymmGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.1;
#endif
if ( side == 'l' || side == 'L' )
thresh = (3*m+1)*testinghelpers::getEpsilon<T>();
thresh = adj*(3*m+1)*testinghelpers::getEpsilon<T>();
else
thresh = (3*n+1)*testinghelpers::getEpsilon<T>();
thresh = adj*(3*n+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

11
gtestsuite/testsuite/level3/syrk/dsyrk_generic.cpp
View File

@@ -86,8 +86,15 @@ TEST_P( dsyrkGeneric, API )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
thresh = (3*k+1)*testinghelpers::getEpsilon<T>();
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 2.4;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

13
gtestsuite/testsuite/level3/trmm/dtrmm_generic.cpp
View File

@@ -85,11 +85,18 @@ TEST_P( dtrmmGeneric, API )
if (m == 0 || n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.5;
#endif
if ( side == 'l' || side == 'L' )
thresh = 3*m*testinghelpers::getEpsilon<T>();
thresh = adj*3*m*testinghelpers::getEpsilon<T>();
else
thresh = 3*n*testinghelpers::getEpsilon<T>();
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

13
gtestsuite/testsuite/level3/trmm/strmm_generic.cpp
View File

@@ -85,11 +85,18 @@ TEST_P( strmmGeneric, API )
if (m == 0 || n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.8;
#endif
if ( side == 'l' || side == 'L' )
thresh = 3*m*testinghelpers::getEpsilon<T>();
thresh = adj*3*m*testinghelpers::getEpsilon<T>();
else
thresh = 3*n*testinghelpers::getEpsilon<T>();
thresh = adj*3*n*testinghelpers::getEpsilon<T>();
}
//----------------------------------------------------------
// Call test body using these parameters
//----------------------------------------------------------

2
gtestsuite/testsuite/level3/trsm/dtrsm/dtrsm_generic.cpp
View File

@@ -234,7 +234,7 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Values('n','u'), // diaga , n=nonunit u=unit
::testing::Values(1, 2, 300, 1500), // n
::testing::Values(1, 2, 300, 1500), // m
::testing::Values(-2.4, 0.0, 1.0, 3.1, NAN, INFINITY), // alpha
::testing::Values(-2.4, 0.0, 1.0, 3.1), // alpha
::testing::Values(gtint_t(0), gtint_t(5)), // increment to the leading dim of a
::testing::Values(gtint_t(0), gtint_t(3)) // increment to the leading dim of b
),

26
gtestsuite/testsuite/level3/trsm/dtrsm/evt/dtrsm_evt.cpp
View File

@@ -126,7 +126,7 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Values('n','u'), // diaga , n=nonunit u=unit
::testing::Values(1, 2, 301, 1551), // m
::testing::Values(1, 2, 324, 1676), // n
::testing::Values(-2.4, 0), // alpha
::testing::Values(-2.4, 1.0, 0.0), // alpha
::testing::Values(gtint_t(0)), // increment to the leading dim of a
::testing::Values(gtint_t(0)), // increment to the leading dim of b
::testing::Values(NO_EVT, NaN, INF, NaN_INF, DIAG_NaN, DIAG_INF),// EVT test for A
@@ -134,3 +134,27 @@ INSTANTIATE_TEST_SUITE_P(
),
::trsmEVTPrint<double>()
);
INSTANTIATE_TEST_SUITE_P(
alpha,
dtrsmEVT,
::testing::Combine(
::testing::Values('c'
#ifndef TEST_BLAS_LIKE
,'r'
#endif
), // storage format
::testing::Values('l','r'), // side l:left, r:right
::testing::Values('u','l'), // uplo u:upper, l:lower
::testing::Values('n','t'), // transa
::testing::Values('n','u'), // diaga , n=nonunit u=unit
::testing::Values(1, 2, 301, 1551), // m
::testing::Values(1, 2, 324, 1676), // n
::testing::Values(NaN, INF, -INF), // alpha
::testing::Values(gtint_t(0)), // increment to the leading dim of a
::testing::Values(gtint_t(0)), // increment to the leading dim of b
::testing::Values(NO_EVT), // EVT test for A
::testing::Values(NO_EVT) // EVT test for B
),
::trsmEVTPrint<double>()
);

22
gtestsuite/testsuite/ukr/gemm/cgemm/cgemm_ukernel.cpp
View File

@@ -72,8 +72,6 @@ TEST_P( cgemmGenericSUP, UKR )
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// Threshold adjustment
double adj = 8.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -83,8 +81,15 @@ TEST_P( cgemmGenericSUP, UKR )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.4;
#else
double adj = 8.1;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_complex_gemmsup_ukr<scomplex, cgemmsup_ker_ft> (storageC, transa, transb, m, n, k, alpha, beta, thresh, kern_ptr, is_memory_test);
}// end of function
@@ -668,8 +673,6 @@ TEST_P( cgemmGenericNat, UKR )
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// Threshold adjustment
double adj = 8.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -679,8 +682,15 @@ TEST_P( cgemmGenericNat, UKR )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 3.0;
#else
double adj = 7.1;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_gemmnat_ukr(storageC, m, n, k, alpha, beta, thresh, kern_ptr, is_memory_test);
}// end of function

42
gtestsuite/testsuite/ukr/gemm/dgemm/dgemm_ukernel.cpp
View File

@@ -77,7 +77,6 @@ TEST_P( dgemmGenericSUP, sup_kernel)
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double adj = 2.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -87,8 +86,15 @@ TEST_P( dgemmGenericSUP, sup_kernel)
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 4.5;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_gemmsup_ukr(kern_ptr, transa, transb, m, n, k, alpha, beta, storageC, MR, row_pref, thresh, is_memory_test);
}// end of function
@@ -372,7 +378,6 @@ TEST_P( dgemmGenericNat, native_kernel_testing)
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double adj=2.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -382,8 +387,15 @@ TEST_P( dgemmGenericNat, native_kernel_testing)
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.1;
#else
double adj = 3.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_gemmnat_ukr(storageC, m, n, k, alpha, beta, kern_ptr, thresh, is_memory_test);
}// end of function
@@ -505,7 +517,6 @@ TEST_P( dgemmGenericK1, k1_kernel_testing)
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// Threshold adjustment
double adj = 8.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -515,8 +526,15 @@ TEST_P( dgemmGenericK1, k1_kernel_testing)
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.9;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_gemmk1_ukr(kern_ptr, m, n, k, storageC, alpha, beta, thresh, is_memory_test);
}// end of function
@@ -638,7 +656,6 @@ TEST_P( dgemmGenericSmall, gemm_small)
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// Threshold adjustment./
double adj = 2.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -648,11 +665,18 @@ TEST_P( dgemmGenericSmall, gemm_small)
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.2;
#else
double adj = 2.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
if ( is_memory_test )
{
srand(time(NULL));
//srand(time(NULL));
double *a, *b, *c, *cref = NULL;
// Allocate memory for A
testinghelpers::ProtectedBuffer a_buf( m * k * lda * sizeof(double), false, is_memory_test );

20
gtestsuite/testsuite/ukr/gemm/sgemm/sgemm_ukernel.cpp
View File

@@ -77,7 +77,6 @@ TEST_P( sgemmGenericSUP, functionality_testing)
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double adj = 2.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -87,8 +86,15 @@ TEST_P( sgemmGenericSUP, functionality_testing)
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 3.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_gemmsup_ukr(kern_ptr, transa, transb, m, n, k, alpha, beta, storageC, MR, row_pref, thresh, is_memory_test);
}// end of function
@@ -452,7 +458,6 @@ TEST_P( sgemmGenericNat, functionality_testing)
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double adj = 2.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -462,8 +467,15 @@ TEST_P( sgemmGenericNat, functionality_testing)
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.2;
#else
double adj = 4.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_gemmnat_ukr(storageC, m, n, k, alpha, beta, kern_ptr, thresh, is_memory_test);
}// end of function

21
gtestsuite/testsuite/ukr/gemm/zgemm/zgemm_ukernel.cpp
View File

@@ -73,8 +73,6 @@ TEST_P( zgemmGenericSUP, UKR )
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double adj = 20.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -84,8 +82,15 @@ TEST_P( zgemmGenericSUP, UKR )
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 3.6;
#else
double adj = 19.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_complex_gemmsup_ukr(storageC, transa, transb, m, n, k, alpha, beta, thresh, kern_ptr, is_memory_test);
}// end of function
@@ -1204,7 +1209,6 @@ TEST_P( zgemmGenericNat, MicroKernelTest)
// Check gtestsuite gemm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double adj = 5.0;
double thresh;
if (m == 0 || n == 0)
thresh = 0.0;
@@ -1214,8 +1218,15 @@ TEST_P( zgemmGenericNat, MicroKernelTest)
else if (alpha == testinghelpers::ZERO<T>())
thresh = testinghelpers::getEpsilon<T>();
else
{
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 5.0;
#endif
thresh = adj*(3*k+1)*testinghelpers::getEpsilon<T>();
}
test_gemmnat_ukr(storageC, m, n, k, alpha, beta, thresh, kern_ptr, is_memory_test);
}// end of function

7
gtestsuite/testsuite/ukr/scal2v/zscal2v_ukr.cpp
View File

@@ -73,12 +73,17 @@ TEST_P( zscal2vGeneric, UKR )
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.01;
#else
double adj = 1.0;
#endif
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() || alpha == testinghelpers::ONE<T>())
thresh = 0.0;
else
thresh = testinghelpers::getEpsilon<T>();
thresh = adj*testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Call generic test body using those parameters

8
gtestsuite/testsuite/ukr/scalv/cscalv_ukr.cpp
View File

@@ -71,14 +71,18 @@ TEST_P( cscalvGeneric, UKR )
// Check gtestsuite scalv.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.01;
#else
double adj = 1.0;
#endif
if (n == 0)
thresh = 0.0;
else if (alpha == testinghelpers::ZERO<T>() || alpha == testinghelpers::ONE<T>())
thresh = 0.0;
else
thresh = testinghelpers::getEpsilon<T>();
thresh = adj*testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Call generic test body using those parameters

3
gtestsuite/testsuite/ukr/trsm/ztrsm/ztrsm_ukr.cpp
View File

@@ -87,13 +87,12 @@ TEST_P( ztrsmGenericNat, UKR )
// Check gtestsuite trsm.h or netlib source code for reminder of the
// functionality from which we estimate operation count per element
// of output, and hence the multipler for epsilon.
// No adjustment applied yet for complex data.
double thresh;
// Threshold adjustment
#ifdef BLIS_INT_ELEMENT_TYPE
double adj = 1.0;
#else
double adj = 1.6;
double adj = 1.7;
#endif
if (m == 0 || n == 0 || alpha == testinghelpers::ZERO<T>())
thresh = 0.0;