[CK] Add command option instance_index and param_mask to run partial ck test (#2889)

* [CK] Add command option instance_index and param_mask to run partial ck test

Many CK test are instance test. it will loop all instance in the instance library. It causes test often out-of-time if we run test on simulator/emulator.
This PR add option instance_index and param_mask to reduce the workload of instance test

instance_index: only run test 1 available instance with specified index.
param_mask: filter the embedded parameter with specified mask

* fix CI error

* fix clang format

---------

Co-authored-by: illsilin_amdeng <Illia.Silin@amd.com>

test/pool/test_avg_pool2d_bwd.cpp

@@ -5,6 +5,9 @@
 #include "profiler/profile_avg_pool2d_bwd_impl.hpp"
 #include "test_pool_fwd_common.hpp"
 
+static ck::index_t param_mask     = 0xffff;
+static ck::index_t instance_index = -1;
+
 template <typename T>
 class AvgPool2dBWDTest : public ::testing::Test
 {
@@ -16,8 +19,13 @@ class AvgPool2dBWDTest : public ::testing::Test
 
     void Run()
     {
-        for(auto param : this->params)
+        for(size_t i = 0; i < this->params.size(); i++)
         {
+            if((param_mask & (1 << i)) == 0)
+            {
+                continue;
+            }
+            auto& param = this->params[i];
             bool success =
                 ck::profiler::profile_avg_pool2d_bwd_impl<InDataType, OutDataType, NHWC, NHWC>(
                     true,
@@ -29,7 +37,8 @@ class AvgPool2dBWDTest : public ::testing::Test
                     param.window_strides_,
                     param.window_dilations_,
                     param.input_left_pads_,
-                    param.input_right_pads_);
+                    param.input_right_pads_,
+                    instance_index);
             EXPECT_TRUE(success);
         }
     }
@@ -131,3 +140,20 @@ TYPED_TEST(AvgPool2D_f16, AvgPool2DTest_f16) { this->Run(); }
 TYPED_TEST(AvgPool2D_bf16, AvgPool2DTest_bf16) { this->Run(); }
 
 TYPED_TEST(AvgPool2D_f8, AvgPool2DTest_f8) { this->Run(); }
+
+int main(int argc, char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    if(argc == 1) {}
+    else if(argc == 3)
+    {
+        param_mask     = strtol(argv[1], nullptr, 0);
+        instance_index = atoi(argv[2]);
+    }
+    else
+    {
+        std::cout << "Usage of " << argv[0] << std::endl;
+        std::cout << "Arg1,2: param_mask instance_index(-1 means all)" << std::endl;
+    }
+    return RUN_ALL_TESTS();
+}

test/pool/test_avg_pool2d_fwd.cpp

@@ -5,6 +5,9 @@
 #include "profiler/profile_pool2d_fwd_impl.hpp"
 #include "test_pool_fwd_common.hpp"
 
+static ck::index_t param_mask     = 0xffff;
+static ck::index_t instance_index = -1;
+
 template <typename Tuple>
 class TestAvgPool2dFwd : public ::testing::Test
 {
@@ -18,8 +21,13 @@ class TestAvgPool2dFwd : public ::testing::Test
 
     void Run()
     {
-        for(auto param : params)
+        for(size_t i = 0; i < this->params.size(); i++)
         {
+            if((param_mask & (1 << i)) == 0)
+            {
+                continue;
+            }
+            auto& param = this->params[i];
             bool success =
                 ck::profiler::profile_pool2d_fwd_impl<InDataType,
                                                       OutDataType,
@@ -38,7 +46,8 @@ class TestAvgPool2dFwd : public ::testing::Test
                                                              param.window_strides_,
                                                              param.window_dilations_,
                                                              param.input_left_pads_,
-                                                             param.input_right_pads_);
+                                                             param.input_right_pads_,
+                                                             instance_index);
             EXPECT_TRUE(success);
         }
     }
@@ -143,3 +152,19 @@ TYPED_TEST(AvgPool2D_F16, AvgPool2D_F16_Test) { this->Run(); }
 TYPED_TEST(AvgPool2D_BF16, AvgPool2D_BF16_Test) { this->Run(); }
 TYPED_TEST(AvgPool2D_I8, AvgPool2D_I8_Test) { this->Run(); }
 TYPED_TEST(AvgPool2D_F8, AvgPool2D_F8_Test) { this->Run(); }
