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>

profiler/CMakeLists.txt

@@ -15,6 +15,7 @@ include_directories(BEFORE
     ${PROJECT_SOURCE_DIR}/library/include/ck/library/tensor_operation_instance/gpu/reduce
     ${PROJECT_SOURCE_DIR}/library/include/ck/library/reference_tensor_operation/cpu
     ${PROJECT_SOURCE_DIR}/library/include/ck/library/reference_tensor_operation/gpu
+    ${PROJECT_SOURCE_DIR}/library/include/ck/library/utility
     ${PROJECT_SOURCE_DIR}/profiler/include
     ${PROJECT_SOURCE_DIR}/external/include/half
 )

profiler/include/profile_batched_gemm_impl.hpp

@@ -2,6 +2,7 @@
 
 #include <memory>
 
+#include "check_err.hpp"
 #include "config.hpp"
 #include "element_wise_operation.hpp"
 #include "tensor_layout.hpp"
@@ -393,7 +394,6 @@ bool profile_batched_gemm_impl(int do_verification,
                 }
                 else
                 {
-
                     float err = check_error(c_g_m_n_host_result, c_g_m_n_device_result);
                     pass      = pass && (err < 1E-6);
                 }

profiler/include/profile_conv_bwd_data_impl.hpp

 #pragma once
