[gtest] Combine gtests into single binary.

test/gtest/CMakeLists.txt

@@ -13,38 +13,45 @@ set(SOURCES
     )
 
 if(MIOPEN_BACKEND_OPENCL)
-  set(SKIP_TESTS dumpTensorTest)
+  set(SKIP_TESTS dumpTensorTest.cpp)
 endif()
 
-function(add_gtest TEST_NAME)
-  if( NOT (TEST_NAME IN_LIST SKIP_TESTS))
-    message("Adding Test: " ${TEST_NAME})
-    add_executable(test_${TEST_NAME} ${TEST_NAME}.cpp  ${SOURCES})
-    add_dependencies(tests test_${TEST_NAME})
-    add_dependencies(check test_${TEST_NAME})
-    target_compile_options(test_${TEST_NAME} PRIVATE -Wno-global-constructors -Wno-undef)
-    target_include_directories(test_${TEST_NAME} PRIVATE ../ ../../src/kernels)
-    if(MIOPEN_ENABLE_AI_KERNEL_TUNING)
-      target_include_directories(test_${TEST_NAME} SYSTEM PRIVATE $<BUILD_INTERFACE:${FDEEP_INCLUDE_DIR}>)
-      target_include_directories(test_${TEST_NAME} SYSTEM PRIVATE $<BUILD_INTERFACE:${EIGEN_INCLUDE_DIR}/eigen3>)
-    endif()
-    target_link_libraries(test_${TEST_NAME} GTest::gtest GTest::gtest_main MIOpen ${Boost_LIBRARIES} hip::host $<BUILD_INTERFACE:roc::rocblas>)
-    if(NOT MIOPEN_EMBED_DB STREQUAL "")
-        target_link_libraries(test_${TEST_NAME} $<BUILD_INTERFACE:miopen_data>)
-    endif()
-    # Enable CMake to discover the test binary
-    gtest_discover_tests(test_${TEST_NAME} 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}")
-
-  endif()
-endfunction()
 
 file(GLOB TESTS *.cpp)
+file(GLOB HEADERS *.hpp)
 # Remove files that do not contain tests
 foreach(SOURCE ${SOURCES})
     list(REMOVE_ITEM TESTS ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE})
 endforeach()
 
+foreach(SOURCE ${SKIP_TESTS})
+    list(REMOVE_ITEM TESTS ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE})
+endforeach()
+
+message("Test files: " ${TESTS})
 foreach(TEST ${TESTS})
-    get_filename_component(BASE_NAME ${TEST} NAME_WE)
-    add_gtest(${BASE_NAME})
+    get_filename_component(BASE_NAME ${TEST} NAME)
+    list(APPEND TESTS_CPP ${BASE_NAME}) 
 endforeach()
+
+
+
+if( NOT (TEST_NAME IN_LIST SKIP_TESTS))
+  message("Adding miopen_gtest: " ${TESTS_CPP})
+  add_executable(miopen_gtest ${TESTS_CPP} ${SOURCES})
+  add_dependencies(tests miopen_gtest)
+  add_dependencies(check miopen_gtest)
+  target_compile_options(miopen_gtest PRIVATE -Wno-global-constructors -Wno-undef)
+  target_include_directories(miopen_gtest PRIVATE ../ ../../src/kernels)
+  if(MIOPEN_ENABLE_AI_KERNEL_TUNING)
+    target_include_directories(miopen_gtest SYSTEM PRIVATE $<BUILD_INTERFACE:${FDEEP_INCLUDE_DIR}>)
+    target_include_directories(miopen_gtest SYSTEM PRIVATE $<BUILD_INTERFACE:${EIGEN_INCLUDE_DIR}/eigen3>)
+  endif()
+  target_link_libraries(miopen_gtest GTest::gtest GTest::gtest_main MIOpen ${Boost_LIBRARIES} hip::host $<BUILD_INTERFACE:roc::rocblas>)
+  if(NOT MIOPEN_EMBED_DB STREQUAL "")
+      target_link_libraries(miopen_gtest $<BUILD_INTERFACE:miopen_data>)
+  endif()
+  # Enable CMake to discover the test binary
+  gtest_discover_tests(miopen_gtest 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}")
+
+endif()

test/gtest/ai_heuristics.hpp