+int main(int argc, char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    if(argc == 1) {}
+    else if(argc == 3)
+    {
+        param_mask     = strtol(argv[1], nullptr, 0);
+        instance_index = atoi(argv[2]);
+    }
+    else
+    {
+        std::cout << "Usage of " << argv[0] << std::endl;
+        std::cout << "Arg1,2: param_mask instance_index(-1 means all)" << std::endl;
+    }
+    return RUN_ALL_TESTS();
+}

test/pool/test_avg_pool3d_bwd.cpp

@@ -5,6 +5,9 @@
 #include "profiler/profile_avg_pool3d_bwd_impl.hpp"
 #include "test_pool_fwd_common.hpp"
 
+static ck::index_t param_mask     = 0xffff;
+static ck::index_t instance_index = -1;
+
 template <typename Tuple>
 class TestAvgPool3dBwd : public ::testing::Test
 {
@@ -19,8 +22,13 @@ class TestAvgPool3dBwd : public ::testing::Test
 
     void Run()
     {
-        for(auto param : params)
+        for(size_t i = 0; i < this->params.size(); i++)
         {
+            if((param_mask & (1 << i)) == 0)
+            {
+                continue;
+            }
+            auto& param = this->params[i];
             bool success =
                 ck::profiler::profile_avg_pool3d_bwd_impl<DOutDataType,
                                                           DInDataType,
@@ -35,7 +43,8 @@ class TestAvgPool3dBwd : public ::testing::Test
                                                                      param.window_strides_,
                                                                      param.window_dilations_,
                                                                      param.input_left_pads_,
-                                                                     param.input_right_pads_);
+                                                                     param.input_right_pads_,
+                                                                     instance_index);
             EXPECT_TRUE(success);
         }
     }
@@ -72,3 +81,19 @@ TYPED_TEST(TestAvgPool3dBwd, Test_Pool)
 
     this->Run();
 }
+int main(int argc, char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    if(argc == 1) {}
+    else if(argc == 3)
+    {
+        param_mask     = strtol(argv[1], nullptr, 0);
+        instance_index = atoi(argv[2]);
+    }
+    else
+    {
+        std::cout << "Usage of " << argv[0] << std::endl;
+        std::cout << "Arg1,2: param_mask instance_index(-1 means all)" << std::endl;
+    }
+    return RUN_ALL_TESTS();
+}

test/pool/test_avg_pool3d_fwd.cpp

@@ -5,6 +5,9 @@
 #include "profiler/profile_pool3d_fwd_impl.hpp"
 #include "test_pool_fwd_common.hpp"
 
+static ck::index_t param_mask     = 0xffff;
+static ck::index_t instance_index = -1;
+
 template <typename Tuple>
 class TestAvgPool3dFwd : public ::testing::Test
 {
@@ -20,8 +23,13 @@ class TestAvgPool3dFwd : public ::testing::Test
 
     void Run()
     {
-        for(auto param : params)
+        for(size_t i = 0; i < this->params.size(); i++)
         {
+            if((param_mask & (1 << i)) == 0)
+            {
+                continue;
+            }
+            auto& param = this->params[i];
             ck::profiler::PoolFwdKernelParams kernel_params{param.length_,
                                                             param.window_spatial_lengths_,
                                                             param.window_strides_,
@@ -38,7 +46,8 @@ class TestAvgPool3dFwd : public ::testing::Test
                                                       ck::tensor_layout::convolution::NDHWC,
                                                       ck::ReduceTensorOp::AVG,
                                                       false,
-                                                      false>(in_params_avg_pool, kernel_params);
+                                                      false>(
+                    in_params_avg_pool, kernel_params, instance_index);
             EXPECT_TRUE(success);
         }
     }
@@ -61,3 +70,19 @@ TYPED_TEST(TestAvgPool3dFwd, Test_Pool)
 
     this->Run();
 }
+int main(int argc, char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    if(argc == 1) {}
+    else if(argc == 3)
+    {
+        param_mask     = strtol(argv[1], nullptr, 0);
+        instance_index = atoi(argv[2]);
+    }
+    else
+    {
+        std::cout << "Usage of " << argv[0] << std::endl;
+        std::cout << "Arg1,2: param_mask instance_index(-1 means all)" << std::endl;
+    }
+    return RUN_ALL_TESTS();
+}

test/pool/test_max_pool2d_bwd.cpp

@@ -5,6 +5,9 @@
 #include "profiler/profile_max_pool2d_bwd_impl.hpp"
 #include "test_pool_fwd_common.hpp"
 
+static ck::index_t param_mask     = 0xffff;
+static ck::index_t instance_index = -1;
+
 template <typename T>
 class MaxPool2dBWDTest : public ::testing::Test
 {
@@ -20,8 +23,13 @@ class MaxPool2dBWDTest : public ::testing::Test
 
     void Run()
     {
-        for(auto param : this->params)
+        for(size_t i = 0; i < this->params.size(); i++)
         {
+            if((param_mask & (1 << i)) == 0)
+            {
+                continue;
+            }
+            auto& param = this->params[i];
             bool success =
                 ck::profiler::profile_max_pool2d_bwd_impl<InDataType,
                                                           OutDataType,
@@ -37,7 +45,8 @@ class MaxPool2dBWDTest : public ::testing::Test
                                                                  param.window_strides_,
                                                                  param.window_dilations_,
                                                                  param.input_left_pads_,
-                                                                 param.input_right_pads_);
+                                                                 param.input_right_pads_,
+                                                                 instance_index);
             EXPECT_TRUE(success);
         }
     }
