convnd_fwd fp16 example

README.md

@@ -10,7 +10,7 @@ rocm/tensorflow:rocm5.1-tf2.6-dev              \
 /bin/bash
 ```
 
-# Install the new rocm-cmake version
+# Install newer version of rocm-cmake
 https://github.com/RadeonOpenCompute/rocm-cmake
 
 ## Build
@@ -54,6 +54,7 @@ make install
 ```
 
 ## Using CK as pre-built kernel library
+Instructions for using CK as a pre-built kernel library are under ```client_example/```
 
 ## Caveat
 ### Kernel Timing and Verification

example/09_convnd_fwd/CMakeLists.txt

@@ -3,7 +3,3 @@ add_example_executable(example_convnd_fwd_xdl_int8 convnd_fwd_xdl_int8.cpp)
 add_example_executable(example_convnd_fwd_xdl_fp16 convnd_fwd_xdl_fp16.cpp)
 # FIXME: re-enable this exampe as test when SWDEV-335738 is fixed
 add_example_executable_no_testing(example_convnd_fwd_xdl_fp64 convnd_fwd_xdl_fp64.cpp)
-target_link_libraries(example_convnd_fwd_xdl_fp64 PRIVATE conv_util)
-target_link_libraries(example_convnd_fwd_xdl_fp32 PRIVATE conv_util)
-target_link_libraries(example_convnd_fwd_xdl_int8 PRIVATE conv_util)
-target_link_libraries(example_convnd_fwd_xdl_fp16 PRIVATE conv_util)

example/09_convnd_fwd/convnd_fwd_xdl_fp16.cpp

@@ -8,17 +8,17 @@
 
 #include "ck/ck.hpp"
 #include "ck/tensor_operation/gpu/device/tensor_layout.hpp"
-#include "ck/tensor_operation/gpu/device/device_convnd_fwd_xdl_nhwc_kyxc_nhwk.hpp"
+#include "ck/tensor_operation/gpu/device/device_convnd_fwd_nwc_kxc_nwk_xdl.hpp"
 #include "ck/tensor_operation/gpu/element/element_wise_operation.hpp"
 
 #include "ck/library/utility/check_err.hpp"
-#include "ck/library/utility/conv_util.hpp"
-#include "ck/library/host_tensor/device_memory.hpp"
-#include "ck/library/host_tensor/host_tensor.hpp"
-#include "ck/library/host_tensor/host_tensor_generator.hpp"
+#include "ck/library/utility/convolution_parameter.hpp"
+#include "ck/library/utility/device_memory.hpp"
+#include "ck/library/utility/host_tensor.hpp"
+#include "ck/library/utility/host_tensor_generator.hpp"
 #include "ck/library/reference_tensor_operation/cpu/reference_conv_fwd.hpp"
 