@@ -31,7 +31,7 @@
 
 struct AIModelTestCase
 {
-    struct ConvTestCase conv;
+    struct ConvTestCaseBase conv;
     miopen::conv::Direction direction;
     miopenDataType_t data_type;
     miopenTensorLayout_t layout;

test/gtest/bad_fusion_plan.cpp

@@ -29,6 +29,9 @@
 
 #include "tensor_holder.hpp"
 #include "get_handle.hpp"
+#include "conv_test_base.hpp"
+
+namespace bad_fusion_plan {
 
 #if MIOPEN_BACKEND_HIP
 
@@ -45,16 +48,7 @@ void setEnvironmentVariable(const std::string& name, const std::string& value)
     EXPECT_EQ(ret, 0);
 }
 
-template <typename T>
-miopenDataType_t GetDataType();
-
-template <>
-miopenDataType_t GetDataType<half_float::half>()
-{
-    return miopenHalf;
-}
-
-struct ConvTestCase
+struct ConvTestCaseFusion
 {
     size_t N;
     size_t C;
@@ -69,7 +63,7 @@ struct ConvTestCase
     size_t stride_y;
     size_t dilation_x;
     size_t dilation_y;
-    friend std::ostream& operator<<(std::ostream& os, const ConvTestCase& tc)
+    friend std::ostream& operator<<(std::ostream& os, const ConvTestCaseFusion& tc)
     {
         return os << "(N: " << tc.N << " C:" << tc.C << " H:" << tc.H << " W:" << tc.W
                   << " k: " << tc.k << " y:" << tc.y << " x:" << tc.x << " pad_y:" << tc.pad_y
@@ -88,7 +82,7 @@ struct ConvTestCase
     }
 };
 
-const static ConvTestCase conv_config = {64, 64, 56, 56, 64, 3, 3, 1, 1, 1, 1, 1, 1};
+const static ConvTestCaseFusion conv_config = {64, 64, 56, 56, 64, 3, 3, 1, 1, 1, 1, 1, 1};
 
 template <typename Solver, typename T>
 class TestFusionPlan
@@ -263,3 +257,5 @@ TEST(TestFusionPlan, UnSupportedFusionPlanDuringSearchMode)
 }
 
 #endif
+
+} // namespace bad_fusion_plan

test/gtest/bn_bwd.cpp

@@ -54,20 +54,20 @@ TEST_P(BNBwdTestDouble, DISABLED_BnBwdCKDouble) {}
 
 INSTANTIATE_TEST_SUITE_P(BNBwdTestTestHalfNHWCSuite,
                          BNBwdTestTestHalf,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNBwdTestFloatNHWCSuite,
                          BNBwdTestFloat,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNBwdTestBFloat16NHWCSuite,
                          BNBwdTestBFloat16,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNBwdTestDoubleNHWCSuite,
                          BNBwdTestDouble,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));

test/gtest/bn_fwd_train.cpp

@@ -54,20 +54,20 @@ TEST_P(BNFwdTrainTestBFloat16, DISABLED_BnFwdTrainCKBFloat16) {}
 
 INSTANTIATE_TEST_SUITE_P(BNFwdTrainTestHalfNHWCSuite,
                          BNFwdTrainTestHalf,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNFwdTrainTestFloatNHWCSuite,
                          BNFwdTrainTestFloat,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNFwdTrainTestFloatNHWCSuite,
                          BNFwdTrainTestDouble,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNFwdTrainTestFloatNHWCSuite,
                          BNFwdTrainTestBFloat16,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));

test/gtest/bn_infer.cpp

@@ -54,20 +54,20 @@ TEST_P(BNInferTestBFloat16, DISABLED_BnInferCKBFloat16) {}
 
 INSTANTIATE_TEST_SUITE_P(BNInferTestHalfNHWCSuite,
                          BNInferTestHalf,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNInferTestFloatNHWCSuite,
                          BNInferTestFloat,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNInferTestFloatNHWCSuite,
                          BNInferTestDouble,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNInferTestFloatNHWCSuite,
                          BNInferTestBFloat16,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));

test/gtest/bn_test_data.hpp

@@ -55,7 +55,11 @@ struct BNTestCase
     std::vector<size_t> GetInput() const { return {N, C, H, W}; }
 };
 