@@ -137,3 +146,20 @@ TYPED_TEST(MaxPool2D_f16, MaxPool2DTest_f16) { this->Run(); }
 TYPED_TEST(MaxPool2D_bf16, MaxPool2DTest_bf16) { this->Run(); }
 
 TYPED_TEST(MaxPool2D_f8, MaxPool2DTest_f8) { this->Run(); }
+
+int main(int argc, char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    if(argc == 1) {}
+    else if(argc == 3)
+    {
+        param_mask     = strtol(argv[1], nullptr, 0);
+        instance_index = atoi(argv[2]);
+    }
+    else
+    {
+        std::cout << "Usage of " << argv[0] << std::endl;
+        std::cout << "Arg1,2: param_mask instance_index(-1 means all)" << std::endl;
+    }
+    return RUN_ALL_TESTS();
+}

test/pool/test_max_pool2d_fwd.cpp

@@ -5,6 +5,9 @@
 #include "profiler/profile_pool2d_fwd_impl.hpp"
 #include "test_pool_fwd_common.hpp"
 
+static ck::index_t param_mask     = 0xffff;
+static ck::index_t instance_index = -1;
+
 template <typename Tuple>
 class TestMaxPool2dFwd : public ::testing::Test
 {
@@ -19,8 +22,13 @@ class TestMaxPool2dFwd : public ::testing::Test
 
     void Run()
     {
-        for(auto param : params)
+        for(size_t i = 0; i < this->params.size(); i++)
         {
+            if((param_mask & (1 << i)) == 0)
+            {
+                continue;
+            }
+            auto& param = this->params[i];
             // max pool
             bool success =
                 ck::profiler::profile_pool2d_fwd_impl<InDataType,
@@ -40,7 +48,8 @@ class TestMaxPool2dFwd : public ::testing::Test
                                                                    param.window_strides_,
                                                                    param.window_dilations_,
                                                                    param.input_left_pads_,
-                                                                   param.input_right_pads_);
+                                                                   param.input_right_pads_,
+                                                                   instance_index);
             EXPECT_TRUE(success);
         }
     }
@@ -148,3 +157,20 @@ TYPED_TEST(MaxPool2D_F16, MaxPool2D_F16_Test) { this->Run(); }
 TYPED_TEST(MaxPool2D_BF16, MaxPool2D_BF16_Test) { this->Run(); }
 TYPED_TEST(MaxPool2D_I8, MaxPool2D_I8_Test) { this->Run(); }
 TYPED_TEST(MaxPool2D_F8, MaxPool2D_F8_Test) { this->Run(); }
+
+int main(int argc, char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    if(argc == 1) {}
+    else if(argc == 3)
+    {
+        param_mask     = strtol(argv[1], nullptr, 0);
+        instance_index = atoi(argv[2]);
+    }
+    else
+    {
+        std::cout << "Usage of " << argv[0] << std::endl;
+        std::cout << "Arg1,2: param_mask instance_index(-1 means all)" << std::endl;
+    }
+    return RUN_ALL_TESTS();
+}