+
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -253,7 +255,8 @@ void profile_conv_bwd_data_impl(int do_verification,
             {
                 in_device_buf.FromDevice(in_n_c_hi_wi_device_result.mData.data());
 
-                check_error(in_n_c_hi_wi_host_result, in_n_c_hi_wi_device_result);
+                ck::utils::check_err(in_n_c_hi_wi_device_result.mData,
+                                     in_n_c_hi_wi_host_result.mData);
 
                 if(do_log)
                 {

profiler/include/profile_conv_fwd_bias_relu_add_impl.hpp

 #pragma once
+
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -245,7 +247,8 @@ void profile_conv_fwd_bias_relu_add_impl(int do_verification,
             {
                 out_device_buf.FromDevice(out_n_k_ho_wo_device_result.mData.data());
 
-                check_error(out_n_k_ho_wo_host_result, out_n_k_ho_wo_device_result);
+                ck::utils::check_err(out_n_k_ho_wo_device_result.mData,
+                                     out_n_k_ho_wo_host_result.mData);
 
                 if(do_log)
                 {

profiler/include/profile_conv_fwd_bias_relu_atomic_add_impl.hpp

 #pragma once
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -301,7 +302,8 @@ void profile_conv_fwd_bias_relu_atomic_add_impl(int do_verification,
             {
                 out_device_buf.FromDevice(out_n_k_ho_wo_device_result.mData.data());
 
-                check_error(out_n_k_ho_wo_host_result, out_n_k_ho_wo_device_result);
+                ck::utils::check_err(out_n_k_ho_wo_device_result.mData,
+                                     out_n_k_ho_wo_host_result.mData);
 
                 if(do_log)
                 {

profiler/include/profile_conv_fwd_bias_relu_impl.hpp

 #pragma once
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -233,7 +234,8 @@ void profile_conv_fwd_bias_relu_impl(int do_verification,
             {
                 out_device_buf.FromDevice(out_n_k_ho_wo_device_result.mData.data());
 
-                check_error(out_n_k_ho_wo_host_result, out_n_k_ho_wo_device_result);
+                ck::utils::check_err(out_n_k_ho_wo_device_result.mData,
+                                     out_n_k_ho_wo_host_result.mData);
 
                 if(do_log)
                 {

profiler/include/profile_conv_fwd_impl.hpp

 #pragma once
+
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -253,7 +255,8 @@ void profile_conv_fwd_impl(int do_verification,
             {
                 out_device_buf.FromDevice(out_n_k_ho_wo_device_result.mData.data());
 
-                check_error(out_n_k_ho_wo_host_result, out_n_k_ho_wo_device_result);
+                ck::utils::check_err(out_n_k_ho_wo_device_result.mData,
+                                     out_n_k_ho_wo_host_result.mData);
 
                 if(do_log)
                 {

profiler/include/profile_convnd_bwd_data_impl.hpp

 #pragma once
 #include "config.hpp"
 #include "device.hpp"
-#include "conv_utils.hpp"
+#include "conv_fwd_util.hpp"
 #include "host_tensor.hpp"
 #include "host_tensor_generator.hpp"
 #include "tensor_layout.hpp"
@@ -68,13 +68,13 @@ HostTensorDescriptor get_input_host_tensor_descriptor(const std::vector<std::siz
     switch(num_dim_spatial)
     {
     case 3: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, InLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, InLayout{});
     }
     case 2: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, InLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, InLayout{});
     }
     case 1: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, InLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, InLayout{});
     }
     default: {
         throw std::runtime_error("Unsupported number of spatial dimensions provided!");
@@ -90,13 +90,13 @@ HostTensorDescriptor get_filters_host_tensor_descriptor(const std::vector<std::s
     switch(num_dim_spatial)
     {
     case 3: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, WeiLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, WeiLayout{});
     }
     case 2: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, WeiLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, WeiLayout{});
     }
     case 1: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, WeiLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, WeiLayout{});
     }
     default: {
         throw std::runtime_error("Unsupported number of spatial dimensions provided!");
@@ -112,13 +112,13 @@ HostTensorDescriptor get_output_host_ensor_descriptor(const std::vector<std::siz
     switch(num_dim_spatial)
     {
     case 3: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, OutLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, OutLayout{});
     }
     case 2: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, OutLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, OutLayout{});
     }
     case 1: {
-        return ck::conv_util::GetHostTensorDescriptor(dims, OutLayout{});
+        return ck::utils::conv::get_host_tensor_descriptor(dims, OutLayout{});
     }
     default: {
         throw std::runtime_error("Unsupported number of spatial dimensions provided!");
@@ -413,9 +413,10 @@ bool profile_convnd_bwd_data_impl(int do_verification,
             float ave_time = invoker_ptr->Run(argument_ptr.get(), nrepeat);
 
             std::size_t flop =
-                ck::conv_util::GetFlops(N, C, K, filter_spatial_lengths, output_spatial_lengths);
-            std::size_t num_btype = ck::conv_util::GetBtype<InDataType, WeiDataType, OutDataType>(
-                N, C, K, input_spatial_lengths, filter_spatial_lengths, output_spatial_lengths);
+                ck::utils::conv::get_flops(N, C, K, filter_spatial_lengths, output_spatial_lengths);
+            std::size_t num_btype =
+                ck::utils::conv::get_btype<InDataType, WeiDataType, OutDataType>(
+                    N, C, K, input_spatial_lengths, filter_spatial_lengths, output_spatial_lengths);
 
             float tflops     = static_cast<float>(flop) / 1.E9 / ave_time;
             float gb_per_sec = num_btype / 1.E6 / ave_time;

profiler/include/profile_gemm_bias_2d_impl.hpp

 #pragma once
+
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -283,7 +285,7 @@ void profile_gemm_bias_2d_impl(int do_verification,
             {
                 c_device_buf.FromDevice(c_m_n_device_result.mData.data());
 
-                check_error(c_m_n_host_result, c_m_n_device_result);
+                ck::utils::check_err(c_m_n_device_result.mData, c_m_n_host_result.mData);
 
                 if(do_log)
                 {

profiler/include/profile_gemm_bias_relu_add_impl.hpp

 #pragma once
+
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -257,7 +259,7 @@ void profile_gemm_bias_relu_add_impl(int do_verification,
             {
                 c_device_buf.FromDevice(c_m_n_device_result.mData.data());
 
-                check_error(c_m_n_host_result, c_m_n_device_result);
+                ck::utils::check_err(c_m_n_device_result.mData, c_m_n_host_result.mData);
 
                 if(do_log)
                 {

profiler/include/profile_gemm_bias_relu_impl.hpp

 #pragma once
+
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -236,7 +238,7 @@ void profile_gemm_bias_relu_impl(int do_verification,
             {
                 c_device_buf.FromDevice(c_m_n_device_result.mData.data());
 
-                check_error(c_m_n_host_result, c_m_n_device_result);
+                ck::utils::check_err(c_m_n_device_result.mData, c_m_n_host_result.mData);
 
                 if(do_log)
                 {

profiler/include/profile_gemm_impl.hpp

 #pragma once
 #include <iomanip>
+
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -470,7 +472,7 @@ void profile_gemm_impl(int do_verification,
 
                     ref_invoker.Run(ref_argument);
 
-                    check_error(c_m_n_host_result, c_m_n_device_f32_result);
+                    ck::utils::check_err(c_m_n_device_f32_result.mData, c_m_n_host_result.mData);
 
                     if(do_log)
                     {
@@ -499,7 +501,7 @@ void profile_gemm_impl(int do_verification,
                         a_m_k, b_k_n, c_m_n_host_result, a_element_op, b_element_op, c_element_op);
 
                     ref_invoker.Run(ref_argument);
-                    check_error(c_m_n_host_result, c_m_n_device_result);
+                    ck::utils::check_err(c_m_n_device_result.mData, c_m_n_host_result.mData);
 
                     if(do_log)
                     {

profiler/include/profile_grouped_gemm_impl.hpp

 #pragma once
 #include <iomanip>
+
+#include "check_err.hpp"
 #include "config.hpp"
 #include "device.hpp"
 #include "host_tensor.hpp"
@@ -283,7 +285,7 @@ void profile_grouped_gemm_impl(int do_verification,
                                                               c_element_op);
 
                     ref_invoker.Run(ref_argument);
-                    check_error(c_m_n_host_result, c_m_n_device_results[i]);
+                    ck::utils::check_err(c_m_n_device_results[i].mData, c_m_n_host_result.mData);
 
                     if(do_log)
                     {

profiler/include/profile_reduce_impl.hpp

 #pragma once
+
+#include "check_err.hpp"
 #include "device_reduce.hpp"
 #include "device_reduce_instance.hpp"
 #include "reduction_enums.hpp"
@@ -455,12 +457,13 @@ void profile_reduce_impl_impl(bool do_verification,
             if(do_verification)
             {
                 out_dev.FromDevice(out.mData.data());
-                check_error(out_ref, out);
+                ck::utils::check_err(out.mData, out_ref.mData);
 
                 if(NeedIndices)
                 {
                     out_indices_dev.FromDevice(out_indices.mData.data());
-                    check_indices(out_indices_ref, out_indices);
+                    ck::utils::check_err(out_indices.mData, out_indices_ref.mData);
+                    ;
                 };
 
                 if(do_log)
@@ -577,12 +580,13 @@ void profile_reduce_impl_impl(bool do_verification,
                 if(do_verification)
                 {
                     out_dev.FromDevice(out.mData.data());
-                    check_error(out_ref, out);
+                    ck::utils::check_err(out.mData, out_ref.mData);
 
                     if(NeedIndices)
                     {
                         out_indices_dev.FromDevice(out_indices.mData.data());
-                        check_indices(out_indices_ref, out_indices);
+                        ck::utils::check_err(out_indices.mData, out_indices_ref.mData);
+                        ;
                     };
 
                     if(do_log)

profiler/src/profile_convnd_bwd_data.cpp

@@ -32,10 +32,10 @@ enum struct ConvOutputLayout
     NKHW, // 0
     NHWK, // 1
 };
-ck::conv_util::ConvParams parse_conv_params(int num_dim_spatial, char* argv[], int arg_idx)
+ck::utils::conv::ConvParams parse_conv_params(int num_dim_spatial, char* argv[], int arg_idx)
 {
     // (N, K, C) + num_dim_spatial * 6 (filter, input, strides, dilations, pad left, pad right)
-    ck::conv_util::ConvParams params;
+    ck::utils::conv::ConvParams params;
 
     params.num_dim_spatial = num_dim_spatial;
     params.N               = std::stoi(argv[arg_idx++]);
@@ -106,7 +106,7 @@ int profile_convnd_bwd_data(int argc, char* argv[], int num_dim_spatial)
     const bool do_log          = std::stoi(argv[8]);
     const int nrepeat          = std::stoi(argv[9]);
 
-    ck::conv_util::ConvParams params = parse_conv_params(num_dim_spatial, argv, preParams);
+    ck::utils::conv::ConvParams params = parse_conv_params(num_dim_spatial, argv, preParams);
 
     auto Run = [&](auto input_type, auto wei_type, auto out_type, auto acc_type) {
         using InDataType  = decltype(input_type);

test/CMakeLists.txt

@@ -15,6 +15,7 @@ include_directories(BEFORE
     ${PROJECT_SOURCE_DIR}/library/include/ck/library/tensor_operation_instance/gpu/reduce
     ${PROJECT_SOURCE_DIR}/library/include/ck/library/reference_tensor_operation/cpu
     ${PROJECT_SOURCE_DIR}/library/include/ck/library/reference_tensor_operation/gpu
+    ${PROJECT_SOURCE_DIR}/library/include/ck/library/utility
     ${PROJECT_SOURCE_DIR}/test/include
     ${PROJECT_SOURCE_DIR}/profiler/include
     ${PROJECT_SOURCE_DIR}/external/include/half

test/batched_gemm/batched_gemm_fp16.cpp

-#include "profile_batched_gemm_impl.hpp"
-
 #include <iostream>
 
+#include "profile_batched_gemm_impl.hpp"
+
 namespace {
 using ADataType = ck::half_t;
 using BDataType = ck::half_t;

test/conv2d_bwd_weight/conv2d_bwd_weight.cpp

@@ -6,13 +6,13 @@
 #include <half.hpp>
 #include <vector>
 
-#include "conv_utils.hpp"
+#include "conv_fwd_util.hpp"
 #include "profile_conv_bwd_weight_impl.hpp"
 
 int test_self()
 {
     bool pass = true;
-    std::vector<ck::conv_util::ConvParams> params;
+    std::vector<ck::utils::conv::ConvParams> params;
 
     params.push_back({2, 128, 256, 256, {1, 1}, {7, 7}, {2, 2}, {1, 1}, {0, 0}, {0, 0}});
     params.push_back({2, 128, 256, 256, {3, 3}, {14, 14}, {1, 1}, {1, 1}, {1, 1}, {1, 1}});
@@ -136,16 +136,16 @@ int main(int argc, char* argv[])
             exit(1);
         }
 
-        ck::conv_util::ConvParams param{2,
-                                        N,
-                                        K,
-                                        C,
-                                        {Y, X},
-                                        {Hi, Wi},
-                                        {conv_stride_h, conv_stride_w},
-                                        {conv_dilation_h, conv_dilation_w},
-                                        {in_left_pad_h, in_left_pad_w},
-                                        {in_right_pad_h, in_right_pad_w}};
+        ck::utils::conv::ConvParams param{2,
+                                          N,
+                                          K,
+                                          C,
+                                          {Y, X},
+                                          {Hi, Wi},
+                                          {conv_stride_h, conv_stride_w},
+                                          {conv_dilation_h, conv_dilation_w},
+                                          {in_left_pad_h, in_left_pad_w},
+                                          {in_right_pad_h, in_right_pad_w}};
         if(data_type == 0)
         {
             pass = ck::profiler::profile_conv_bwd_weight_impl<2,

test/conv_util/conv_util.cpp

@@ -3,13 +3,13 @@
 #include <vector>
 
 #include "config.hpp"
-#include "conv_utils.hpp"
+#include "conv_fwd_util.hpp"
 #include "tensor_layout.hpp"
-#include "test_util.hpp"
+#include "check_err.hpp"
 
 namespace {
 
-bool TestConvParams_GetOutputSpatialLengths()
+bool test_conv_params_get_output_spatial_lengths()
 {
     bool res{true};
     // -------------------------- default 2D ------------------------------------
@@ -18,28 +18,28 @@ bool TestConvParams_GetOutputSpatialLengths()
     // stride {2,2},
     // dilations {1,1},
     // padding {{1,1}, {1,1}}
-    ck::conv_util::ConvParams conv_params;
+    ck::utils::conv::ConvParams conv_params;
     std::vector<ck::index_t> out_spatial_len = conv_params.GetOutputSpatialLengths();
-    res                                      = test::check_err(out_spatial_len,
-                          std::vector<ck::index_t>{36, 36},
-                          "Error: ConvParams 2D default constructor.");
+    res                                      = ck::utils::check_err(out_spatial_len,
+                               std::vector<ck::index_t>{36, 36},
+                               "Error: ConvParams 2D default constructor.");
 
     conv_params.conv_filter_strides = std::vector<ck::index_t>{1, 1};
     out_spatial_len                 = conv_params.GetOutputSpatialLengths();
-    res                             = test::check_err(
+    res                             = ck::utils::check_err(
         out_spatial_len, std::vector<ck::index_t>{71, 71}, "Error: ConvParams 2D stride {1,1}.");
 
     conv_params.conv_filter_strides = std::vector<ck::index_t>{2, 2};
     conv_params.input_left_pads     = std::vector<ck::index_t>{2, 2};
     conv_params.input_right_pads    = std::vector<ck::index_t>{2, 2};
     out_spatial_len                 = conv_params.GetOutputSpatialLengths();
-    res                             = test::check_err(out_spatial_len,
-                          std::vector<ck::index_t>{37, 37},
-                          "Error: ConvParams 2D padding left/right {2,2}.");
+    res                             = ck::utils::check_err(out_spatial_len,
+                               std::vector<ck::index_t>{37, 37},
+                               "Error: ConvParams 2D padding left/right {2,2}.");
 
     conv_params.conv_filter_dilations = std::vector<ck::index_t>{2, 2};
     out_spatial_len                   = conv_params.GetOutputSpatialLengths();
-    res                               = test::check_err(
+    res                               = ck::utils::check_err(
         out_spatial_len, std::vector<ck::index_t>{36, 36}, "Error: ConvParams 2D dilation {2,2}.");
 
     conv_params.conv_filter_strides   = std::vector<ck::index_t>{3, 3};
@@ -47,9 +47,10 @@ bool TestConvParams_GetOutputSpatialLengths()
     conv_params.input_right_pads      = std::vector<ck::index_t>{1, 1};
     conv_params.conv_filter_dilations = std::vector<ck::index_t>{2, 2};
     out_spatial_len                   = conv_params.GetOutputSpatialLengths();
-    res                               = test::check_err(out_spatial_len,
-                          std::vector<ck::index_t>{23, 23},
-                          "Error: ConvParams 2D strides{3,3}, padding {1,1}, dilations {2,2}.");
+    res =
+        ck::utils::check_err(out_spatial_len,
+                             std::vector<ck::index_t>{23, 23},
+                             "Error: ConvParams 2D strides{3,3}, padding {1,1}, dilations {2,2}.");
 
     // -------------------------- 1D ------------------------------------
     conv_params.num_dim_spatial        = 1;
@@ -61,24 +62,25 @@ bool TestConvParams_GetOutputSpatialLengths()
     conv_params.input_right_pads       = std::vector<ck::index_t>{1};
 
     out_spatial_len = conv_params.GetOutputSpatialLengths();
-    res = test::check_err(out_spatial_len, std::vector<ck::index_t>{36}, "Error: ConvParams 1D.");
+    res             = ck::utils::check_err(
+        out_spatial_len, std::vector<ck::index_t>{36}, "Error: ConvParams 1D.");
 
-    conv_params.conv_filter_strides = std::vector<ck::index_t>{1, 1};
+    conv_params.conv_filter_strides = std::vector<ck::index_t>{1};
     out_spatial_len                 = conv_params.GetOutputSpatialLengths();
-    res                             = test::check_err(
+    res                             = ck::utils::check_err(
         out_spatial_len, std::vector<ck::index_t>{71}, "Error: ConvParams 1D stride {1}.");
 
     conv_params.conv_filter_strides = std::vector<ck::index_t>{2};
     conv_params.input_left_pads     = std::vector<ck::index_t>{2};
     conv_params.input_right_pads    = std::vector<ck::index_t>{2};
     out_spatial_len                 = conv_params.GetOutputSpatialLengths();
-    res                             = test::check_err(out_spatial_len,
-                          std::vector<ck::index_t>{37},
-                          "Error: ConvParams 1D padding left/right {2}.");
+    res                             = ck::utils::check_err(out_spatial_len,
+                               std::vector<ck::index_t>{37},
+                               "Error: ConvParams 1D padding left/right {2}.");
 
     conv_params.conv_filter_dilations = std::vector<ck::index_t>{2};
     out_spatial_len                   = conv_params.GetOutputSpatialLengths();
-    res                               = test::check_err(
+    res                               = ck::utils::check_err(
         out_spatial_len, std::vector<ck::index_t>{36}, "Error: ConvParams 1D dilation {2}.");
 
     conv_params.conv_filter_strides   = std::vector<ck::index_t>{3};
@@ -86,9 +88,9 @@ bool TestConvParams_GetOutputSpatialLengths()
     conv_params.input_right_pads      = std::vector<ck::index_t>{1};
     conv_params.conv_filter_dilations = std::vector<ck::index_t>{2};
     out_spatial_len                   = conv_params.GetOutputSpatialLengths();
-    res                               = test::check_err(out_spatial_len,
-                          std::vector<ck::index_t>{23},
-                          "Error: ConvParams 1D strides{3}, padding {1}, dilations {2}.");
+    res                               = ck::utils::check_err(out_spatial_len,
+                               std::vector<ck::index_t>{23},
+                               "Error: ConvParams 1D strides{3}, padding {1}, dilations {2}.");
 
     // -------------------------- 3D ------------------------------------
     conv_params.num_dim_spatial        = 3;
@@ -100,35 +102,35 @@ bool TestConvParams_GetOutputSpatialLengths()
     conv_params.input_right_pads       = std::vector<ck::index_t>{1, 1, 1};
 
     out_spatial_len = conv_params.GetOutputSpatialLengths();
-    res             = test::check_err(
+    res             = ck::utils::check_err(
         out_spatial_len, std::vector<ck::index_t>{36, 36, 36}, "Error: ConvParams 3D.");
 
     conv_params.conv_filter_strides = std::vector<ck::index_t>{1, 1, 1};
     out_spatial_len                 = conv_params.GetOutputSpatialLengths();
-    res                             = test::check_err(out_spatial_len,
-                          std::vector<ck::index_t>{71, 71, 71},
-                          "Error: ConvParams 3D stride {1, 1, 1}.");
+    res                             = ck::utils::check_err(out_spatial_len,
+                               std::vector<ck::index_t>{71, 71, 71},
+                               "Error: ConvParams 3D stride {1, 1, 1}.");
 
     conv_params.conv_filter_strides = std::vector<ck::index_t>{2, 2, 2};
     conv_params.input_left_pads     = std::vector<ck::index_t>{2, 2, 2};
     conv_params.input_right_pads    = std::vector<ck::index_t>{2, 2, 2};
     out_spatial_len                 = conv_params.GetOutputSpatialLengths();
-    res                             = test::check_err(out_spatial_len,
-                          std::vector<ck::index_t>{37, 37, 37},
-                          "Error: ConvParams 3D padding left/right {2, 2, 2}.");
+    res                             = ck::utils::check_err(out_spatial_len,
+                               std::vector<ck::index_t>{37, 37, 37},
+                               "Error: ConvParams 3D padding left/right {2, 2, 2}.");
 
     conv_params.conv_filter_dilations = std::vector<ck::index_t>{2, 2, 2};
     out_spatial_len                   = conv_params.GetOutputSpatialLengths();
-    res                               = test::check_err(out_spatial_len,
-                          std::vector<ck::index_t>{36, 36, 36},
-                          "Error: ConvParams 3D dilation {2, 2, 2}.");
+    res                               = ck::utils::check_err(out_spatial_len,
+                               std::vector<ck::index_t>{36, 36, 36},
+                               "Error: ConvParams 3D dilation {2, 2, 2}.");
 
     conv_params.conv_filter_strides   = std::vector<ck::index_t>{3, 3, 3};
     conv_params.input_left_pads       = std::vector<ck::index_t>{1, 1, 1};
     conv_params.input_right_pads      = std::vector<ck::index_t>{1, 1, 1};
     conv_params.conv_filter_dilations = std::vector<ck::index_t>{2, 2, 2};
     out_spatial_len                   = conv_params.GetOutputSpatialLengths();
-    res                               = test::check_err(
+    res                               = ck::utils::check_err(
         out_spatial_len,
         std::vector<ck::index_t>{23, 23, 23},
         "Error: ConvParams 3D strides{3, 3, 3}, padding {1, 1, 1}, dilations {2, 2, 2}.");
@@ -136,50 +138,54 @@ bool TestConvParams_GetOutputSpatialLengths()
     return res;
 }
 
-bool TestGetHostTensorDescriptor()
+bool test_get_host_tensor_descriptor()
 {
     bool res{true};
     namespace tl = ck::tensor_layout::convolution;
     std::vector<std::size_t> dims{2, 3, 4, 5};
-    HostTensorDescriptor h = ck::conv_util::GetHostTensorDescriptor(dims, tl::NHWC{});
-    res = test::check_err(h.GetLengths(), {2, 3, 4, 5}, "Error: wrong NHWC dimensions lengths!");
-    res = test::check_err(
+    HostTensorDescriptor h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NHWC{});
+    res =
+        ck::utils::check_err(h.GetLengths(), {2, 3, 4, 5}, "Error: wrong NHWC dimensions lengths!");
+    res = ck::utils::check_err(
         h.GetStrides(), {3 * 4 * 5, 1, 3 * 5, 3}, "Error: wrong NHWC dimensions strides!");
 
-    h   = ck::conv_util::GetHostTensorDescriptor(dims, tl::NCHW{});
-    res = test::check_err(h.GetLengths(), {2, 3, 4, 5}, "Error: wrong NCHW dimensions lengths!");
-    res = test::check_err(
+    h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCHW{});
+    res =
+        ck::utils::check_err(h.GetLengths(), {2, 3, 4, 5}, "Error: wrong NCHW dimensions lengths!");
+    res = ck::utils::check_err(
         h.GetStrides(), {3 * 4 * 5, 4 * 5, 5, 1}, "Error: wrong NCHW dimensions strides!");
 
     dims = std::vector<std::size_t>{2, 3, 4};
-    h    = ck::conv_util::GetHostTensorDescriptor(dims, tl::NWC{});
-    res  = test::check_err(h.GetLengths(), {2, 3, 4}, "Error: wrong NWC dimensions lengths!");
-    res  = test::check_err(h.GetStrides(), {3 * 4, 1, 3}, "Error: wrong NWC dimensions strides!");
+    h    = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NWC{});
+    res  = ck::utils::check_err(h.GetLengths(), {2, 3, 4}, "Error: wrong NWC dimensions lengths!");
+    res =
+        ck::utils::check_err(h.GetStrides(), {3 * 4, 1, 3}, "Error: wrong NWC dimensions strides!");
 
-    h   = ck::conv_util::GetHostTensorDescriptor(dims, tl::NCW{});
-    res = test::check_err(h.GetLengths(), {2, 3, 4}, "Error: wrong NCW dimensions lengths!");
-    res = test::check_err(h.GetStrides(), {3 * 4, 4, 1}, "Error: wrong NCW dimensions strides!");
+    h   = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCW{});
+    res = ck::utils::check_err(h.GetLengths(), {2, 3, 4}, "Error: wrong NCW dimensions lengths!");
+    res =
+        ck::utils::check_err(h.GetStrides(), {3 * 4, 4, 1}, "Error: wrong NCW dimensions strides!");
 
     dims = std::vector<std::size_t>{2, 3, 4, 5, 6};
-    h    = ck::conv_util::GetHostTensorDescriptor(dims, tl::NDHWC{});
-    res  = test::check_err(h.GetLengths(), dims, "Error: wrong NDHWC dimensions lengths!");
-    res  = test::check_err(h.GetStrides(),
-                          {3 * 4 * 5 * 6, // N
-                           1,             // C
-                           3 * 5 * 6,     // D
-                           3 * 6,         // H
-                           3},            // W
-                          "Error: wrong NDHWC dimensions strides!");
-
-    h   = ck::conv_util::GetHostTensorDescriptor(dims, tl::NCDHW{});
-    res = test::check_err(h.GetLengths(), dims, "Error: wrong NCDHW dimensions lengths!");
-    res = test::check_err(h.GetStrides(),
-                          {3 * 4 * 5 * 6, // N
-                           4 * 5 * 6,     // C
-                           5 * 6,         // D
-                           6,             // H
-                           1},            // W
-                          "Error: wrong NCDHW dimensions strides!");
+    h    = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NDHWC{});
+    res  = ck::utils::check_err(h.GetLengths(), dims, "Error: wrong NDHWC dimensions lengths!");
+    res  = ck::utils::check_err(h.GetStrides(),
+                               {3 * 4 * 5 * 6, // N
+                                1,             // C
+                                3 * 5 * 6,     // D
+                                3 * 6,         // H
+                                3},            // W
+                               "Error: wrong NDHWC dimensions strides!");
+
+    h   = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCDHW{});
+    res = ck::utils::check_err(h.GetLengths(), dims, "Error: wrong NCDHW dimensions lengths!");
+    res = ck::utils::check_err(h.GetStrides(),
+                               {3 * 4 * 5 * 6, // N
+                                4 * 5 * 6,     // C
+                                5 * 6,         // D
+                                6,             // H
+                                1},            // W
+                               "Error: wrong NCDHW dimensions strides!");
 
     return res;
 }
@@ -188,10 +194,11 @@ bool TestGetHostTensorDescriptor()
 
 int main(void)
 {
-    bool res = TestConvParams_GetOutputSpatialLengths();
-    std::cout << "TestConvParams_GetOutputSpatialLengths ..... " << (res ? "SUCCESS" : "FAILURE")
+    bool res = test_conv_params_get_output_spatial_lengths();
+    std::cout << "test_conv_params_get_output_spatial_lengths ..... "
+              << (res ? "SUCCESS" : "FAILURE") << std::endl;
+    res = test_get_host_tensor_descriptor();
+    std::cout << "test_get_host_tensor_descriptor ..... " << (res ? "SUCCESS" : "FAILURE")
               << std::endl;
-    res = TestGetHostTensorDescriptor();
-    std::cout << "TestGetHostTensorDescriptor ..... " << (res ? "SUCCESS" : "FAILURE") << std::endl;
     return res ? 0 : 1;
 }

test/convnd_bwd_data/convnd_bwd_data.cpp

@@ -12,7 +12,7 @@ int main()
 {
     bool pass = true;
     // check 1d
-    std::vector<ck::conv_util::ConvParams> params;
+    std::vector<ck::utils::conv::ConvParams> params;
     params.push_back({1, 128, 128, 256, {1}, {14}, {2}, {1}, {0}, {0}});
     params.push_back({1, 128, 128, 256, {3}, {28}, {1}, {1}, {1}, {1}});
     params.push_back({1, 128, 128, 256, {1}, {3}, {1}, {1}, {0}, {0}});