[gtest] conversion for lstm

test/gtest/CMakeLists.txt

@@ -29,8 +29,7 @@ function(add_gtest TEST_NAME TEST_CPP)
   endif()
   if(NOT WIN32) # TODO: cannot run on Windows due to missing DLL dependencies
     # Enable CMake to discover the test binary
-    # Extend GTest DISCOVERY_TIMEOUT to 5 mins
-    gtest_discover_tests(${TEST_NAME} DISCOVERY_TIMEOUT 300 PROPERTIES ENVIRONMENT "MIOPEN_USER_DB_PATH=${CMAKE_CURRENT_BINARY_DIR};MIOPEN_TEST_FLOAT_ARG=${MIOPEN_TEST_FLOAT_ARG};MIOPEN_TEST_ALL=${MIOPEN_TEST_ALL};MIOPEN_TEST_MLIR=${MIOPEN_TEST_MLIR};MIOPEN_TEST_COMPOSABLEKERNEL=${MIOPEN_TEST_COMPOSABLEKERNEL};CODECOV_TEST=${CODECOV_TEST};MIOPEN_TEST_DBSYNC=${MIOPEN_TEST_DBSYNC};MIOPEN_TEST_DEEPBENCH=${MIOPEN_TEST_DEEPBENCH};MIOPEN_TEST_FLOAT=${MIOPEN_TEST_FLOAT};MIOPEN_TEST_HALF=${MIOPEN_TEST_HALF}")
+    gtest_discover_tests(${TEST_NAME} DISCOVERY_TIMEOUT 300 PROPERTIES ENVIRONMENT "MIOPEN_USER_DB_PATH=${CMAKE_CURRENT_BINARY_DIR};MIOPEN_TEST_FLOAT_ARG=${MIOPEN_TEST_FLOAT_ARG};MIOPEN_TEST_ALL=${MIOPEN_TEST_ALL};MIOPEN_TEST_MLIR=${MIOPEN_TEST_MLIR};MIOPEN_TEST_COMPOSABLEKERNEL=${MIOPEN_TEST_COMPOSABLEKERNEL};CODECOV_TEST=${CODECOV_TEST};MIOPEN_TEST_DBSYNC=${MIOPEN_TEST_DBSYNC};MIOPEN_TEST_CONV=${MIOPEN_TEST_CONV};MIOPEN_TEST_DEEPBENCH=${MIOPEN_TEST_DEEPBENCH};MIOPEN_DEBUG_TUNING_ITERATIONS_MAX=${MIOPEN_DEBUG_TUNING_ITERATIONS_MAX}")
   endif()
     target_link_libraries(${TEST_NAME} BZip2::BZip2)
   if(WIN32)

test/gtest/conv_trans.cpp

@@ -43,7 +43,7 @@ void GetArgs(const std::string& param, std::vector<std::string>& tokens)
         tokens.push_back(*begin++);
 }
 
-class ConfigWithFloat : public testing::TestWithParam<std::vector<std::string>>
+class ConfigWithFloat_conv_trans : public testing::TestWithParam<std::vector<std::string>>
 {
 };
 
@@ -53,7 +53,7 @@ void Run2dDriver(miopenDataType_t prec)
     std::vector<std::string> params;
     switch(prec)
     {
-    case miopenFloat: params = ConfigWithFloat::GetParam(); break;
+    case miopenFloat: params = ConfigWithFloat_conv_trans::GetParam(); break;
     case miopenHalf:
     case miopenFloat8:
     case miopenBFloat8:
@@ -65,7 +65,7 @@ void Run2dDriver(miopenDataType_t prec)
                   "data type not supported by "
                   "conv_trans test";
 
-    default: params = ConfigWithFloat::GetParam();
+    default: params = ConfigWithFloat_conv_trans::GetParam();
     }
 
     for(const auto& test_value : params)
@@ -142,7 +142,7 @@ std::vector<std::string> GetTestCases(void)
 } // namespace conv_trans
 using namespace conv_trans;
 
-TEST_P(ConfigWithFloat, FloatTest_conv_trans)
+TEST_P(ConfigWithFloat_conv_trans, FloatTest_conv_trans)
 {
     const auto& handle = get_handle();
     if(IsTestSupportedForDevice(handle) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)))
@@ -155,4 +155,4 @@ TEST_P(ConfigWithFloat, FloatTest_conv_trans)
     }
 };
 
