Common forward convolution utility refactor. (#141)

* Convolution ND

* Code unification across dimensions for generating tensor descriptors.
* Example
* Instances

* Move convnd f32 instance file to comply with repo structure.

* Conv 1D tensor layouts.

* Formatting and use ReferenceConv

* Reference ConvFwd supporting 1D and 2D convolution.

* Debug printing TensorLayout name.

* Conv fwd 1D instance f32

* Refactor conv ND example.

Needed to support various conv dimensio.

Needed to support various conv dimensions

* Rename conv nd example director to prevent conflicts.

* Refactor some common utility to single file.

Plus some tests.

* Refactor GetHostTensorDescriptor + UT.

* Add 1D test case.

* Test reference convolution 1d/2d

* Remove some leftovers.

* Fix convolution example error for 1D

* Refactor test check errors utility function.

* Test Conv2D Fwd XDL

* More UT for 1D case.

* Parameterize input & weight initializers.

* Rename example to prevent conflicts.

* Split convnd instance into separate files for 1d/2d

* Address review comments.

* Fix data type for flops/gbytes calculations.

* Assign example number 11.

* 3D cases for convolution utility functions.

* 3D reference convolution.

* Add support for 3D convolution.

* Check for inputs bigger than  2GB.

* Formatting

* Support for bf16/f16/f32/i8 - conv instances + UT.

* Use check_err from test_util.hpp.

* Split convnd test into separate files for each dim.

* Fix data generation and use proper instances.

* Formatting

* Skip tensor initialization if not necessary.

* Fix CMakefiles.

* Remove redundant conv2d_fwd test.

* Lower problem size for conv3D UT.

* 3D case for convnd example.

* Remove leftovers after merge.

* Add Conv Specialization string to GetTypeString

* Skip instance causing numerical errors.

* Small fixes.

* Remove redundant includes.

* Fix namespace name error.

* Script for automatic testing and logging convolution fwd UTs

* Comment out numactl cmd.

* Refine weights initalization and relax rtol for fp16

* Move test_util.hpp to check_err.hpp

* Refine weights initalization and relax rtol for fp16

* Refactor common part of test conv utils.

* Move utility function to single common place.

* Add additional common functions to utility.

* Refactor convnd_fwd_xdl examples.

* Remove redundant files.
* Unify structure.

* Add constructor to ConvParams.

* And add input parameters validation.

* Modify conv examples to use single utility file.

* Remove check_error from host_tensor.hpp

* Get rid of check_indices function.

* Remove bf16_to_f32 function overload for scalars.

* Fix namespace.

* Add half_float::half for check_err.

* Fix conv params size in UT.

* Fix weights initialization for int8.

* Fix weights initialization for int8.

* Add type_convert when store output in ref conv 1D.

* Get back old conv2d_fwd_xdl operation.

* Silence conv debug print.

* format

* clean

* clean

* Fix merge.

* Fix namespace for check_err

* Formatting.

* Fix merge artifacts.

* Remove deleted header.

* Fix some includes and use ck::utils::check_err.

* Remove unused check_indices restored by previous merge.

* Fix namespaces after merge.

* Fix compilation error.

* Small fixes.

* Use common functions.
* Fix filename
* Fix namespaces.

* Fix merge artifact - retrieve removed by accident fun.

* Fix ConvForwardSpecialization.

* Adhere to coding style rules.

* Fix merge artifacts.
Co-authored-by: Adam Osewski <aosewski@amd.com>
Co-authored-by: Chao Liu <chao.liu2@amd.com>

test/convnd_fwd/conv1d_fwd.cpp

@@ -5,10 +5,11 @@
 
 #include "data_type.hpp"
 #include "element_wise_operation.hpp"
-#include "conv_test_util.hpp"
+#include "conv_fwd_util.hpp"
+#include "conv_util.hpp"
 #include "host_tensor.hpp"
 #include "tensor_layout.hpp"
-#include "test_util.hpp"
+#include "check_err.hpp"
 
 // Forward declarations for conv instances.
 
@@ -34,10 +35,10 @@ void add_device_conv1d_fwd_xdl_nwc_kxc_nwk_int8_instances(std::vector<DeviceConv
 
 namespace {
 
-bool TestConv1DNWC()
+bool test_conv1D_nwc()
 {
     bool res{true};
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.num_dim_spatial        = 1;
     params.N                      = 2;
     params.K                      = 16;
@@ -49,7 +50,8 @@ bool TestConv1DNWC()
     params.input_left_pads        = std::vector<ck::index_t>{1};
     params.input_right_pads       = std::vector<ck::index_t>{1};
 
-    auto host_tensors            = test::conv::GetHostTensors<float,
+    auto host_tensors =
+        ck::utils::conv::get_host_tensors<float,
                                           float,
                                           float,
                                           ck::tensor_layout::convolution::NWC,
@@ -60,19 +62,19 @@ bool TestConv1DNWC()
     Tensor<float>& host_output   = std::get<2>(host_tensors);
     Tensor<float>& device_output = std::get<3>(host_tensors);
 
-    test::conv::RunReferenceConv<1>(params, input, weights, host_output);
+    ck::utils::conv::run_reference_convolution_forward<1>(params, input, weights, host_output);
     test::conv::RunConv<1>(params, input, weights, device_output);
     res = res &&
-          test::check_err(
+          ck::utils::check_err(
               device_output.mData, host_output.mData, "Error: incorrect results!", 1e-5f, 1e-4f);
 
     return res;
 }
 
 template <typename T>
-bool TestConv1DNWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
+bool test_conv1d_nwc_instances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
 {
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.num_dim_spatial        = 1;
     params.filter_spatial_lengths = std::vector<ck::index_t>{3};
     params.input_spatial_lengths  = std::vector<ck::index_t>{71};
@@ -81,7 +83,8 @@ bool TestConv1DNWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
     params.input_left_pads        = std::vector<ck::index_t>{1};
     params.input_right_pads       = std::vector<ck::index_t>{1};
 
-    auto host_tensors        = test::conv::GetHostTensors<T,
+    auto host_tensors =
+        ck::utils::conv::get_host_tensors<T,
                                           T,
                                           T,
                                           ck::tensor_layout::convolution::NWC,
@@ -92,40 +95,40 @@ bool TestConv1DNWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
     Tensor<T>& host_output   = std::get<2>(host_tensors);
     Tensor<T>& device_output = std::get<3>(host_tensors);
 
-    test::conv::RunReferenceConv<1>(params, input, weights, host_output);
-    return test::conv::RunConvInstances<1>(
+    ck::utils::conv::run_reference_convolution_forward<1>(params, input, weights, host_output);
+    return ck::utils::conv::run_convolution_forward_instances<1>(
         params, conv_ptrs, input, weights, device_output, host_output);
 }
-bool TestConv1DNWCBF16Instances()
+bool test_conv1d_nwc_bf16_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv1d_fwd_instance::
         add_device_conv1d_fwd_xdl_nwc_kxc_nwk_bf16_instances(conv_ptrs);
-    return TestConv1DNWCInstances<ck::bhalf_t>(conv_ptrs);
+    return test_conv1d_nwc_instances<ck::bhalf_t>(conv_ptrs);
 }
 
-bool TestConv1DNWCF16Instances()
+bool test_conv1d_nwc_f16_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv1d_fwd_instance::
         add_device_conv1d_fwd_xdl_nwc_kxc_nwk_f16_instances(conv_ptrs);
-    return TestConv1DNWCInstances<ck::half_t>(conv_ptrs);
+    return test_conv1d_nwc_instances<ck::half_t>(conv_ptrs);
 }
 
-bool TestConv1DNWCF32Instances()
+bool test_conv1d_nwc_f32_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv1d_fwd_instance::
         add_device_conv1d_fwd_xdl_nwc_kxc_nwk_f32_instances(conv_ptrs);
-    return TestConv1DNWCInstances<float>(conv_ptrs);
+    return test_conv1d_nwc_instances<float>(conv_ptrs);
 }
 
-bool TestConv1DNWCInt8Instances()
+bool test_conv1d_nwc_int8_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv1d_fwd_instance::
         add_device_conv1d_fwd_xdl_nwc_kxc_nwk_int8_instances(conv_ptrs);
-    return TestConv1DNWCInstances<int8_t>(conv_ptrs);
+    return test_conv1d_nwc_instances<int8_t>(conv_ptrs);
 }
 
 } // anonymous namespace