-std::vector<BNTestCase> Network1()
+template <typename T>
+std::vector<T> Network1();
+
+template <>
+inline std::vector<BNTestCase> Network1()
 {
     // pyt_mlperf_resnet50v1.5
     return {

test/gtest/cba.hpp

@@ -43,7 +43,7 @@
 template <typename T = float>
 struct ConvBiasActivInferTest
     : public ::testing::TestWithParam<
-          std::tuple<miopenActivationMode_t, ConvTestCase, miopenTensorLayout_t>>,
+          std::tuple<miopenActivationMode_t, ConvTestCaseBase, miopenTensorLayout_t>>,
       ConvFwdSolverTestBase<T>
 {
 protected:
@@ -90,7 +90,7 @@ struct ConvBiasActivInferTest
                             cfsb::ref_out.data);
         cfsb::ThresholdChecks();
     }
-    ConvTestCase conv_config;
+    ConvTestCaseBase conv_config;
     miopen::ActivationDescriptor activ_desc;
     tensor<T> bias;
     miopen::Allocator::ManageDataPtr bias_dev;

test/gtest/cba_find2.hpp

@@ -45,11 +45,11 @@
 template <typename T = float>
 struct ConvBiasActivInferFind2Test
     : public ::testing::TestWithParam<
-          std::tuple<miopenActivationMode_t, ConvTestCase, miopenTensorLayout_t>>,
+          std::tuple<miopenActivationMode_t, ConvTestCaseBase, miopenTensorLayout_t>>,
       ConvFwdSolverTestBase<T>
 {
 protected:
-    ConvTestCase conv_config;
+    ConvTestCaseBase conv_config;
     miopen::ActivationDescriptor activ_desc;
     tensor<T> bias;
     miopen::Allocator::ManageDataPtr bias_dev;

test/gtest/cba_find2_infer.cpp

@@ -38,6 +38,8 @@
 #include "get_handle.hpp"
 #include "cba_find2.hpp"
 
+namespace cba_find2_infer {
+
 struct ConvBiasActivFind2InferTestFloat : ConvBiasActivInferFind2Test<float>
 {
 };
@@ -78,7 +80,7 @@ void RunSolver(miopen::FusedProblem& problem,
 template <typename Solver>
 void RunTunableSolver(miopen::FusedProblem& problem,
                       const miopen::AnyInvokeParams& invoke_ctx,
-                      const ConvTestCase& conv_config,
+                      const ConvTestCaseBase& conv_config,
                       bool& test_skipped)
 {
     auto& handle = get_handle();
@@ -153,22 +155,25 @@ TEST_P(ConvBiasActivFind2InferTestFloatFusionFind, ConvBiasActivFind2Float_testF
     }
 }
 
-INSTANTIATE_TEST_SUITE_P(CBAFind2InferSolverTest,
-                         ConvBiasActivFind2InferTestFloatFusionFind,
-                         testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetworkForFusionCompileStepTest()),
-                                          testing::Values(miopenTensorNCHW)));
+INSTANTIATE_TEST_SUITE_P(
+    CBAFind2InferSolverTest,
+    ConvBiasActivFind2InferTestFloatFusionFind,
+    testing::Combine(testing::Values(miopenActivationRELU),
+                     testing::ValuesIn(GetNetworkForFusionCompileStepTest<ConvTestCaseBase>()),
+                     testing::Values(miopenTensorNCHW)));
 
 #endif
 
 INSTANTIATE_TEST_SUITE_P(CBAFind2InferSolverTest,
                          ConvBiasActivFind2InferTestFloat,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNCHW)));
 
 INSTANTIATE_TEST_SUITE_P(CBAFind2InferSolverTest,
                          ConvBiasActivFind2InferTestHalf,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNHWC)));
+
+} // namespace cba_find2_infer

test/gtest/cba_infer.cpp

@@ -36,6 +36,8 @@
 #include "get_handle.hpp"
 #include "cba.hpp"
 
+namespace cba_infer {
+
 struct ConvBiasActivInferTestFloat : ConvBiasActivInferTest<float>
 {
 };
@@ -87,7 +89,7 @@ void RunSolver(miopen::FusionPlanDescriptor& fusePlanDesc,
 template <typename Solver>
 void RunTunableSolver(miopen::FusionPlanDescriptor& fusePlanDesc,
                       const std::unique_ptr<miopen::fusion::FusionInvokeParams>& plan_params,
-                      const ConvTestCase& conv_config,
+                      const ConvTestCaseBase& conv_config,
                       bool& test_skipped)
 {
     auto& handle = get_handle();
@@ -158,22 +160,25 @@ TEST_P(ConvBiasActivInferTestFloatFusionCompileStep, ConvBiasActivAsm1x1UFloat_t
         fusePlanDesc, plan_params, conv_config, test_skipped);
 }
 
-INSTANTIATE_TEST_SUITE_P(CBAInferSolverTest,
-                         ConvBiasActivInferTestFloatFusionCompileStep,
-                         testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetworkForFusionCompileStepTest()),
-                                          testing::Values(miopenTensorNCHW)));
+INSTANTIATE_TEST_SUITE_P(
+    CBAInferSolverTest,
+    ConvBiasActivInferTestFloatFusionCompileStep,
+    testing::Combine(testing::Values(miopenActivationRELU),
+                     testing::ValuesIn(GetNetworkForFusionCompileStepTest<ConvTestCaseBase>()),
+                     testing::Values(miopenTensorNCHW)));
 
 #endif
 
 INSTANTIATE_TEST_SUITE_P(CBAInferSolverTest,
                          ConvBiasActivInferTestFloat,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNCHW)));
 
 INSTANTIATE_TEST_SUITE_P(CBAInferSolverTest,
                          ConvBiasActivInferTestHalf,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNHWC)));
+
+} // namespace cba_infer

test/gtest/conv3d_test_case.hpp

@@ -32,27 +32,7 @@
 
 #include "../driver/tensor_driver.hpp"
 #include "conv_common.hpp"
-
-template <typename T>
-miopenDataType_t GetDataType();
-
-template <>
-miopenDataType_t GetDataType<float>()
-{
-    return miopenFloat;
-}
-
-template <>
-miopenDataType_t GetDataType<half_float::half>()
-{
-    return miopenHalf;
-}
-
-template <>
-miopenDataType_t GetDataType<int8_t>()
-{
-    return miopenInt8;
-}
+#include "conv_test_base.hpp"
 
 struct Conv3DTestCase
 {