-INSTANTIATE_TEST_SUITE_P(ConvTrans, ConfigWithFloat, testing::Values(GetTestCases()));
+INSTANTIATE_TEST_SUITE_P(ConvTrans, ConfigWithFloat_conv_trans, testing::Values(GetTestCases()));

test/gtest/deepbench_lstm.cpp

@@ -35,23 +35,6 @@ MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_DEEPBENCH)
 
 namespace deepbench_lstm {
 
-static bool Skip(miopenDataType_t prec)
-{
-    switch(prec)
-    {
-    case miopenFloat: return !miopen::IsEnabled(ENV(MIOPEN_TEST_DEEPBENCH));
-    case miopenHalf:
-    case miopenFloat8:
-    case miopenBFloat8:
-    case miopenInt8:
-    case miopenBFloat16:
-    case miopenInt32:
-    case miopenDouble:
-    default: MIOPEN_THROW("Unsupported datatype");
-    }
-    return true;
-}
-
 void GetArgs(const std::string& param, std::vector<std::string>& tokens)
 {
     std::stringstream ss(param);
@@ -97,50 +80,13 @@ auto GetTestCases(std::string precision)
 
 using TestCase = decltype(GetTestCases({}))::value_type;
 
-class ConfigWithFloat : public testing::TestWithParam<std::vector<TestCase>>
+class ConfigWithFloat_deepbench_lstm : public testing::TestWithParam<std::vector<TestCase>>
 {
 };
 
-class ConfigWithHalf : public testing::TestWithParam<std::vector<TestCase>>
+void Run2dDriverFloat(void)
 {
-};
-
-static bool IsTestSupportedForDevice()
-{
-    using namespace miopen::debug;
-    using e_mask = enabled<Gpu::gfx94X, Gpu::gfx103X, Gpu::gfx110X, Gpu::gfx908>;
-    using d_mask = disabled<Gpu::Default>;
-    return miopen::debug::IsTestSupportedForDevice<d_mask, e_mask>();
-}
-
-void Run2dDriver(miopenDataType_t prec)
-{
-    if(!IsTestSupportedForDevice())
-    {
-        GTEST_SKIP();
-    }
-    if(Skip(prec))
-    {
-        GTEST_SKIP();
-    }
-    std::vector<std::string> params;
-    switch(prec)
-    {
-    case miopenFloat: params = ConfigWithFloat::GetParam(); break;
-    case miopenHalf: params = ConfigWithHalf::GetParam(); break;
-    case miopenFloat8:
-    case miopenBFloat8:
-    case miopenInt8:
-    case miopenBFloat16:
-    case miopenInt32:
-    case miopenDouble:
-        FAIL() << "miopenInt8, miopenBFloat16, miopenInt32, "
-                  "miopenDouble, miopenFloat8, miopenBFloat8 "
-                  "data types not supported by "
-                  "deepbench_lstm test";
-
-    default: params = ConfigWithFloat::GetParam();
-    }
+    std::vector<std::string> params = ConfigWithFloat_deepbench_lstm::GetParam();
 
     for(const auto& test_value : params)
     {
@@ -161,6 +107,16 @@ void Run2dDriver(miopenDataType_t prec)
 
 using namespace deepbench_lstm;
 
-TEST_P(ConfigWithFloat, FloatTest_deepbench_lstm) { Run2dDriver(miopenFloat); };
+TEST_P(ConfigWithFloat_deepbench_lstm, FloatTest_deepbench_lstm)
+{
+    if(!miopen::IsEnabled(ENV(MIOPEN_TEST_DEEPBENCH)))
+    {
+        GTEST_SKIP();
+    }
+
+    Run2dDriverFloat();
+};
 
-INSTANTIATE_TEST_SUITE_P(DeepbenchLstm, ConfigWithFloat, testing::Values(GetTestCases("--float")));
+INSTANTIATE_TEST_SUITE_P(DeepbenchLstm,
+                         ConfigWithFloat_deepbench_lstm,
+                         testing::Values(GetTestCases("--float")));

test/gtest/gtest_common.hpp

@@ -38,9 +38,7 @@
 
 #include "../driver.hpp"
 
-namespace miopen {
-namespace debug {
-void default_check(const std::string& err) { std::cout << err; }
+inline void default_check(const std::string& err) { std::cout << err; }
 
 inline void tuning_check(const std::string& err)
 {
@@ -174,8 +172,6 @@ void invoke_with_params(Check&& check)
         check(testing::internal::GetCapturedStderr());
     }
 }
-} // namespace debug
-} // namespace miopen
 
 /// The types for env variables must be redefined, but
 /// do not mess up with the types - those variables are decalred in the library

test/gtest/lstm_extra.cpp

@@ -31,6 +31,9 @@
 #include <gtest/gtest.h>
 #include <boost/algorithm/string.hpp>
 
+MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
+MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLOAT_ARG)
+
 namespace lstm_extra {
 void GetArgs(const std::string& param, std::vector<std::string>& tokens)
 {
@@ -77,19 +80,15 @@ auto GetTestCases(std::string precision)
         {flags + commonFlags + " -dir-mode 1 --no-hy --no-cy"},
         {flags + commonFlags + " -dir-mode 1 --no-dcx"},
         {flags + commonFlags + " -dir-mode 1 --no-cy --no-dcx"},
-	{flags + commonFlags + " -dir-mode 0 --no-hx --no-dhy --no-cx --no-dcy --no-hy --no-dhx --no-cy --no-dcx"},
-	{flags + commonFlags + " -dir-mode 1 --no-hx --no-dhy --no-cx --no-dcy --no-hy --no-dhx --no-cy --no-dcx"}
+	    {flags + commonFlags + " -dir-mode 0 --no-hx --no-dhy --no-cx --no-dcy --no-hy --no-dhx --no-cy --no-dcx"},
+	    {flags + commonFlags + " -dir-mode 1 --no-hx --no-dhy --no-cx --no-dcy --no-hy --no-dhx --no-cy --no-dcx"}
     };
     // clang-format on
 }
 
 using TestCase = decltype(GetTestCases({}))::value_type;
 
-class ConfigWithFloat : public testing::TestWithParam<std::vector<TestCase>>
-{
-};
-
-class ConfigWithHalf : public testing::TestWithParam<std::vector<TestCase>>
+class ConfigWithFloat_lstm_extra : public testing::TestWithParam<std::vector<TestCase>>
 {
 };
 
@@ -98,33 +97,19 @@ bool IsTestSupportedForDevice()
     using namespace miopen::debug;
     using e_mask = enabled<Gpu::gfx94X, Gpu::gfx103X, Gpu::gfx110X>;
     using d_mask = disabled<Gpu::Default>;
-    return miopen::debug::IsTestSupportedForDevice<d_mask, e_mask>();
+    return ::IsTestSupportedForDevMask<d_mask, e_mask>();
 }
 
 void Run2dDriver(miopenDataType_t prec)
 {
-    if(!IsTestSupportedForDevice())
+    if(!(IsTestSupportedForDevice()                      //
+         && (miopen::IsUnset(ENV(MIOPEN_TEST_ALL))       // standalone run
+             || (miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) // or --float full tests enabled
+                 && miopen::GetStringEnv(ENV(MIOPEN_TEST_FLOAT_ARG)) == "--float"))))
     {
         GTEST_SKIP();
     }
-    std::vector<std::string> params;
-    switch(prec)
-    {
-    case miopenFloat: params = ConfigWithFloat::GetParam(); break;
-    case miopenHalf:
-    case miopenFloat8:
-    case miopenBFloat8:
-    case miopenInt8:
-    case miopenBFloat16:
-    case miopenInt32:
-    case miopenDouble:
-        FAIL() << "miopenInt8, miopenBFloat16, miopenInt32, "
-                  "miopenDouble, miopenFloat8, miopenBFloat8 "
-                  "data types not supported by "
-                  "lstm_extra test";
-
-    default: params = ConfigWithFloat::GetParam();
-    }
+    std::vector<std::string> params = ConfigWithFloat_lstm_extra::GetParam();
 
     for(const auto& test_value : params)
     {
@@ -145,6 +130,8 @@ void Run2dDriver(miopenDataType_t prec)
 } // namespace lstm_extra
 using namespace lstm_extra;
 
-TEST_P(ConfigWithFloat, FloatTest_lstm_extra) { Run2dDriver(miopenFloat); };
+TEST_P(ConfigWithFloat_lstm_extra, FloatTest_lstm_extra) { Run2dDriver(miopenFloat); };
 
-INSTANTIATE_TEST_SUITE_P(LstmExtra, ConfigWithFloat, testing::Values(GetTestCases("--float")));
+INSTANTIATE_TEST_SUITE_P(LstmExtra,
+                         ConfigWithFloat_lstm_extra,
+                         testing::Values(GetTestCases("--float")));