@@ -133,18 +136,20 @@ bool TestConv1DNWCInt8Instances()
 int main()
 {
     bool res{true};
-    res = TestConv1DNWC();
-    std::cout << "TestConv1DNWC ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
+    res = test_conv1D_nwc();
+    std::cout << "test_conv1D_nwc ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
 
-    res = TestConv1DNWCBF16Instances();
+    res = test_conv1d_nwc_bf16_instances();
     std::cout << "\nTestConv1DNWCBF16Instances ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
-    res = TestConv1DNWCF16Instances();
-    std::cout << "\nTestConv1DNWCF16Instances ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
-    res = TestConv1DNWCF32Instances();
-    std::cout << "\nTestConv1DNWCF32Instances ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
-    res = TestConv1DNWCInt8Instances();
-    std::cout << "\nTestConv1DNWCInt8Instances ..... " << (res ? "SUCCESS" : "FAILURE")
+    res = test_conv1d_nwc_f16_instances();
+    std::cout << "\ntest_conv1d_nwc_f16_instances ..... " << (res ? "SUCCESS" : "FAILURE")
+              << std::endl;
+    res = test_conv1d_nwc_f32_instances();
+    std::cout << "\ntest_conv1d_nwc_f32_instances ..... " << (res ? "SUCCESS" : "FAILURE")
+              << std::endl;
+    res = test_conv1d_nwc_int8_instances();
+    std::cout << "\ntes_tconv1_dnw_cint_8instances ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
 
     return res ? 0 : 1;

test/convnd_fwd/conv2d_fwd.cpp

@@ -6,10 +6,11 @@
 
 #include "data_type.hpp"
 #include "element_wise_operation.hpp"
-#include "conv_test_util.hpp"
+#include "conv_fwd_util.hpp"
+#include "conv_util.hpp"
 #include "host_tensor.hpp"
 #include "tensor_layout.hpp"
-#include "test_util.hpp"
+#include "check_err.hpp"
 
 // Forward declarations for conv instances.
 using DeviceConvFwdNoOpPtr =
@@ -36,35 +37,35 @@ void add_device_conv2d_fwd_xdl_nhwc_kyxc_nhwk_int8_instances(std::vector<DeviceC
 
 namespace {
 
-bool TestConv2DNHWC()
+bool test_conv2d_nhwc()
 {
     bool res{true};
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.N                     = 2;
     params.K                     = 16;
     params.C                     = 4;
     params.input_spatial_lengths = std::vector<ck::index_t>{16, 16};
     params.conv_filter_strides   = std::vector<ck::index_t>{1, 1};
 
-    auto host_tensors            = test::conv::GetHostTensors(params);
+    auto host_tensors            = ck::utils::conv::get_host_tensors(params);
     const Tensor<float>& input   = std::get<0>(host_tensors);
     const Tensor<float>& weights = std::get<1>(host_tensors);
     Tensor<float>& host_output   = std::get<2>(host_tensors);
     Tensor<float>& device_output = std::get<3>(host_tensors);
 
-    test::conv::RunReferenceConv<2>(params, input, weights, host_output);
+    ck::utils::conv::run_reference_convolution_forward<2>(params, input, weights, host_output);
     test::conv::RunConv<2>(params, input, weights, device_output);
     res = res &&
-          test::check_err(
+          ck::utils::check_err(
               device_output.mData, host_output.mData, "Error: incorrect results!", 1e-5f, 1e-4f);
 
     return res;
 }
 
 template <typename T>
-bool TestConv2DNHWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
+bool test_conv2d_nhwc_instances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
 {
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.num_dim_spatial        = 2;
     params.filter_spatial_lengths = std::vector<ck::index_t>{3, 3};
     params.input_spatial_lengths  = std::vector<ck::index_t>{71, 71};
@@ -73,7 +74,8 @@ bool TestConv2DNHWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
     params.input_left_pads        = std::vector<ck::index_t>{1, 1};
     params.input_right_pads       = std::vector<ck::index_t>{1, 1};
 
-    auto host_tensors        = test::conv::GetHostTensors<T,
+    auto host_tensors =
+        ck::utils::conv::get_host_tensors<T,
                                           T,
                                           T,
                                           ck::tensor_layout::convolution::NHWC,
@@ -84,43 +86,43 @@ bool TestConv2DNHWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
     Tensor<T>& host_output   = std::get<2>(host_tensors);
     Tensor<T>& device_output = std::get<3>(host_tensors);
 
-    test::conv::RunReferenceConv<2>(params, input, weights, host_output);
-    return test::conv::RunConvInstances<2>(
+    ck::utils::conv::run_reference_convolution_forward<2>(params, input, weights, host_output);
+    return ck::utils::conv::run_convolution_forward_instances<2>(
         params, conv_ptrs, input, weights, device_output, host_output);
 }
 
-bool TestConv2DNHWCBF16Instances()
+bool test_conv2d_nhwc_bf16_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv2d_fwd_instance::
         add_device_conv2d_fwd_xdl_nhwc_kyxc_nhwk_bf16_instances(conv_ptrs);
-    return TestConv2DNHWCInstances<ck::bhalf_t>(conv_ptrs);
+    return test_conv2d_nhwc_instances<ck::bhalf_t>(conv_ptrs);
 }
 
-bool TestConv2DNHWCF16Instances()
+bool test_conv2d_nhwc_f16_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv2d_fwd_instance::
         add_device_conv2d_fwd_xdl_nhwc_kyxc_nhwk_f16_instances(conv_ptrs);
     ck::tensor_operation::device::device_conv2d_fwd_instance::
         add_device_conv2d_fwd_xdl_c_shuffle_nhwc_kyxc_nhwk_f16_instances(conv_ptrs);
-    return TestConv2DNHWCInstances<ck::half_t>(conv_ptrs);
+    return test_conv2d_nhwc_instances<ck::half_t>(conv_ptrs);
 }
 
-bool TestConv2DNHWCF32Instances()
+bool test_conv2d_nhwc_f32_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv2d_fwd_instance::
         add_device_conv2d_fwd_xdl_nhwc_kyxc_nhwk_f32_instances(conv_ptrs);
-    return TestConv2DNHWCInstances<float>(conv_ptrs);
+    return test_conv2d_nhwc_instances<float>(conv_ptrs);
 }
 
-bool TestConv2DNHWCInt8Instances()
+bool test_conv2d_nhwc_int8_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv2d_fwd_instance::
         add_device_conv2d_fwd_xdl_nhwc_kyxc_nhwk_int8_instances(conv_ptrs);
-    return TestConv2DNHWCInstances<int8_t>(conv_ptrs);
+    return test_conv2d_nhwc_instances<int8_t>(conv_ptrs);
 }
 
 } // anonymous namespace