-namespace {
+#include "parse_conv_parameter.hpp"
 
 using InDataType  = ck::half_t;
 using WeiDataType = ck::half_t;
@@ -39,13 +39,8 @@ using OutElementOp = ck::tensor_operation::element_wise::PassThrough;
 static constexpr auto ConvFwdDefault =
     ck::tensor_operation::device::ConvolutionForwardSpecialization::Default;
 
-using DeviceConvFwdBasePtr =
-    ck::tensor_operation::device::DeviceConvFwdPtr<InElementOp, WeiElementOp, OutElementOp>;
-
 template <ck::index_t NumDimSpatial>
-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
+using DeviceConvNDFwdInstance = ck::tensor_operation::device::DeviceConvNdFwdNwcKxcNwk_Xdl<
     InDataType,     //
     WeiDataType,    //
     OutDataType,    //
@@ -90,107 +85,14 @@ using ReferenceConvNDFwdInstance = ck::tensor_operation::host::ReferenceConvFwd<
                                                                                 OutElementOp,
                                                                                 NumDimSpatial>;
 
-DeviceConvFwdBasePtr get_conv_instance(int num_dim_spatial)
-{
-    switch(num_dim_spatial)
-    {
-    case 3: {
-        return std::make_unique<DeviceConvNDFwdInstance<3>>();
-    }
-    case 2: {
-        return std::make_unique<DeviceConvNDFwdInstance<2>>();
-    }
-    case 1: {
-        return std::make_unique<DeviceConvNDFwdInstance<1>>();
-    }
-    default: {
-        throw std::runtime_error("Unsupported number of spatial dimensions provided!");
-    }
-    }
-}
-
-void print_use_msg()
-{
-    std::cout << "arg1: verification (0=no, 1=yes)\n"
-              << "arg2: initialization (0=no init, 1=integer value, 2=decimal value)\n"
-              << "arg3: time kernel (0=n0, 1=yes)\n"
-              << "arg4: N spatial dimensions (default 2)\n"
-              << "Following arguments (depending on number of spatial dims):\n"
-              << " N, K, C, \n"
-              << " <filter spatial dimensions>, (ie Y, X for 2D)\n"
-              << " <input image spatial dimensions>, (ie Hi, Wi for 2D)\n"
-              << " <strides>, (ie Sy, Sx for 2D)\n"
-              << " <dilations>, (ie Dy, Dx for 2D)\n"
-              << " <left padding>, (ie LeftPy, LeftPx for 2D)\n"
-              << " <right padding>, (ie RightPy, RightPx for 2D)\n"
-              << std::endl;
-}
-
-ck::utils::conv::ConvParams parse_conv_params(int num_dim_spatial, int argc, char* argv[])
-{
-    // (N, K, C) + num_dim_spatial * 6 (filter, input, strides, dilations, pad left, pad right)
-    int conv_args     = 3 + num_dim_spatial * 6;
-    int cmdline_nargs = conv_args + 5;
-    if(cmdline_nargs != argc)
-    {
-        print_use_msg();
-        exit(0);
-    }
-
-    ck::utils::conv::ConvParams params;
-    int arg_idx = 5;
-
-    params.num_dim_spatial_ = num_dim_spatial;
-    params.N_               = std::stoi(argv[arg_idx++]);
-    params.K_               = std::stoi(argv[arg_idx++]);
-    params.C_               = std::stoi(argv[arg_idx++]);
-
-    params.filter_spatial_lengths_.resize(num_dim_spatial);
-    for(int i = 0; i < num_dim_spatial; ++i)
-    {
-        params.filter_spatial_lengths_[i] = std::stoi(argv[arg_idx++]);
-    }
-    params.input_spatial_lengths_.resize(num_dim_spatial);
-    for(int i = 0; i < num_dim_spatial; ++i)
-    {
-        params.input_spatial_lengths_[i] = std::stoi(argv[arg_idx++]);
-    }
-    params.conv_filter_strides_.resize(num_dim_spatial);
-    for(int i = 0; i < num_dim_spatial; ++i)
-    {
-        params.conv_filter_strides_[i] = std::stoi(argv[arg_idx++]);
-    }
-    params.conv_filter_dilations_.resize(num_dim_spatial);
-    for(int i = 0; i < num_dim_spatial; ++i)
-    {
-        params.conv_filter_dilations_[i] = std::stoi(argv[arg_idx++]);
-    }
-    params.input_left_pads_.resize(num_dim_spatial);
-    for(int i = 0; i < num_dim_spatial; ++i)
-    {
-        params.input_left_pads_[i] = std::stoi(argv[arg_idx++]);
-    }
-    params.input_right_pads_.resize(num_dim_spatial);
-    for(int i = 0; i < num_dim_spatial; ++i)
-    {
-        params.input_right_pads_[i] = std::stoi(argv[arg_idx++]);
-    }
-
-    return params;
-}
-
-} // anonymous namespace
-
 int main(int argc, char* argv[])
 {
-    using namespace ck::utils::conv;
-
     bool do_verification = true;
     int init_method      = 1;
-    bool time_kernel     = false;
+    bool time_kernel     = true;
     int num_dim_spatial  = 2;
 
-    ck::utils::conv::ConvParams params;
+    ck::tensor_operation::device::ConvParams params;
 
     if(argc >= 5)
     {
@@ -205,29 +107,25 @@ int main(int argc, char* argv[])
         params = parse_conv_params(num_dim_spatial, argc, argv);
     }
 
-    std::vector<std::size_t> input_dims{static_cast<std::size_t>(params.N_),
-                                        static_cast<std::size_t>(params.C_)};
-    input_dims.insert(std::end(input_dims),
-                      std::begin(params.input_spatial_lengths_),
-                      std::end(params.input_spatial_lengths_));
-
-    std::vector<std::size_t> filter_dims{static_cast<std::size_t>(params.K_),
-                                         static_cast<std::size_t>(params.C_)};
-    filter_dims.insert(std::end(filter_dims),
-                       std::begin(params.filter_spatial_lengths_),
-                       std::end(params.filter_spatial_lengths_));
+    auto f_nchw_host_tensor_descriptor =
+        [](ck::index_t n, ck::index_t c, std::vector<ck::index_t> spatial_lengths) {
+            std::vector<std::size_t> nhwc_lengths{static_cast<std::size_t>(n),
+                                                  static_cast<std::size_t>(c)};
+            nhwc_lengths.insert(
+                nhwc_lengths.begin() + 1, spatial_lengths.begin(), spatial_lengths.end());
 
-    const std::vector<ck::index_t>& output_spatial_lengths = params.GetOutputSpatialLengths();
-    std::vector<std::size_t> output_dims{static_cast<std::size_t>(params.N_),
-                                         static_cast<std::size_t>(params.K_)};
-    output_dims.insert(std::end(output_dims),
-                       std::begin(output_spatial_lengths),
-                       std::end(output_spatial_lengths));
+            return transpose_host_tensor_descriptor_given_new2old(
+                HostTensorDescriptor(nhwc_lengths), std::vector<std::size_t>({0, 3, 1, 2}));
+        };
 
-    Tensor<InDataType> input(get_input_host_tensor_descriptor(input_dims, num_dim_spatial));
-    Tensor<WeiDataType> weights(get_filters_host_tensor_descriptor(filter_dims, num_dim_spatial));
-    Tensor<OutDataType> host_output(get_output_host_tensor_descriptor(output_dims, num_dim_spatial));
-    Tensor<OutDataType> device_output(get_output_host_tensor_descriptor(output_dims, num_dim_spatial));
+    Tensor<InDataType> input(
+        f_nchw_host_tensor_descriptor(params.N_, params.C_, params.input_spatial_lengths_));
+    Tensor<InDataType> weights(
+        f_nchw_host_tensor_descriptor(params.K_, params.C_, params.filter_spatial_lengths_));
+    Tensor<InDataType> host_output(
+        f_nchw_host_tensor_descriptor(params.N_, params.K_, params.GetOutputSpatialLengths()));
+    Tensor<InDataType> device_output(
+        f_nchw_host_tensor_descriptor(params.N_, params.K_, params.GetOutputSpatialLengths()));
 
     std::cout << "input: " << input.mDesc << std::endl;
     std::cout << "weights: " << weights.mDesc << std::endl;
@@ -253,10 +151,9 @@ int main(int argc, char* argv[])
     wei_device_buf.ToDevice(weights.mData.data());
 
     // do GEMM
-    auto conv    = get_conv_instance(num_dim_spatial);
-    auto invoker = conv->MakeInvokerPointer();
-    auto argument =
-        conv->MakeArgumentPointer(static_cast<InDataType*>(in_device_buf.GetDeviceBuffer()),
+    auto conv     = DeviceConvNDFwdInstance<2>{};
+    auto invoker  = conv.MakeInvoker();
+    auto argument = conv.MakeArgument(static_cast<InDataType*>(in_device_buf.GetDeviceBuffer()),
                                       static_cast<WeiDataType*>(wei_device_buf.GetDeviceBuffer()),
                                       static_cast<OutDataType*>(out_device_buf.GetDeviceBuffer()),
                                       params.N_,
@@ -264,7 +161,7 @@ int main(int argc, char* argv[])
                                       params.C_,
                                       params.input_spatial_lengths_,
                                       params.filter_spatial_lengths_,
-                                  output_spatial_lengths,
+                                      params.GetOutputSpatialLengths(),
                                       params.conv_filter_strides_,
                                       params.conv_filter_dilations_,
                                       params.input_left_pads_,
@@ -273,29 +170,22 @@ int main(int argc, char* argv[])
                                       WeiElementOp{},
                                       OutElementOp{});
 
-    if(!conv->IsSupportedArgument(argument.get()))
+    if(!conv.IsSupportedArgument(argument))
     {
         throw std::runtime_error(
             "wrong! device_conv with the specified compilation parameters does "
             "not support this Conv problem");
     }
 
-    float ave_time = invoker->Run(argument.get(), StreamConfig{nullptr, time_kernel});
+    float ave_time = invoker.Run(argument, StreamConfig{nullptr, time_kernel});
 
-    std::size_t flop = get_flops(
-        params.N_, params.C_, params.K_, params.filter_spatial_lengths_, output_spatial_lengths);
-    std::size_t num_btype = get_btype<InDataType, WeiDataType, OutDataType>(
-        params.N_,
-        params.C_,
-        params.K_,
-        params.input_spatial_lengths_,
-        params.filter_spatial_lengths_,
-        output_spatial_lengths);
+    std::size_t flop      = params.GetFlops();
+    std::size_t num_btype = params.GetByte<InDataType, WeiDataType, OutDataType>();
 
     float tflops     = static_cast<float>(flop) / 1.E9 / ave_time;
     float gb_per_sec = num_btype / 1.E6 / ave_time;
     std::cout << "Perf: " << ave_time << " ms, " << tflops << " TFlops, " << gb_per_sec << " GB/s, "
-              << conv->GetTypeString() << std::endl;
+              << conv.GetTypeString() << std::endl;
 
     if(do_verification)
     {
@@ -315,22 +205,27 @@ int main(int argc, char* argv[])
 
             ref_invoker.Run(ref_argument);
             out_device_buf.FromDevice(device_output.mData.data());
-            return ck::utils::check_err(
-                host_output.mData, device_output.mData, "Error: incorrect results!", 1e-5f, 1e-4f) ? 0 : 1;
+            return ck::utils::check_err(host_output.mData,
+                                        device_output.mData,
+                                        "Error: incorrect results!",
+                                        1e-5f,
+                                        1e-4f)
+                       ? 0
+                       : 1;
         };
 
         switch(num_dim_spatial)
         {
-        case 3: {
-            auto ref_conv = ReferenceConvNDFwdInstance<3>();
+        case 1: {
+            auto ref_conv = ReferenceConvNDFwdInstance<1>();
             return verify_f(ref_conv);
         }
         case 2: {
             auto ref_conv = ReferenceConvNDFwdInstance<2>();
             return verify_f(ref_conv);
         }
-        case 1: {
-            auto ref_conv = ReferenceConvNDFwdInstance<1>();
+        case 3: {
+            auto ref_conv = ReferenceConvNDFwdInstance<3>();
             return verify_f(ref_conv);
         }
         default: {

example/09_convnd_fwd/parse_conv_parameter.hpp

+// SPDX-License-Identifier: MIT
+// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
+
+#include <cstdlib>
+#include <iostream>
+
+#include "ck/ck.hpp"
+
+#include "ck/library/utility/convolution_parameter.hpp"
+
+ck::tensor_operation::device::ConvParams
+parse_conv_params(int num_dim_spatial, int arg_idx, char* const argv[])
+{
+    ck::tensor_operation::device::ConvParams params;
+
+    params.num_dim_spatial_ = num_dim_spatial;
+    params.N_               = std::stoi(argv[arg_idx++]);
+    params.K_               = std::stoi(argv[arg_idx++]);
+    params.C_               = std::stoi(argv[arg_idx++]);
+
+    params.filter_spatial_lengths_.resize(num_dim_spatial);
+    for(int i = 0; i < num_dim_spatial; ++i)
+    {
+        params.filter_spatial_lengths_[i] = std::stoi(argv[arg_idx++]);
+    }
+    params.input_spatial_lengths_.resize(num_dim_spatial);
+    for(int i = 0; i < num_dim_spatial; ++i)
+    {
+        params.input_spatial_lengths_[i] = std::stoi(argv[arg_idx++]);
+    }
+    params.conv_filter_strides_.resize(num_dim_spatial);
+    for(int i = 0; i < num_dim_spatial; ++i)
+    {
+        params.conv_filter_strides_[i] = std::stoi(argv[arg_idx++]);
+    }
+    params.conv_filter_dilations_.resize(num_dim_spatial);
+    for(int i = 0; i < num_dim_spatial; ++i)
+    {
+        params.conv_filter_dilations_[i] = std::stoi(argv[arg_idx++]);
+    }
+    params.input_left_pads_.resize(num_dim_spatial);
+    for(int i = 0; i < num_dim_spatial; ++i)
+    {
+        params.input_left_pads_[i] = std::stoi(argv[arg_idx++]);
+    }
+    params.input_right_pads_.resize(num_dim_spatial);
+    for(int i = 0; i < num_dim_spatial; ++i)
+    {
+        params.input_right_pads_[i] = std::stoi(argv[arg_idx++]);
+    }
+
+    return params;
+}
+
+void print_use_msg()
+{
+    std::cout << "arg1: verification (0=no, 1=yes)\n"
+              << "arg2: initialization (0=no init, 1=integer value, 2=decimal value)\n"
+              << "arg3: time kernel (0=n0, 1=yes)\n"
+              << "arg4: N spatial dimensions (default 2)\n"
+              << "Following arguments (depending on number of spatial dims):\n"
+              << " N, K, C, \n"
+              << " <filter spatial dimensions>, (ie Y, X for 2D)\n"
+              << " <input image spatial dimensions>, (ie Hi, Wi for 2D)\n"
+              << " <strides>, (ie Sy, Sx for 2D)\n"
+              << " <dilations>, (ie Dy, Dx for 2D)\n"
+              << " <left padding>, (ie LeftPy, LeftPx for 2D)\n"
+              << " <right padding>, (ie RightPy, RightPx for 2D)\n"
+              << std::endl;
+}

example/CMakeLists.txt

@@ -8,7 +8,7 @@ add_custom_target(examples)
 function(add_example_executable EXAMPLE_NAME FILE_NAME)
     message("adding example ${EXAMPLE_NAME}")
     add_executable(${EXAMPLE_NAME} ${FILE_NAME})
-    target_link_libraries(${EXAMPLE_NAME} PRIVATE host_tensor)
+    target_link_libraries(${EXAMPLE_NAME} PRIVATE utility)
     add_test(NAME ${EXAMPLE_NAME} COMMAND $<TARGET_FILE:${EXAMPLE_NAME}> ${ARGN})
     add_dependencies(examples ${EXAMPLE_NAME})
     add_dependencies(check ${EXAMPLE_NAME})
@@ -17,7 +17,7 @@ endfunction(add_example_executable EXAMPLE_NAME)
 function(add_example_executable_no_testing EXAMPLE_NAME FILE_NAME)
     message("adding example ${EXAMPLE_NAME}")
     add_executable(${EXAMPLE_NAME} ${FILE_NAME})
-    target_link_libraries(${EXAMPLE_NAME} PRIVATE host_tensor)
+    target_link_libraries(${EXAMPLE_NAME} PRIVATE utility)
     add_dependencies(examples ${EXAMPLE_NAME})
 endfunction(add_example_executable_no_testing EXAMPLE_NAME)
 

include/ck/tensor_operation/gpu/device/device_conv_fwd.hpp

@@ -12,7 +12,14 @@ namespace ck {
 namespace tensor_operation {
 namespace device {
 
-template <typename InElementwiseOperation,
+template <ck::index_t NumDimSpatial,
+          typename InLayout,
+          typename WeiLayout,
+          typename OutLayout,
+          typename InDataType,
+          typename WeiDataType,
+          typename OutDataType,
+          typename InElementwiseOperation,
           typename WeiElementwiseOperation,
           typename OutElementwiseOperation>
 struct DeviceConvFwd : public BaseOperator
@@ -38,11 +45,28 @@ struct DeviceConvFwd : public BaseOperator
     virtual std::unique_ptr<BaseInvoker> MakeInvokerPointer() = 0;
 };
 
-template <typename InElementwiseOperation,
+#if 0
+template <ck::index_t NumDimSpatial,
+          typename InLayout,
+          typename WeiLayout,
+          typename OutLayout,
+          typename InDataType,
+          typename WeiDataType,
+          typename OutDataType,
+          typename InElementwiseOperation,
           typename WeiElementwiseOperation,
           typename OutElementwiseOperation>
-using DeviceConvFwdPtr = std::unique_ptr<
-    DeviceConvFwd<InElementwiseOperation, WeiElementwiseOperation, OutElementwiseOperation>>;
+using DeviceConvFwdPtr = std::unique_ptr<DeviceConvFwd<NumDimSpatial,
+                                                       InLayout,
+                                                       WeiLayout,
+                                                       OutLayout,
+                                                       InDataType,
+                                                       WeiDataType,
+                                                       OutDataType,
+                                                       InElementwiseOperation,
+                                                       WeiElementwiseOperation,
+                                                       OutElementwiseOperation>>;
+#endif
 
 } // namespace device
 } // namespace tensor_operation

include/ck/tensor_operation/gpu/device/device_convnd_fwd_xdl_nhwc_kyxc_nhwk.hpp → include/ck/tensor_operation/gpu/device/device_convnd_fwd_nwc_kxc_nwk_xdl.hpp

@@ -27,10 +27,10 @@ namespace device {
 // @brief      Device Convolution operation.
 //
 // Supports:
-//  @li         Inputs with up to 3 spatial dimentions
-//  @li         Input tensor in NHWC data format
-//  @li         Weight tensor in KYXC data format
-//  @li         Output tensor in NHWK data format
+//  @li         Forward convolution with up to 3 spatial dimentions
+//  @li         Input tensor in NWC data format
+//  @li         Weight tensor in KXC data format
+//  @li         Output tensor in NWK data format
 //
 // 1D:
 // out[N, Wo, K] = in[N, Wi, C] * wei[K, X, C]
@@ -73,10 +73,28 @@ template <typename InDataType,
           bool BBlockLdsAddExtraN,
           ck::index_t CThreadTransferSrcDstVectorDim,
           ck::index_t CThreadTransferDstScalarPerVector>
-struct DeviceConvNDFwdXdl_Input_N_Hi_Wi_C_Weight_K_Y_X_C_Output_N_Ho_Wo_K
-    : public DeviceConvFwd<InElementwiseOperation, WeiElementwiseOperation, OutElementwiseOperation>
+struct DeviceConvNdFwdNwcKxcNwk_Xdl
+    : public DeviceConvFwd<NumDimSpatial,
+                           ck::tuple_element_t<NumDimSpatial - 1,
+                                               ck::Tuple<ck::tensor_layout::convolution::NWC,
+                                                         ck::tensor_layout::convolution::NHWC,
+                                                         ck::tensor_layout::convolution::NDHWC>>,
+                           ck::tuple_element_t<NumDimSpatial - 1,
+                                               ck::Tuple<ck::tensor_layout::convolution::KXC,
+                                                         ck::tensor_layout::convolution::KYXC,
+                                                         ck::tensor_layout::convolution::KZYXC>>,
+                           ck::tuple_element_t<NumDimSpatial - 1,
+                                               ck::Tuple<ck::tensor_layout::convolution::NWC,
+                                                         ck::tensor_layout::convolution::NHWC,
+                                                         ck::tensor_layout::convolution::NDHWC>>,
+                           InDataType,
+                           WeiDataType,
+                           OutDataType,
+                           InElementwiseOperation,
+                           WeiElementwiseOperation,
+                           OutElementwiseOperation>
 {
-    using DeviceOp = DeviceConvNDFwdXdl_Input_N_Hi_Wi_C_Weight_K_Y_X_C_Output_N_Ho_Wo_K;
+    using DeviceOp = DeviceConvNdFwdNwcKxcNwk_Xdl;
 
     using ADataType = InDataType;
     using BDataType = WeiDataType;
@@ -1027,7 +1045,7 @@ struct DeviceConvNDFwdXdl_Input_N_Hi_Wi_C_Weight_K_Y_X_C_Output_N_Ho_Wo_K
         auto str = std::stringstream();
 
         // clang-format off
-        str << "DeviceConvNDFwdXdl_Input_N_Hi_Wi_C_Weight_K_Y_X_C_Output_N_Ho_Wo_K"
+        str << "DeviceConvNdFwdNwcKxcNwk_Xdl"
             << "<"
             << BlockSize << ", "
             << MPerBlock << ", "

include/ck/tensor_operation/gpu/device/device_gemm.hpp

@@ -46,25 +46,6 @@ struct DeviceGemm : public BaseOperator
     virtual std::unique_ptr<BaseInvoker> MakeInvokerPointer() = 0;
 };
 
-template <typename ALayout,
-          typename BLayout,
-          typename CLayout,
-          typename ADataType,
-          typename BDataType,
-          typename CDataType,
-          typename AElementwiseOperation,
-          typename BElementwiseOperation,
-          typename CElementwiseOperation>
-using DeviceGemmPtr = std::unique_ptr<DeviceGemm<ALayout,
-                                                 BLayout,
-                                                 CLayout,
-                                                 ADataType,
-                                                 BDataType,
-                                                 CDataType,
-                                                 AElementwiseOperation,
-                                                 BElementwiseOperation,
-                                                 CElementwiseOperation>>;
-
 template <typename AElementwiseOperation,
           typename BElementwiseOperation,
           typename CElementwiseOperation>

library/CMakeLists.txt

 add_subdirectory(src/tensor_operation_instance/gpu)
-add_subdirectory(src/host_tensor)
 add_subdirectory(src/utility)

library/include/ck/library/reference_tensor_operation/cpu/reference_conv_fwd.hpp

@@ -8,7 +8,7 @@
 #include <sstream>
 
 #include "ck/tensor_operation/gpu/device/device_base.hpp"
-#include "ck/library/host_tensor/host_tensor.hpp"
+#include "ck/library/utility/host_tensor.hpp"
 
 namespace ck {
 namespace tensor_operation {
@@ -267,7 +267,10 @@ struct ReferenceConvFwd : public device::BaseOperator
         return true;
     }
 
-    bool IsSupportedArgument(const device::BaseArgument*) override { return true; }
+    bool IsSupportedArgument(const device::BaseArgument*) override
+    {
+        return NumDimSpatial >= 1 && NumDimSpatial <= 3;
+    }
 
     static auto MakeArgument(const Tensor<InDataType>& input,
                              const Tensor<WeiDataType>& weight,

library/include/ck/library/utility/check_err.hpp

@@ -13,8 +13,11 @@
 #include <type_traits>
 #include <vector>
 
+#include "ck/ck.hpp"
 #include "ck/utility/data_type.hpp"
 
+#include "ck/library/utility/io.hpp"
+
 namespace ck {
 namespace utils {
 
@@ -201,10 +204,3 @@ check_err(const std::vector<T>& out,
 
 } // namespace utils
 } // namespace ck
-
-template <typename T>
-std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
-{
-    std::copy(std::begin(v), std::end(v), std::ostream_iterator<T>(os, " "));
-    return os;
-}

library/include/ck/library/utility/convolution_parameter.hpp

+// SPDX-License-Identifier: MIT
+// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
+
+#pragma once
+
+#include <cstdlib>
+#include <numeric>
+#include <iterator>
+#include <vector>
+
+#include "ck/ck.hpp"
+
+#include "ck/library/utility/io.hpp"
+
+namespace ck {
+namespace tensor_operation {
+namespace device {
+
+struct ConvParams
+{
+    ConvParams();
+    ConvParams(ck::index_t n_dim,
+               ck::index_t n_batch,
+               ck::index_t n_out_channels,
+               ck::index_t n_in_channels,
+               const std::vector<ck::index_t>& filters_len,
+               const std::vector<ck::index_t>& input_len,
+               const std::vector<ck::index_t>& strides,
+               const std::vector<ck::index_t>& dilations,
+               const std::vector<ck::index_t>& left_pads,
+               const std::vector<ck::index_t>& right_pads);
+
+    ck::index_t num_dim_spatial_;
+    ck::index_t N_;
+    ck::index_t K_;
+    ck::index_t C_;
+
+    std::vector<ck::index_t> filter_spatial_lengths_;
+    std::vector<ck::index_t> input_spatial_lengths_;
+    std::vector<ck::index_t> output_spatial_lengths_;
+
+    std::vector<ck::index_t> conv_filter_strides_;
+    std::vector<ck::index_t> conv_filter_dilations_;
+
+    std::vector<ck::index_t> input_left_pads_;
+    std::vector<ck::index_t> input_right_pads_;
+
+    std::vector<ck::index_t> GetOutputSpatialLengths() const;
+
+    std::size_t GetFlops() const;
+
+    template <typename InDataType, typename WeiDataType, typename OutDataType>
+    std::size_t GetByte() const
+    {
+        // sizeof(InDataType) * (N * C * <input spatial lengths product>) +
+        // sizeof(WeiDataType) * (K * C * <filter spatial lengths product>) +
+        // sizeof(OutDataType) * (N * K * <output spatial lengths product>);
+        return sizeof(InDataType) * (N_ * C_ *
+                                     std::accumulate(std::begin(input_spatial_lengths_),
+                                                     std::end(input_spatial_lengths_),
+                                                     static_cast<std::size_t>(1),
+                                                     std::multiplies<std::size_t>())) +
+               sizeof(WeiDataType) * (K_ * C_ *
+                                      std::accumulate(std::begin(filter_spatial_lengths_),
+                                                      std::end(filter_spatial_lengths_),
+                                                      static_cast<std::size_t>(1),
+                                                      std::multiplies<std::size_t>())) +
+               sizeof(OutDataType) * (N_ * K_ *
+                                      std::accumulate(std::begin(output_spatial_lengths_),
+                                                      std::end(output_spatial_lengths_),
+                                                      static_cast<std::size_t>(1),
+                                                      std::multiplies<std::size_t>()));
+    }
+};
+
+} // namespace device
+} // namespace tensor_operation
+} // namespace ck
+
+std::ostream& operator<<(std::ostream& os, const ck::tensor_operation::device::ConvParams& p);

library/include/ck/library/host_tensor/host_tensor.hpp → library/include/ck/library/utility/host_tensor.hpp

@@ -122,6 +122,22 @@ struct HostTensorDescriptor
     std::vector<std::size_t> mStrides;
 };
 
+template <typename New2Old>
+HostTensorDescriptor transpose_host_tensor_descriptor_given_new2old(const HostTensorDescriptor& a,
+                                                                    const New2Old& new2old)
+{
+    std::vector<std::size_t> new_lengths(a.GetNumOfDimension());
+    std::vector<std::size_t> new_strides(a.GetNumOfDimension());
+
+    for(std::size_t i = 0; i < a.GetNumOfDimension(); i++)
+    {
+        new_lengths[i] = a.GetLengths()[new2old[i]];
+        new_strides[i] = a.GetStrides()[new2old[i]];
+    }
+
+    return HostTensorDescriptor(new_lengths, new_strides);
+}
+
 struct joinable_thread : std::thread
 {
     template <typename... Xs>