test/pool/test_max_pool3d_bwd.cpp

@@ -5,6 +5,9 @@
 #include "profiler/profile_max_pool3d_bwd_impl.hpp"
 #include "test_pool_fwd_common.hpp"
 
+static ck::index_t param_mask     = 0xffff;
+static ck::index_t instance_index = -1;
+
 template <typename Tuple>
 class TestMaxPool3dBwd : public ::testing::Test
 {
@@ -20,8 +23,13 @@ class TestMaxPool3dBwd : public ::testing::Test
 
     void Run()
     {
-        for(auto param : params)
+        for(size_t i = 0; i < this->params.size(); i++)
         {
+            if((param_mask & (1 << i)) == 0)
+            {
+                continue;
+            }
+            auto& param = this->params[i];
             bool success =
                 ck::profiler::profile_max_pool3d_bwd_impl<InDataType,
                                                           OutDataType,
@@ -37,7 +45,8 @@ class TestMaxPool3dBwd : public ::testing::Test
                                                                  param.window_strides_,
                                                                  param.window_dilations_,
                                                                  param.input_left_pads_,
-                                                                 param.input_right_pads_);
+                                                                 param.input_right_pads_,
+                                                                 instance_index);
             EXPECT_TRUE(success);
         }
     }
@@ -77,3 +86,20 @@ TYPED_TEST(TestMaxPool3dBwd, Test_Pool)
 
     this->Run();
 }
+
+int main(int argc, char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    if(argc == 1) {}
+    else if(argc == 3)
+    {
+        param_mask     = strtol(argv[1], nullptr, 0);
+        instance_index = atoi(argv[2]);
+    }
+    else
+    {
+        std::cout << "Usage of " << argv[0] << std::endl;
+        std::cout << "Arg1,2: param_mask instance_index(-1 means all)" << std::endl;
+    }
+    return RUN_ALL_TESTS();
+}

test/pool/test_max_pool3d_fwd.cpp

@@ -5,6 +5,9 @@
 #include "profiler/profile_pool3d_fwd_impl.hpp"
 #include "test_pool_fwd_common.hpp"
 
+static ck::index_t param_mask     = 0xffff;
+static ck::index_t instance_index = -1;
+
 template <typename Tuple>
 class TestMaxPool3dFwd : public ::testing::Test
 {
@@ -21,8 +24,14 @@ class TestMaxPool3dFwd : public ::testing::Test
 
     void Run()
     {
-        for(auto param : params)
+        for(size_t i = 0; i < this->params.size(); i++)
         {
+            if((param_mask & (1 << i)) == 0)
+            {
+                continue;
+            }
+            auto& param = this->params[i];
+
             ck::profiler::PoolFwdKernelParams kernel_params{param.length_,
                                                             param.window_spatial_lengths_,
                                                             param.window_strides_,
@@ -40,7 +49,8 @@ class TestMaxPool3dFwd : public ::testing::Test
                                                       ck::tensor_layout::convolution::NDHWC,
                                                       ck::ReduceTensorOp::MAX,
                                                       false,
-                                                      false>(in_params_max_pool, kernel_params);
+                                                      false>(
+                    in_params_max_pool, kernel_params, instance_index);
             EXPECT_TRUE(success);
 
             // max pool + index
@@ -52,8 +62,8 @@ class TestMaxPool3dFwd : public ::testing::Test
                                                             ck::tensor_layout::convolution::NDHWC,
                                                             ck::ReduceTensorOp::MAX,
                                                             false,
-                                                            true>(in_params_max_pool_indexed,
-                                                                  kernel_params);
+                                                            true>(
+                in_params_max_pool_indexed, kernel_params, instance_index);
             EXPECT_TRUE(success);
         }
     }
@@ -76,3 +86,20 @@ TYPED_TEST(TestMaxPool3dFwd, Test_Pool)
 
     this->Run();
 }
+
+int main(int argc, char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    if(argc == 1) {}
+    else if(argc == 3)
+    {
+        param_mask     = strtol(argv[1], nullptr, 0);
+        instance_index = atoi(argv[2]);
+    }
+    else
+    {
+        std::cout << "Usage of " << argv[0] << std::endl;
+        std::cout << "Arg1,2: param_mask instance_index(-1 means all)" << std::endl;
+    }
+    return RUN_ALL_TESTS();
+}