@@ -128,19 +130,20 @@ bool TestConv2DNHWCInt8Instances()
 int main()
 {
     bool res{true};
-    res = TestConv2DNHWC();
-    std::cout << "TestConv2DNHWC ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
+    res = test_conv2d_nhwc();
+    std::cout << "test_conv2d_nhwc ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
 
-    res = TestConv2DNHWCBF16Instances();
-    std::cout << "\nTestConv2DNHWCBF16Instances ..... " << (res ? "SUCCESS" : "FAILURE")
+    res = test_conv2d_nhwc_bf16_instances();
+    std::cout << "\ntest_conv2d_nhwc_bf16_instances ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
-    res = TestConv2DNHWCF16Instances();
-    std::cout << "\nTestConv2DNHWCF16Instances ....." << (res ? "SUCCESS" : "FAILURE") << std::endl;
-    res = TestConv2DNHWCF32Instances();
-    std::cout << "\nTestConv2DNHWCF32Instances ..... " << (res ? "SUCCESS" : "FAILURE")
+    res = test_conv2d_nhwc_f16_instances();
+    std::cout << "\ntest_conv2d_nhwc_f16_instances ....." << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
-    res = TestConv2DNHWCInt8Instances();
-    std::cout << "\nTestConv2DNHWCInt8Instances ..... " << (res ? "SUCCESS" : "FAILURE")
+    res = test_conv2d_nhwc_f32_instances();
+    std::cout << "\ntest_conv2d_nhwc_f32_instances ..... " << (res ? "SUCCESS" : "FAILURE")
+              << std::endl;
+    res = test_conv2d_nhwc_int8_instances();
+    std::cout << "\ntest_conv2d_nhwc_int8_instances ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
 
     return res ? 0 : 1;

test/convnd_fwd/conv3d_fwd.cpp

@@ -6,10 +6,11 @@
 
 #include "data_type.hpp"
 #include "element_wise_operation.hpp"
-#include "conv_test_util.hpp"
+#include "conv_fwd_util.hpp"
+#include "conv_util.hpp"
 #include "host_tensor.hpp"
 #include "tensor_layout.hpp"
-#include "test_util.hpp"
+#include "check_err.hpp"
 
 // Forward declarations for conv instances.
 using DeviceConvFwdNoOpPtr =
@@ -34,10 +35,10 @@ void add_device_conv3d_fwd_xdl_ndhwc_kzyxc_ndhwk_int8_instances(std::vector<Devi
 
 namespace {
 
-bool TestConv3DNDHWC()
+bool test_conv3d_ndhwc()
 {
     bool res{true};
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.num_dim_spatial        = 3;
     params.N                      = 2;
     params.K                      = 16;
@@ -49,7 +50,8 @@ bool TestConv3DNDHWC()
     params.input_left_pads        = std::vector<ck::index_t>{1, 1, 1};
     params.input_right_pads       = std::vector<ck::index_t>{1, 1, 1};
 
-    auto host_tensors            = test::conv::GetHostTensors<float,
+    auto host_tensors =
+        ck::utils::conv::get_host_tensors<float,
                                           float,
                                           float,
                                           ck::tensor_layout::convolution::NDHWC,
@@ -60,19 +62,19 @@ bool TestConv3DNDHWC()
     Tensor<float>& host_output   = std::get<2>(host_tensors);
     Tensor<float>& device_output = std::get<3>(host_tensors);
 
-    test::conv::RunReferenceConv<3>(params, input, weights, host_output);
+    ck::utils::conv::run_reference_convolution_forward<3>(params, input, weights, host_output);
     test::conv::RunConv<3>(params, input, weights, device_output);
     res = res &&
-          test::check_err(
+          ck::utils::check_err(
               device_output.mData, host_output.mData, "Error: incorrect results!", 1e-5f, 1e-4f);
 
     return res;
 }
 
-bool TestConv3DNDHWC2GBInput()
+bool test_conv3d_ndhwc_2gb_input()
 {
     // >2GB Input
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.num_dim_spatial        = 3;
     params.N                      = 2;
     params.K                      = 16;
@@ -85,7 +87,7 @@ bool TestConv3DNDHWC2GBInput()
     params.input_right_pads       = std::vector<ck::index_t>{1, 1, 1};
 
     auto host_tensors =
-        test::conv::GetHostTensors<float,
+        ck::utils::conv::get_host_tensors<float,
                                           float,
                                           float,
                                           ck::tensor_layout::convolution::NDHWC,
@@ -113,10 +115,10 @@ bool TestConv3DNDHWC2GBInput()
     return false;
 }
 
-bool TestConv3DNDHWC2GBFilters()
+bool test_conv3d_ndhwc_2gb_filters()
 {
     // >2GB Filters
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.num_dim_spatial        = 3;
     params.N                      = 2;
     params.K                      = 16;
@@ -129,7 +131,7 @@ bool TestConv3DNDHWC2GBFilters()
     params.input_right_pads       = std::vector<ck::index_t>{1, 1, 1};
 
     auto host_tensors =
-        test::conv::GetHostTensors<float,
+        ck::utils::conv::get_host_tensors<float,
                                           float,
                                           float,
                                           ck::tensor_layout::convolution::NDHWC,
@@ -157,10 +159,10 @@ bool TestConv3DNDHWC2GBFilters()
     return false;
 }
 
-bool TestConv3DNDHWC2GBOutput()
+bool test_conv3d_ndhwc_2gb_output()
 {
     // >2GB Output
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.num_dim_spatial        = 3;
     params.N                      = 2;
     params.K                      = 16;
@@ -173,7 +175,7 @@ bool TestConv3DNDHWC2GBOutput()
     params.input_right_pads       = std::vector<ck::index_t>{2, 2, 2};
 
     auto host_tensors =
-        test::conv::GetHostTensors<float,
+        ck::utils::conv::get_host_tensors<float,
                                           float,
                                           float,
                                           ck::tensor_layout::convolution::NDHWC,
@@ -202,9 +204,9 @@ bool TestConv3DNDHWC2GBOutput()
 }
 
 template <typename T>
-bool TestConv3DNDHWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
+bool test_conv3d_ndhwc_instances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs)
 {
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
     params.N                      = 64;
     params.num_dim_spatial        = 3;
     params.filter_spatial_lengths = std::vector<ck::index_t>{3, 3, 2};
@@ -214,7 +216,8 @@ bool TestConv3DNDHWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs
     params.input_left_pads        = std::vector<ck::index_t>{1, 1, 1};
     params.input_right_pads       = std::vector<ck::index_t>{1, 1, 1};
 
-    auto host_tensors        = test::conv::GetHostTensors<T,
+    auto host_tensors =
+        ck::utils::conv::get_host_tensors<T,
                                           T,
                                           T,
                                           ck::tensor_layout::convolution::NDHWC,
@@ -225,41 +228,41 @@ bool TestConv3DNDHWCInstances(const std::vector<DeviceConvFwdNoOpPtr>& conv_ptrs
     Tensor<T>& host_output   = std::get<2>(host_tensors);
     Tensor<T>& device_output = std::get<3>(host_tensors);
 
-    test::conv::RunReferenceConv<3>(params, input, weights, host_output);
-    return test::conv::RunConvInstances<3>(
+    ck::utils::conv::run_reference_convolution_forward<3>(params, input, weights, host_output);
+    return ck::utils::conv::run_convolution_forward_instances<3>(
         params, conv_ptrs, input, weights, device_output, host_output);
 }
 
-bool TestConv3DNDHWCBF16Instances()
+bool test_conv3d_ndhwc_bf16_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv3d_fwd_instance::
         add_device_conv3d_fwd_xdl_ndhwc_kzyxc_ndhwk_bf16_instances(conv_ptrs);
-    return TestConv3DNDHWCInstances<ck::bhalf_t>(conv_ptrs);
+    return test_conv3d_ndhwc_instances<ck::bhalf_t>(conv_ptrs);
 }
 
-bool TestConv3DNDHWCF16Instances()
+bool test_conv3d_ndhwc_f16_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv3d_fwd_instance::
         add_device_conv3d_fwd_xdl_ndhwc_kzyxc_ndhwk_f16_instances(conv_ptrs);
-    return TestConv3DNDHWCInstances<ck::half_t>(conv_ptrs);
+    return test_conv3d_ndhwc_instances<ck::half_t>(conv_ptrs);
 }
 
-bool TestConv3DNDHWCF32Instances()
+bool test_conv3d_ndhwc_f32_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv3d_fwd_instance::
         add_device_conv3d_fwd_xdl_ndhwc_kzyxc_ndhwk_f32_instances(conv_ptrs);
-    return TestConv3DNDHWCInstances<float>(conv_ptrs);
+    return test_conv3d_ndhwc_instances<float>(conv_ptrs);
 }
 
-bool TestConv3DNDHWCInt8Instances()
+bool test_conv3d_ndhwc_int8_instances()
 {
     std::vector<DeviceConvFwdNoOpPtr> conv_ptrs;
     ck::tensor_operation::device::device_conv3d_fwd_instance::
         add_device_conv3d_fwd_xdl_ndhwc_kzyxc_ndhwk_int8_instances(conv_ptrs);
-    return TestConv3DNDHWCInstances<int8_t>(conv_ptrs);
+    return test_conv3d_ndhwc_instances<int8_t>(conv_ptrs);
 }
 
 } // anonymous namespace
@@ -267,27 +270,30 @@ bool TestConv3DNDHWCInt8Instances()
 int main()
 {
     bool res{true};
-    res = TestConv3DNDHWC();
-    std::cout << "TestConv3DNDHWC ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
+    res = test_conv3d_ndhwc();
+    std::cout << "test_conv3d_ndhwc ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
 
-    res = TestConv3DNDHWC2GBInput();
-    std::cout << "\nTestConv3DNDHWC2GBInput ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
-    res = TestConv3DNDHWC2GBFilters();
-    std::cout << "\nTestConv3DNDHWC2GBFilters ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
-    res = TestConv3DNDHWC2GBOutput();
-    std::cout << "\nTestConv3DNDHWC2GBOutput ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
+    res = test_conv3d_ndhwc_2gb_input();
+    std::cout << "\ntest_conv3d_ndhwc_2gb_input ..... " << (res ? "SUCCESS" : "FAILURE")
+              << std::endl;
+    res = test_conv3d_ndhwc_2gb_filters();
+    std::cout << "\ntest_conv3d_ndhwc_2gb_filters ..... " << (res ? "SUCCESS" : "FAILURE")
+              << std::endl;
+    res = test_conv3d_ndhwc_2gb_output();
+    std::cout << "\ntest_conv3d_ndhwc_2gb_output ..... " << (res ? "SUCCESS" : "FAILURE")
+              << std::endl;
 
-    res = TestConv3DNDHWCBF16Instances();
-    std::cout << "\nTestConv3DNDHWCBF16Instances ..... " << (res ? "SUCCESS" : "FAILURE")
+    res = test_conv3d_ndhwc_bf16_instances();
+    std::cout << "\ntest_conv3d_ndhwc_bf16_instances ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
-    res = TestConv3DNDHWCF16Instances();
-    std::cout << "\nTestConv3DNDHWCF16Instances ..... " << (res ? "SUCCESS" : "FAILURE")
+    res = test_conv3d_ndhwc_f16_instances();
+    std::cout << "\ntest_conv3d_ndhwc_f16_instances ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
-    res = TestConv3DNDHWCF32Instances();
-    std::cout << "\nTestConv3DNDHWCF32Instances ..... " << (res ? "SUCCESS" : "FAILURE")
+    res = test_conv3d_ndhwc_f32_instances();
+    std::cout << "\ntest_conv3d_ndhwc_f32_instances ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
-    res = TestConv3DNDHWCInt8Instances();
-    std::cout << "\nTestConv3DNDHWCInt8Instances ..... " << (res ? "SUCCESS" : "FAILURE")
+    res = test_conv3d_ndhwc_int8_instances();
+    std::cout << "\ntest_conv3d_ndhw_cint_8instances ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
 
     return res ? 0 : 1;

test/convnd_fwd/conv_util.hpp

+#ifndef TEST_CONV_UTIL_HPP
+#define TEST_CONV_UTIL_HPP
+
+#include <tuple>
+
+#include "config.hpp"
+#include "conv_fwd_util.hpp"
+#include "device_convnd_fwd_xdl_nhwc_kyxc_nhwk.hpp"
+#include "element_wise_operation.hpp"
+#include "host_tensor.hpp"
+#include "sequence.hpp"
+
+namespace {
+
+template <ck::index_t... Is>
+using S = ck::Sequence<Is...>;
+
+using InElementOp  = ck::tensor_operation::element_wise::PassThrough;
+using WeiElementOp = ck::tensor_operation::element_wise::PassThrough;
+using OutElementOp = ck::tensor_operation::element_wise::PassThrough;
+
+static constexpr auto ConvFwdDefault =
+    ck::tensor_operation::device::ConvolutionForwardSpecialization::Default;
+
+template <ck::index_t SpatialDims, typename InDataType, typename WeiDataType, typename OutDataType>
+using DeviceConvNDFwdInstance = ck::tensor_operation::device::
+    DeviceConvNDFwdXdl_Input_N_Hi_Wi_C_Weight_K_Y_X_C_Output_N_Ho_Wo_K<
+        // clang-format off
+        InDataType,         // 
+        WeiDataType,        //
+        OutDataType,        //
+        InDataType,         // 
+        InElementOp,        // Input Elementwise Operation
+        WeiElementOp,       // Weights Elementwise Operation
+        OutElementOp,       // Output Elementwise Operation
+        ConvFwdDefault,     // ConvForwardSpecialization
+        SpatialDims,        // SptialDims
+        64,                 // BlockSize
+        16,                 // MPerBlock
+        16,                 // NPerBlock
+        4,                  // K0PerBlock
+        1,                  // K1                                           
+        16,                 // MPerXDL
+        16,                 // NPerXDL
+        1,                  // MXdlPerWave
+        1,                  // NXdlPerWave
+        S<1, 16, 1>,        // ABlockTransferThreadClusterLengths_K0_M_K1
+        S<1, 0, 2>,         // ABlockTransferThreadClusterArrangeOrder
+        S<1, 0, 2>,         // ABlockTransferSrcAccessOrder
+        2,                  // ABlockTransferSrcVectorDim
+        1,                  // ABlockTransferSrcScalarPerVector
+        1,                  // ABlockTransferDstScalarPerVector_K1
+        true,               // ABlockLdsAddExtraM
+        S<1, 16, 1>,        // BBlockTransferThreadClusterLengths_K0_N_K1
+        S<1, 0, 2>,         // BBlockTransferThreadClusterArrangeOrder
+        S<1, 0, 2>,         // BBlockTransferSrcAccessOrder
+        2,                  // BBlockTransferSrcVectorDim
+        1,                  // BBlockTransferSrcScalarPerVector
+        1,                  // BBlockTransferDstScalarPerVector_K1
+        true,               // BBlockTransferAddExtraN
+        7,                  // CThreadTransferSrcDstVectorDim
+        1>;                 // CThreadTransferDstScalarPerVector
+// clang-format on
+
+} // namespace
+
+namespace test {
+namespace conv {
+
+template <ck::index_t NDim,
+          typename InDataType  = float,
+          typename WeiDataType = float,
+          typename OutDataType = float>
+void RunConv(const ck::utils::conv::ConvParams& params,
+             const Tensor<InDataType>& input,
+             const Tensor<WeiDataType>& weights,
+             Tensor<OutDataType>& output)
+{
+    ck::utils::conv::run_convolution_forward<NDim,
+                                             InDataType,
+                                             WeiDataType,
+                                             OutDataType,
+                                             DeviceConvNDFwdInstance>(
+        params, input, weights, output);
+}
+
+} // namespace conv
+} // namespace test
+
+#endif

test/gemm/gemm_bf16.cpp

@@ -19,7 +19,6 @@
 #include "element_wise_operation.hpp"
 #include "reference_gemm.hpp"
 #include "gemm_specialization.hpp"
-#include "test_util.hpp"
 
 using PassThrough = ck::tensor_operation::element_wise::PassThrough;
 

test/gemm/gemm_fp32.cpp

@@ -19,7 +19,6 @@
 #include "element_wise_operation.hpp"
 #include "reference_gemm.hpp"
 #include "gemm_specialization.hpp"
-#include "test_util.hpp"
 
 using PassThrough = ck::tensor_operation::element_wise::PassThrough;
 

test/gemm/gemm_int8.cpp

@@ -19,7 +19,6 @@
 #include "element_wise_operation.hpp"
 #include "reference_gemm.hpp"
 #include "gemm_specialization.hpp"
-#include "test_util.hpp"
 
 using PassThrough = ck::tensor_operation::element_wise::PassThrough;
 

test/gemm/gemm_util.hpp

 #ifndef GEMM_UTILS_HPP
 #define GEMM_UTILS_HPP
 
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
 #include "host_tensor_generator.hpp"
 #include "reference_gemm.hpp"
 #include "tensor_layout.hpp"
-#include "test_util.hpp"
 
 namespace ck {
 namespace gemm_util {
@@ -202,20 +202,17 @@ struct TestGemm
         bool res = false;
         if(std::is_same<CDataType, float>::value)
         {
-            res = test::check_err(c_device.mData, c_host.mData, "Error: incorrect results!");
-
+            res = ck::utils::check_err(c_device.mData, c_host.mData);
             std::cout << (res ? "SUCCESS" : "FAILURE") << std::endl;
         }
         else if(std::is_same<CDataType, ck::half_t>::value)
         {
-            res = test::check_err(c_device.mData, c_host.mData, "Error: incorrect results!");
-
+            res = ck::utils::check_err(c_device.mData, c_host.mData);
             std::cout << (res ? "SUCCESS" : "FAILURE") << std::endl;
         }
         else if(std::is_same<CDataType, int8_t>::value)
         {
-            res = test::check_err(c_device.mData, c_host.mData, "Error: incorrect results!");
-
+            res = ck::utils::check_err(c_device.mData, c_host.mData);
             std::cout << (res ? "SUCCESS" : "FAILURE") << std::endl;
         }
 
@@ -330,9 +327,8 @@ struct TestGemmBF16
         bf16_to_f32_(c_device_bf16, c_device_fp32);
 
         // Assert
-        bool res = test::check_err(
+        bool res = ck::utils::check_err(
             c_device_fp32.mData, c_host_fp32.mData, "Error: incorrect results!", 1e-2f, 1e-3f);
-
         std::cout << (res ? "SUCCESS" : "FAILURE") << std::endl;
 
         return res;