[CK_BUILDER] Forward convolution builder improvements (#3179)

Proposed changes
Improve the forward convolution builder implementation and addressed leftover feedback left from PR #3138. Main changes

Refactored tests such that they reflect better the builder pattern. The templates and types for the convolution algorithm concepts are created via factory that facilitates programmatic creation of the device op instances.
Moved tests into anonymous namespace.
The convolution factory had lot of if-else constructs when CK Builder types were converted into CK library types. I had initially trouble in using static_assert in the default branch of switch as the static_assert was evaluated at compile time even for valid types. However, if we change the static_assert to throw "<error message>", it will result in a compile-time error only if the default branch is actually hit. This assumes that the function is consteval. Hence, changed all conversions in the convolution factory to use switch, which is more intuitive.
Removed the explicit device op definition from convolution signature and the corresponding predicate file. The device ops are defined by the corresponding concepts. This allowed to remove lot of boilerplate code from the convolution factory.
Adde inheritance and convolution algorithm specialization to handle device ops that are specialization of a more generic ones. The large tensor support is more naturally expressed by this pattern.
Added support for the FP8 data type.

* WIP: Builder for expected test results.

* Improve ckb fwd conv instance tests.

* clang-format

* Change if-else statements into switch in conv factory.

* Fix clang-formatting.

* Removed unnecessary includes.

* Added missing copyright.

* Remove explicit device op flag from from convolution signature.

* Add missing concept.

* Fix build.

* clang-format

* Add test for building conv fwd FP8 instances.

* Add missing header to instance traits.

* Clean-up recently added instances.

* Introduce inheritance and specialization.

* Use builder to build conv algorithm templates and types.

* clang-format

* Fix conv description tests.

---------

Co-authored-by: John Shumway <john.shumwayjr@gmail.com>

experimental/builder/include/ck_tile/builder/conv_algorithm_concepts.hpp

@@ -95,7 +95,8 @@ concept AccessOrderDescriptor = requires(T t) {
     { t.order } -> std::convertible_to<std::array<size_t, 3>>;
 };
 
-// No requirements yet for a ConvAlgorithm concept.
+// Base requirement for all ConvAlgorithm concepts, i.e., all conv algorithm concepts must meet this
+// concept.
 template <typename T>
 concept ConvAlgorithmDescriptor = std::is_class_v<T>;
 
@@ -183,6 +184,12 @@ concept SpecifiesLoopScheduler = requires {
     { T::loop_scheduler } -> std::convertible_to<PipelineScheduler>;
 };
 
+template <typename T>
+concept SpecifiesLargeTensorSupport = requires {
+    { T::specialization } -> std::convertible_to<ConvAlgorithmSpecialization>;
+    requires T::specialization == ConvAlgorithmSpecialization::LARGE_TENSOR;
+};
+
 /******************************************** */
 /* DL-specific descriptors and requirements   */
 /******************************************** */
@@ -204,9 +211,9 @@ concept DlThreadClusterDescriptor = requires(T t) {
     { t.n1_xs } -> std::convertible_to<std::array<size_t, 2>>;
 };
 
-// Concept for DL block transfer K0_M0_M1_K1 format
+// Concept for DL block transfer
 template <typename T>
-concept DlBlockTransferK0M0M1K1Descriptor = requires(T t) {
+concept DlBlockTransferDescriptor = requires(T t) {
     { t.thread_slice_lengths } -> std::convertible_to<std::array<size_t, 4>>;
     { t.thread_cluster_lengths } -> std::convertible_to<std::array<size_t, 4>>;
     { t.thread_cluster_arrange_order } -> std::convertible_to<std::array<size_t, 4>>;
@@ -216,21 +223,9 @@ concept DlBlockTransferK0M0M1K1Descriptor = requires(T t) {
     { t.dst_vector_tensor_lengths } -> std::convertible_to<std::array<size_t, 4>>;
 };
 
-// Concept for DL block transfer K0_N0_N1_K1 format
+// Concept for DL epilogue
 template <typename T>
-concept DlBlockTransferK0N0N1K1Descriptor = requires(T t) {
-    { t.thread_slice_lengths } -> std::convertible_to<std::array<size_t, 4>>;
-    { t.thread_cluster_lengths } -> std::convertible_to<std::array<size_t, 4>>;
-    { t.thread_cluster_arrange_order } -> std::convertible_to<std::array<size_t, 4>>;
-    { t.src_access_order } -> std::convertible_to<std::array<size_t, 4>>;
-    { t.src_vector_tensor_lengths } -> std::convertible_to<std::array<size_t, 4>>;
-    { t.src_vector_tensor_contiguous_dim_order } -> std::convertible_to<std::array<size_t, 4>>;
-    { t.dst_vector_tensor_lengths } -> std::convertible_to<std::array<size_t, 4>>;
-};
-
-// Concept for DL C thread transfer
-template <typename T>
-concept DlCThreadTransferDescriptor = requires(T t) {
+concept DlEpilogueDescriptor = requires(T t) {
     { t.src_dst_access_order } -> std::convertible_to<std::array<size_t, 6>>;
     { t.src_dst_vector_dim } -> std::convertible_to<size_t>;
     { t.dst_scalar_per_vector } -> std::convertible_to<size_t>;
@@ -239,31 +234,63 @@ concept DlCThreadTransferDescriptor = requires(T t) {
 // Concept to check if algorithm specifies DL thread config
 template <typename T>
 concept SpecifiesDlThreadConfig = requires {
-    { T::dl_thread_config } -> DlThreadConfigDescriptor;
+    { T::thread_config } -> DlThreadConfigDescriptor;
 };
 
 // Concept to check if algorithm specifies DL thread cluster
 template <typename T>
 concept SpecifiesDlThreadCluster = requires {
-    { T::dl_thread_cluster } -> DlThreadClusterDescriptor;
+    { T::thread_cluster } -> DlThreadClusterDescriptor;
 };
 
-// Concept to check if algorithm specifies DL A block transfer
+// Concept to check if algorithm specifies DL block transfer
 template <typename T>
-concept SpecifiesDlBlockTransferA = requires {
-    { T::dl_block_transfer_a } -> DlBlockTransferK0M0M1K1Descriptor;
-};
-
-// Concept to check if algorithm specifies DL B block transfer
-template <typename T>
-concept SpecifiesDlBlockTransferB = requires {
-    { T::dl_block_transfer_b } -> DlBlockTransferK0N0N1K1Descriptor;
+concept SpecifiesDlBlockTransfer = requires {
+    { T::block_transfer_a } -> DlBlockTransferDescriptor;
+    { T::block_transfer_b } -> DlBlockTransferDescriptor;
 };
 
 // Concept to check if algorithm specifies DL C thread transfer
 template <typename T>
-concept SpecifiesDlCThreadTransfer = requires {
-    { T::dl_c_thread_transfer } -> DlCThreadTransferDescriptor;
+concept SpecifiesDlEpilogue = requires {
+    { T::epilogue_c } -> DlEpilogueDescriptor;
 };
 
+/******************************************** */
+/* Concepts for the different device ops */
+/******************************************** */
+
+template <typename T>
+concept DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3 =
+    ConvAlgorithmDescriptor<T> && SpecifiesThreadBlock<T> && SpecifiesGridwiseXdlGemm<T> &&
+    SpecifiesBlockTransfer<T> && SpecifiesLdsTransfer<T> && SpecifiesThreadClusterAccessOrder<T> &&
+    SpecifiesSourceAccessOrder<T> && SpecifiesFwdConcSpecialization<T> &&
+    SpecifiesGemmSpecialization<T> && SpecifiesBlockGemm<T>;
+
+template <typename T>
+concept DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle =
+    ConvAlgorithmDescriptor<T> && SpecifiesThreadBlock<T> && SpecifiesGridwiseXdlGemm<T> &&
+    SpecifiesBlockTransfer<T> && SpecifiesLdsTransfer<T> && SpecifiesThreadClusterAccessOrder<T> &&
+    SpecifiesSourceAccessOrder<T> && SpecifiesFwdConcSpecialization<T> &&
+    SpecifiesGemmSpecialization<T> && SpecifiesNumPrefetchStages<T> &&
+    SpecifiesNumGroupsToMerge<T> && SpecifiesLoopScheduler<T>;
+
+template <typename T>
+concept DeviceGroupedConvFwdMultipleABD_Wmma_CShuffle =
+    ConvAlgorithmDescriptor<T> && SpecifiesThreadBlock<T> && SpecifiesGridwiseWmmaGemm<T> &&
+    SpecifiesBlockTransfer<T> && SpecifiesLdsTransfer<T> && SpecifiesThreadClusterAccessOrder<T> &&
+    SpecifiesSourceAccessOrder<T> && SpecifiesFwdConcSpecialization<T> &&
+    SpecifiesGemmSpecialization<T> && SpecifiesNumPrefetchStages<T> && SpecifiesLoopScheduler<T>;
+
+template <typename T>
+concept DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK =
+    ConvAlgorithmDescriptor<T> && SpecifiesThreadBlock<T> && SpecifiesFwdConcSpecialization<T> &&
+    SpecifiesGemmSpecialization<T> && SpecifiesDlThreadConfig<T> && SpecifiesDlThreadCluster<T> &&
+    SpecifiesDlBlockTransfer<T> && SpecifiesDlEpilogue<T>;
+
+template <typename T>
+concept DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor =
+    DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle<decltype(T::base_algorithm)> &&
+    SpecifiesLargeTensorSupport<T>;
+
 } // namespace ck_tile::builder

experimental/builder/include/ck_tile/builder/conv_factory.hpp

@@ -256,6 +256,19 @@ struct ConvTensorTypes<DataType::I8>
     using EDataType        = int8_t;
 };
 
+template <>
+struct ConvTensorTypes<DataType::FP8>
+{
+    using ADataType        = ck::f8_t;
+    using AComputeType     = ck::f8_t;
+    using BDataType        = ck::f8_t;
+    using BComputeType     = ck::f8_t;
+    using CShuffleDataType = ck::f8_t;
+    using DsDataTypes      = ck::Tuple<>;
+    using AccDataType      = float;
+    using EDataType        = ck::f8_t;
+};
+
 template <ElementwiseOperation T>
 struct ElementwiseOps
 {
@@ -302,49 +315,31 @@ struct BlockGemmSpec
 };
 
 template <ConvAlgorithmDescriptor auto ALGORITHM>
-constexpr BlockGemmSpec SetBlockGemm()
+consteval BlockGemmSpec SetBlockGemm()
 {
     constexpr auto& BG = ALGORITHM.block_gemm;
 
     ck::BlockGemmPipelineScheduler scheduler;
     ck::BlockGemmPipelineVersion version;
 
-    if constexpr(BG.scheduler == PipelineScheduler::INTRAWAVE)
+    switch(BG.scheduler)
     {
-        scheduler = ck::BlockGemmPipelineScheduler::Intrawave;
-    }
-    else if constexpr(BG.scheduler == PipelineScheduler::INTERWAVE)
-    {
-        scheduler = ck::BlockGemmPipelineScheduler::Interwave;
-    }
-    else
-    {
-        static_assert(false, "Unknown PipelineScheduler");
+    case PipelineScheduler::INTRAWAVE: scheduler = ck::BlockGemmPipelineScheduler::Intrawave; break;
+    case PipelineScheduler::INTERWAVE: scheduler = ck::BlockGemmPipelineScheduler::Interwave; break;
+    case PipelineScheduler::DEFAULT: throw "Block GEMM scheduler must be Intrawave or Interwave.";
+    default: throw "Unknown PipelineScheduler";
     }
 
-    if constexpr(BG.pipeline_version == PipelineVersion::V1)
+    switch(BG.pipeline_version)
     {
-        version = ck::BlockGemmPipelineVersion::v1;
-    }
-    else if constexpr(BG.pipeline_version == PipelineVersion::V2)
-    {
-        version = ck::BlockGemmPipelineVersion::v2;
-    }
-    else if constexpr(BG.pipeline_version == PipelineVersion::V3)
-    {
-        version = ck::BlockGemmPipelineVersion::v3;
-    }
-    else if constexpr(BG.pipeline_version == PipelineVersion::V4)
-    {
-        version = ck::BlockGemmPipelineVersion::v4;
-    }
-    else if constexpr(BG.pipeline_version == PipelineVersion::V5)
-    {
-        version = ck::BlockGemmPipelineVersion::v5;
-    }
-    else
-    {
-        static_assert(false, "Unknown PipelineVersion");
+    case PipelineVersion::V1: version = ck::BlockGemmPipelineVersion::v1; break;
+    case PipelineVersion::V2: version = ck::BlockGemmPipelineVersion::v2; break;
+    case PipelineVersion::V3: version = ck::BlockGemmPipelineVersion::v3; break;
+    case PipelineVersion::V4: version = ck::BlockGemmPipelineVersion::v4; break;
+    case PipelineVersion::V5: version = ck::BlockGemmPipelineVersion::v5; break;
+    case PipelineVersion::WEIGHT_ONLY:
+        throw "PipelineVersion::WEIGHT_ONLY is not supported for block GEMM.";
+    default: throw "Unknown PipelineVersion";
     }
 
     return BlockGemmSpec{.pipeline_version = version, .scheduler = scheduler};
@@ -453,18 +448,13 @@ template <ConvAlgorithmDescriptor auto ALGORITHM>
 consteval ck::LoopScheduler SetLoopScheduler()
 {
     constexpr auto loop_scheduler = ALGORITHM.loop_scheduler;
-
-    if constexpr(loop_scheduler == PipelineScheduler::DEFAULT)
+    using ck_loop_sched           = ck::LoopScheduler;
+    switch(loop_scheduler)
     {
-        return ck::LoopScheduler::Default;
-    }
-    else if constexpr(loop_scheduler == PipelineScheduler::INTERWAVE)
-    {
-        return ck::LoopScheduler::Interwave;
-    }
-    else
-    {
-        static_assert(false, "Unknown PipelineScheduler");
+    case PipelineScheduler::DEFAULT: return ck_loop_sched::Default;
+    case PipelineScheduler::INTERWAVE: return ck_loop_sched::Interwave;
+    case PipelineScheduler::INTRAWAVE: throw "LoopScheduler must be either DEFAULT or INTERWAVE.";
+    default: throw "Unknown PipelineScheduler";
     }
 }
 
@@ -472,29 +462,16 @@ template <ConvAlgorithmDescriptor auto ALGORITHM>
 consteval ck::PipelineVersion SetGridwiseGemmPipelineVersion()
 {
     constexpr auto pipeline_version = ALGORITHM.gridwise_gemm.pipeline_version;
-    if constexpr(pipeline_version == PipelineVersion::V1)
+    using ck_pipeline               = ck::PipelineVersion;
+    switch(pipeline_version)
     {
-        return ck::PipelineVersion::v1;
-    }
-    else if constexpr(pipeline_version == PipelineVersion::V2)
-    {
-        return ck::PipelineVersion::v2;
-    }
-    else if constexpr(pipeline_version == PipelineVersion::V3)
-    {
-        static_assert(false, "V3 is used only for stream-K.");
-    }
-    else if constexpr(pipeline_version == PipelineVersion::V4)
-    {
-        return ck::PipelineVersion::v4;
-    }
-    else if constexpr(pipeline_version == PipelineVersion::WEIGHT_ONLY)
-    {
-        return ck::PipelineVersion::weight_only;
-    }
-    else
-    {
-        static_assert(false, "Unknown PipelineVersion");
+    case PipelineVersion::V1: return ck_pipeline::v1;
+    case PipelineVersion::V2: return ck_pipeline::v2;
+    case PipelineVersion::V3: throw "PipelineVersion::V3 is used only for stream-K.";
+    case PipelineVersion::V4: return ck_pipeline::v4;
+    case PipelineVersion::V5: throw "PipelineVersion::V5 cannot be used for gridwise GEMM.";
+    case PipelineVersion::WEIGHT_ONLY: return ck_pipeline::weight_only;
+    default: throw "Unknown GridwiseGemmPipelineVersion";
     }
 }
 
@@ -502,74 +479,27 @@ template <ConvAlgorithmDescriptor auto ALGORITHM>
 consteval ck::tensor_operation::device::GemmSpecialization SetGemmSpecialization()
 {
     constexpr auto gemm_spec = ALGORITHM.gemm_specialization;
+    using ck_gemm_spec       = ck::tensor_operation::device::GemmSpecialization;
 
-    if constexpr(gemm_spec == GemmSpecialization::Default)
+    switch(gemm_spec)
     {
-        return ck::tensor_operation::device::GemmSpecialization::Default;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::MPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::MPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::NPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::NPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::KPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::KPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::MNPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::MNPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::MKPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::MKPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::NKPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::NKPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::MNKPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::MNKPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::OPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::OPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::MOPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::MOPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::NOPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::NOPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::KOPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::KOPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::MNOPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::MNOPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::MKOPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::MKOPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::NKOPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::NKOPadding;
-    }
-    else if constexpr(gemm_spec == GemmSpecialization::MNKOPadding)
-    {
-        return ck::tensor_operation::device::GemmSpecialization::MNKOPadding;
-    }
-    else
-    {
-        static_assert(false, "Unknown GemmSpecialization");
+    case GemmSpecialization::Default: return ck_gemm_spec::Default;
+    case GemmSpecialization::MPadding: return ck_gemm_spec::MPadding;
+    case GemmSpecialization::NPadding: return ck_gemm_spec::NPadding;
+    case GemmSpecialization::KPadding: return ck_gemm_spec::KPadding;
+    case GemmSpecialization::MNPadding: return ck_gemm_spec::MNPadding;
+    case GemmSpecialization::MKPadding: return ck_gemm_spec::MKPadding;
+    case GemmSpecialization::NKPadding: return ck_gemm_spec::NKPadding;
+    case GemmSpecialization::MNKPadding: return ck_gemm_spec::MNKPadding;
+    case GemmSpecialization::OPadding: return ck_gemm_spec::OPadding;
+    case GemmSpecialization::MOPadding: return ck_gemm_spec::MOPadding;
+    case GemmSpecialization::NOPadding: return ck_gemm_spec::NOPadding;
+    case GemmSpecialization::KOPadding: return ck_gemm_spec::KOPadding;
+    case GemmSpecialization::MNOPadding: return ck_gemm_spec::MNOPadding;
+    case GemmSpecialization::MKOPadding: return ck_gemm_spec::MKOPadding;
+    case GemmSpecialization::NKOPadding: return ck_gemm_spec::NKOPadding;
+    case GemmSpecialization::MNKOPadding: return ck_gemm_spec::MNKOPadding;
+    default: throw "Unknown GemmSpecialization";
     }
 }
 
@@ -577,30 +507,15 @@ template <ConvAlgorithmDescriptor auto ALGORITHM>
 consteval ck::BlockGemmPipelineVersion SetBlockGemmPipelineVersion()
 {
     constexpr auto version = ALGORITHM.pipeline_version;
-
-    if constexpr(version == PipelineVersion::V1)
+    using ck_pipeline      = ck::BlockGemmPipelineVersion;
+    switch(version)
     {
-        return ck::BlockGemmPipelineVersion::v1;
-    }
-    else if constexpr(version == PipelineVersion::V2)
-    {
-        return ck::BlockGemmPipelineVersion::v2;
-    }
-    else if constexpr(version == PipelineVersion::V3)
-    {
-        return ck::BlockGemmPipelineVersion::v3;
-    }
-    else if constexpr(version == PipelineVersion::V4)
-    {
-        return ck::BlockGemmPipelineVersion::v4;
-    }
-    else if constexpr(version == PipelineVersion::V5)
-    {
-        return ck::BlockGemmPipelineVersion::v5;
-    }
-    else
-    {
-        static_assert(false, "Unknown PipelineVersion");
+    case PipelineVersion::V1: return ck_pipeline::v1;
+    case PipelineVersion::V2: return ck_pipeline::v2;
+    case PipelineVersion::V3: return ck_pipeline::v3;
+    case PipelineVersion::V4: return ck_pipeline::v4;
+    case PipelineVersion::V5: return ck_pipeline::v5;
+    default: throw "Unknown block GEMM PipelineVersion";
     }
 }
 
@@ -608,26 +523,14 @@ template <ConvAlgorithmDescriptor auto ALGORITHM>
 consteval ck::tensor_operation::device::ConvolutionForwardSpecialization SetFwdConvSpecialization()
 {
     constexpr auto specialization = ALGORITHM.fwd_specialization;
-
-    if constexpr(specialization == ConvFwdSpecialization::DEFAULT)
+    using ck_conv_spec            = ck::tensor_operation::device::ConvolutionForwardSpecialization;
+    switch(specialization)
     {
-        return ck::tensor_operation::device::ConvolutionForwardSpecialization::Default;
-    }
-    else if constexpr(specialization == ConvFwdSpecialization::FILTER_1X1_PAD0)
-    {
-        return ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Pad0;
-    }
-    else if constexpr(specialization == ConvFwdSpecialization::FILTER_1X1_STRIDE1_PAD0)
-    {
-        return ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter1x1Stride1Pad0;
-    }
-    else if constexpr(specialization == ConvFwdSpecialization::FILTER_3x3)
-    {
-        return ck::tensor_operation::device::ConvolutionForwardSpecialization::Filter3x3;
-    }
-    else
-    {
-        static_assert(false, "Unknown ConvFwdSpecialization");
+    case ConvFwdSpecialization::DEFAULT: return ck_conv_spec::Default;
+    case ConvFwdSpecialization::FILTER_1X1_PAD0: return ck_conv_spec::Filter1x1Pad0;
+    case ConvFwdSpecialization::FILTER_1X1_STRIDE1_PAD0: return ck_conv_spec::Filter1x1Stride1Pad0;
+    case ConvFwdSpecialization::FILTER_3x3: return ck_conv_spec::Filter3x3;
+    default: throw "Unknown ConvFwdSpecialization";
     }
 }
 
@@ -639,7 +542,12 @@ namespace ck_tile::builder {
 template <ConvSignatureDescriptor auto SIGNATURE,
           ConvAlgorithmDescriptor auto ALGORITHM,
           auto VERSION>
-struct ConvFactory;
+struct ConvFactory
+{
+    // This will trigger if a specialization for the given convolution direction is not found.
+    // We should always catch this in an earlier validation check.
+    static_assert(false, "Unsupported device operation.");
+};
 
 // Factory specialization for DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3 instance
 // of a grouped forward convolution kernel.
@@ -647,7 +555,7 @@ template <ConvSignatureDescriptor auto SIGNATURE,
           ConvAlgorithmDescriptor auto ALGORITHM,
           StringLiteral VERSION>
     requires ConvDirectionIsForward<SIGNATURE> &&
-             ConvDeviceOpIs_DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3<SIGNATURE>
+             DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3<decltype(ALGORITHM)>
 struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
 {
     static constexpr size_t SPATIAL_DIM = SIGNATURE.spatial_dim;
@@ -658,26 +566,6 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
     using Ops           = factory_internal::ElementwiseOps<SIGNATURE.elementwise_operation>;
     using AlgorithmType = decltype(ALGORITHM);
 
-    static_assert(SpecifiesThreadBlock<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify thread block info.");
-    static_assert(SpecifiesGridwiseXdlGemm<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify gridwise GEMM info.");
-    static_assert(SpecifiesBlockTransfer<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify block transfer info.");
-    static_assert(SpecifiesLdsTransfer<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify LDS transfer info.");
-    static_assert(
-        SpecifiesThreadClusterAccessOrder<AlgorithmType>,
-        "The convolution algorithm descriptor must specify thread cluster access order info.");
-    static_assert(SpecifiesSourceAccessOrder<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify source access order info.");
-    static_assert(SpecifiesBlockGemm<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify block gemm pipeline.");
-    static_assert(SpecifiesFwdConcSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify forward convolution "
-                  "specialization.");
-    static_assert(SpecifiesGemmSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify gemm specialization.");
     static_assert(ALGORITHM.block_transfer.lds_transfer_a.is_direct_load ==
                       ALGORITHM.block_transfer.lds_transfer_b.is_direct_load,
                   "A and B block transfers must both be direct load or not.");
@@ -769,7 +657,7 @@ template <ConvSignatureDescriptor auto SIGNATURE,
           ConvAlgorithmDescriptor auto ALGORITHM,
           StringLiteral VERSION>
     requires ConvDirectionIsForward<SIGNATURE> &&
-             ConvDeviceOpIs_DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle<SIGNATURE>
+             DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle<decltype(ALGORITHM)>
 struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
 {
     static constexpr size_t SPATIAL_DIM = SIGNATURE.spatial_dim;
@@ -780,31 +668,6 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
     using Ops           = factory_internal::ElementwiseOps<SIGNATURE.elementwise_operation>;
     using AlgorithmType = decltype(ALGORITHM);
 
-    static_assert(SpecifiesThreadBlock<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify thread block info.");
-    static_assert(SpecifiesGridwiseXdlGemm<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify gridwise GEMM info.");
-    static_assert(SpecifiesBlockTransfer<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify block transfer info.");
-    static_assert(SpecifiesLdsTransfer<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify LDS transfer info.");
-    static_assert(
-        SpecifiesThreadClusterAccessOrder<AlgorithmType>,
-        "The convolution algorithm descriptor must specify thread cluster access order info.");
-    static_assert(SpecifiesSourceAccessOrder<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify source access order info.");
-    static_assert(SpecifiesFwdConcSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify forward convolution "
-                  "specialization.");
-    static_assert(SpecifiesGemmSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify gemm specialization.");
-    static_assert(SpecifiesNumPrefetchStages<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify number of prefetch stages.");
-    static_assert(SpecifiesLoopScheduler<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify loop scheduler.");
-    static_assert(SpecifiesNumGroupsToMerge<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify number of groups to merge.");
-
     static constexpr auto FWD_CONV_SPECIALIZATION =
         factory_internal::SetFwdConvSpecialization<ALGORITHM>();
     static constexpr auto GEMM_SPECIALIZATION =
@@ -891,7 +754,7 @@ template <ConvSignatureDescriptor auto SIGNATURE,
           ConvAlgorithmDescriptor auto ALGORITHM,
           StringLiteral VERSION>
     requires ConvDirectionIsForward<SIGNATURE> &&
-             ConvDeviceOpIs_DeviceGroupedConvFwdMultipleD_Wmma_CShuffle<SIGNATURE>
+             DeviceGroupedConvFwdMultipleABD_Wmma_CShuffle<decltype(ALGORITHM)>
 struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
 {
     static constexpr size_t SPATIAL_DIM = SIGNATURE.spatial_dim;
@@ -902,27 +765,6 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
     using Ops           = factory_internal::ElementwiseOps<SIGNATURE.elementwise_operation>;
     using AlgorithmType = decltype(ALGORITHM);
 
-    static_assert(SpecifiesThreadBlock<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify thread block info.");
-    static_assert(SpecifiesGridwiseWmmaGemm<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify gridwise GEMM info.");
-    static_assert(SpecifiesBlockTransfer<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify block transfer info.");
-    static_assert(SpecifiesLdsTransfer<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify LDS transfer info.");
-    static_assert(
-        SpecifiesThreadClusterAccessOrder<AlgorithmType>,
-        "The convolution algorithm descriptor must specify thread cluster access order info.");
-    static_assert(SpecifiesSourceAccessOrder<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify source access order info.");
-    static_assert(SpecifiesFwdConcSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify forward convolution "
-                  "specialization.");
-    static_assert(SpecifiesNumPrefetchStages<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify number of prefetch stages.");
-    static_assert(SpecifiesLoopScheduler<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify loop scheduler.");
-
     static constexpr auto FWD_CONV_SPECIALIZATION =
         factory_internal::SetFwdConvSpecialization<ALGORITHM>();
     static constexpr auto GEMM_SPECIALIZATION =
@@ -1008,7 +850,7 @@ template <ConvSignatureDescriptor auto SIGNATURE,
           ConvAlgorithmDescriptor auto ALGORITHM,
           StringLiteral VERSION>
     requires ConvDirectionIsForward<SIGNATURE> &&
-             ConvDeviceOpIs_DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK<SIGNATURE>
+             DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK<decltype(ALGORITHM)>
 struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
 {
     static constexpr size_t SPATIAL_DIM = SIGNATURE.spatial_dim;
@@ -1019,24 +861,6 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
     using Ops           = factory_internal::ElementwiseOps<SIGNATURE.elementwise_operation>;
     using AlgorithmType = decltype(ALGORITHM);
 
-    static_assert(SpecifiesThreadBlock<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify thread block info.");
-    static_assert(SpecifiesFwdConcSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify forward convolution "
-                  "specialization.");
-    static_assert(SpecifiesGemmSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify gemm specialization.");
-    static_assert(SpecifiesDlThreadConfig<AlgorithmType>,
-                  "DL algorithm must specify thread config.");
-    static_assert(SpecifiesDlThreadCluster<AlgorithmType>,
-                  "DL algorithm must specify thread cluster.");
-    static_assert(SpecifiesDlBlockTransferA<AlgorithmType>,
-                  "DL algorithm must specify A block transfer.");
-    static_assert(SpecifiesDlBlockTransferB<AlgorithmType>,
-                  "DL algorithm must specify B block transfer.");
-    static_assert(SpecifiesDlCThreadTransfer<AlgorithmType>,
-                  "DL algorithm must specify C thread transfer.");
-
     static constexpr auto FWD_CONV_SPECIALIZATION =
         factory_internal::SetFwdConvSpecialization<ALGORITHM>();
     static constexpr auto GEMM_SPECIALIZATION =
@@ -1045,7 +869,7 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
     static constexpr auto BLOCK = factory_internal::SetThreadBlockInfo<ALGORITHM>();
 
     // DL-specific parameters from algorithm descriptor
-    static constexpr auto DL_THREAD_CFG      = ALGORITHM.dl_thread_config;
+    static constexpr auto DL_THREAD_CFG      = ALGORITHM.thread_config;
     static constexpr ck::index_t K0PerBlock  = DL_THREAD_CFG.k0_per_block;
     static constexpr ck::index_t K1          = DL_THREAD_CFG.k1;
     static constexpr ck::index_t M1PerThread = DL_THREAD_CFG.m1_per_thread;
@@ -1053,12 +877,12 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
     static constexpr ck::index_t KPerThread  = DL_THREAD_CFG.k_per_thread;
 
     // Thread cluster from descriptor
-    static constexpr auto DL_CLUSTER = ALGORITHM.dl_thread_cluster;
+    static constexpr auto DL_CLUSTER = ALGORITHM.thread_cluster;
     using M1N1ThreadClusterM1Xs      = to_sequence_v<DL_CLUSTER.m1_xs>;
     using M1N1ThreadClusterN1Xs      = to_sequence_v<DL_CLUSTER.n1_xs>;
 
     // A Block Transfer from descriptor - K0_M0_M1_K1 tensor format
-    static constexpr auto DL_A_TRANSFER = ALGORITHM.dl_block_transfer_a;
+    static constexpr auto DL_A_TRANSFER = ALGORITHM.block_transfer_a;
     using ABlockTransferThreadSliceLengths_K0_M0_M1_K1 =
         to_sequence_v<DL_A_TRANSFER.thread_slice_lengths>;
     using ABlockTransferThreadClusterLengths_K0_M0_M1_K1 =
@@ -1074,7 +898,7 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
         to_sequence_v<DL_A_TRANSFER.dst_vector_tensor_lengths>;
 
     // B Block Transfer from descriptor - K0_N0_N1_K1 tensor format
-    static constexpr auto DL_B_TRANSFER = ALGORITHM.dl_block_transfer_b;
+    static constexpr auto DL_B_TRANSFER = ALGORITHM.block_transfer_b;
     using BBlockTransferThreadSliceLengths_K0_N0_N1_K1 =
         to_sequence_v<DL_B_TRANSFER.thread_slice_lengths>;
     using BBlockTransferThreadClusterLengths_K0_N0_N1_K1 =
@@ -1090,7 +914,7 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
         to_sequence_v<DL_B_TRANSFER.dst_vector_tensor_lengths>;
 
     // C Thread Transfer from descriptor
-    static constexpr auto DL_C_TRANSFER    = ALGORITHM.dl_c_thread_transfer;
+    static constexpr auto DL_C_TRANSFER    = ALGORITHM.epilogue_c;
     using CThreadTransferSrcDstAccessOrder = to_sequence_v<DL_C_TRANSFER.src_dst_access_order>;
     static constexpr ck::index_t CThreadTransferSrcDstVectorDim = DL_C_TRANSFER.src_dst_vector_dim;
     static constexpr ck::index_t CThreadTransferDstScalarPerVector =
@@ -1148,7 +972,7 @@ template <ConvSignatureDescriptor auto SIGNATURE,
           ConvAlgorithmDescriptor auto ALGORITHM,
           StringLiteral VERSION>
     requires ConvDirectionIsForward<SIGNATURE> &&
-             ConvDeviceOpIs_DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor<SIGNATURE>
+             DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor<decltype(ALGORITHM)>
 struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
 {
     static constexpr size_t SPATIAL_DIM = SIGNATURE.spatial_dim;
@@ -1159,45 +983,24 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
     using Ops           = factory_internal::ElementwiseOps<SIGNATURE.elementwise_operation>;
     using AlgorithmType = decltype(ALGORITHM);
 
-    static_assert(SpecifiesThreadBlock<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify thread block info.");
-    static_assert(SpecifiesGridwiseXdlGemm<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify gridwise GEMM info.");
-    static_assert(SpecifiesBlockTransfer<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify block transfer info.");
-    static_assert(SpecifiesLdsTransfer<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify LDS transfer info.");
-    static_assert(
-        SpecifiesThreadClusterAccessOrder<AlgorithmType>,
-        "The convolution algorithm descriptor must specify thread cluster access order info.");
-    static_assert(SpecifiesSourceAccessOrder<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify source access order info.");
-    static_assert(SpecifiesFwdConcSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify forward convolution "
-                  "specialization.");
-    static_assert(SpecifiesGemmSpecialization<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify gemm specialization.");
-    static_assert(SpecifiesNumPrefetchStages<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify number of prefetch stages.");
-    static_assert(SpecifiesLoopScheduler<AlgorithmType>,
-                  "The convolution algorithm descriptor must specify loop scheduler.");
+    static constexpr auto BASE_ALGORITHM = ALGORITHM.base_algorithm;
 
     static constexpr auto FWD_CONV_SPECIALIZATION =
-        factory_internal::SetFwdConvSpecialization<ALGORITHM>();
+        factory_internal::SetFwdConvSpecialization<BASE_ALGORITHM>();
     static constexpr auto GEMM_SPECIALIZATION =
-        factory_internal::SetGemmSpecialization<ALGORITHM>();
+        factory_internal::SetGemmSpecialization<BASE_ALGORITHM>();
     static constexpr factory_internal::ConvSpec SPECIALIZATION{.conv_spec = FWD_CONV_SPECIALIZATION,
                                                                .gemm_spec = GEMM_SPECIALIZATION};
 
-    static constexpr auto LOOP_SCHEDULER = factory_internal::SetLoopScheduler<ALGORITHM>();
-    static constexpr auto BLOCK          = factory_internal::SetThreadBlockInfo<ALGORITHM>();
-    static constexpr auto GRIDWISE_GEMM  = ALGORITHM.gridwise_gemm;
+    static constexpr auto LOOP_SCHEDULER = factory_internal::SetLoopScheduler<BASE_ALGORITHM>();
+    static constexpr auto BLOCK          = factory_internal::SetThreadBlockInfo<BASE_ALGORITHM>();
+    static constexpr auto GRIDWISE_GEMM  = BASE_ALGORITHM.gridwise_gemm;
     static constexpr auto A_BLOCK_TRANSFER =
-        factory_internal::SetFwdConvABlockTransfer<ALGORITHM>();
+        factory_internal::SetFwdConvABlockTransfer<BASE_ALGORITHM>();
     static constexpr auto B_BLOCK_TRANSFER =
-        factory_internal::SetFwdConvBBlockTransfer<ALGORITHM>();
+        factory_internal::SetFwdConvBBlockTransfer<BASE_ALGORITHM>();
     static constexpr auto C_BLOCK_TRANSFER =
-        factory_internal::SetCBlockTransfer<SIGNATURE, ALGORITHM>();
+        factory_internal::SetCBlockTransfer<SIGNATURE, BASE_ALGORITHM>();
 
     // Check limits for the algorithm parameters.
     static_assert(InputVectorTransferLimits<A_BLOCK_TRANSFER>);
@@ -1227,7 +1030,7 @@ struct ConvFactory<SIGNATURE, ALGORITHM, VERSION>
             typename Ops::CDEElementwiseOp,
             SPECIALIZATION.conv_spec,
             SPECIALIZATION.gemm_spec,
-            ALGORITHM.num_gemm_k_prefetch_stages,
+            BASE_ALGORITHM.num_gemm_k_prefetch_stages,
             BLOCK.block_size,
             BLOCK.per_block.m,
             BLOCK.per_block.n,

experimental/builder/include/ck_tile/builder/conv_signature_concepts.hpp

@@ -21,7 +21,6 @@
 #include <type_traits>
 
 #include "ck_tile/builder/types.hpp"
-#include "ck_tile/builder/conv_signature_predicates.hpp"
 
 namespace ck_tile::builder {
 
@@ -41,9 +40,6 @@ template <DataType T>
 concept ConvDataType = (T == DataType::FP32) || (T == DataType::FP16) || (T == DataType::BF16) ||
                        (T == DataType::FP8) || (T == DataType::I8) || (T == DataType::U8);
 
-template <typename T>
-concept ConvDeviceOp = std::same_as<std::remove_cvref_t<T>, GroupConvDeviceOp>;
-
 template <typename T>
 concept ConvLayout = std::same_as<std::remove_cvref_t<T>, GroupConvLayout>;
 
@@ -55,7 +51,6 @@ concept ConvSignatureDescriptor = requires(T t) {
     { t.layout } -> ConvLayout;
     { t.data_type } -> std::convertible_to<DataType>;
     { t.elementwise_operation } -> std::convertible_to<ElementwiseOperation>;
-    { t.device_operation } -> ConvDeviceOp;
 };
 
 // Concept to validate a convolution signature's values.
@@ -63,7 +58,18 @@ template <auto Sig>
 concept ValidConvSignature = requires {
     requires ConvSpatialDim<Sig.spatial_dim>;
     requires ConvDataType<Sig.data_type>;
-    requires IsValidConvDeviceOp<Sig>;
 };
 
+// Predicate for forward convolution.
+template <auto Sig>
+concept ConvDirectionIsForward = (Sig.direction == ConvDirection::FORWARD);
+
+// Predicate for backward data convolution.
+template <auto Sig>
+concept ConvDirectionIsBackwardData = (Sig.direction == ConvDirection::BACKWARD_DATA);
+
+// Predicate for backward weight convolution.
+template <auto Sig>
+concept ConvDirectionIsBackwardWeight = (Sig.direction == ConvDirection::BACKWARD_WEIGHT);
+
 } // namespace ck_tile::builder

experimental/builder/include/ck_tile/builder/conv_signature_predicates.hpp

@@ -1,190 +0,0 @@
-// Copyright (C) Advanced Micro Devices, Inc., or its affiliates.
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <concepts>
-#include <type_traits>
-
-#include "ck_tile/builder/types.hpp"
-
-namespace ck_tile::builder {
-
-/**********************************************
- * Conv Direction Predicates
- **********************************************/
-
-// Predicate for forward convolution.
-template <auto Sig>
-concept ConvDirectionIsForward = (Sig.direction == ConvDirection::FORWARD);
-
-// Predicate for backward data convolution.
-template <auto Sig>
-concept ConvDirectionIsBackwardData = (Sig.direction == ConvDirection::BACKWARD_DATA);
-
-// Predicate for backward weight convolution.
-template <auto Sig>
-concept ConvDirectionIsBackwardWeight = (Sig.direction == ConvDirection::BACKWARD_WEIGHT);
-
-/**********************************************
- * Conv Fwd Device Op Predicates
- **********************************************/
-
-// Predicate for DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3 operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3 =
-    ConvDirectionIsForward<Sig> &&
-    (Sig.device_operation._fwd ==
-     FwdGroupConvDeviceOperation::DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3);
-
-// Predicate for DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK =
-    ConvDirectionIsForward<Sig> &&
-    (Sig.device_operation._fwd ==
-     FwdGroupConvDeviceOperation::DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK);
-
-// Predicate for DeviceGroupedConvFwdMultipleD_Wmma_CShuffle operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvFwdMultipleD_Wmma_CShuffle =
-    ConvDirectionIsForward<Sig> &&
-    (Sig.device_operation._fwd ==
-     FwdGroupConvDeviceOperation::DeviceGroupedConvFwdMultipleD_Wmma_CShuffle);
-
-// Predicate for DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle =
-    ConvDirectionIsForward<Sig> &&
-    (Sig.device_operation._fwd ==
-     FwdGroupConvDeviceOperation::DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle);
-
-// Predicate for DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor =
-    ConvDirectionIsForward<Sig> &&
-    (Sig.device_operation._fwd ==
-     FwdGroupConvDeviceOperation::DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor);
-
-// Generic predicate to check if signature uses any forward convolution device operation.
-template <auto Sig>
-concept ConvDeviceOpIsForward =
-    ConvDeviceOpIs_DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvFwdMultipleD_Wmma_CShuffle<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor<Sig>;
-
-/**********************************************
- * Conv Bwd Weight Device Op Predicates
- **********************************************/
-
-// Predicate for DeviceGroupedConvBwdWeight operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdWeight =
-    ConvDirectionIsBackwardWeight<Sig> &&
-    (Sig.device_operation._bwd_weight ==
-     BwdWeightGroupConvDeviceOperation::DeviceGroupedConvBwdWeight);
-
-// Predicate for DeviceGroupedConvBwdWeightMultipleD_Xdl_CShuffle operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdWeightMultipleD_Xdl_CShuffle =
-    ConvDirectionIsBackwardWeight<Sig> &&
-    (Sig.device_operation._bwd_weight ==
-     BwdWeightGroupConvDeviceOperation::DeviceGroupedConvBwdWeightMultipleD_Xdl_CShuffle);
-
-// Predicate for DeviceGroupedConvBwdWeight_Xdl_CShuffle operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdWeight_Xdl_CShuffle =
-    ConvDirectionIsBackwardWeight<Sig> &&
-    (Sig.device_operation._bwd_weight ==
-     BwdWeightGroupConvDeviceOperation::DeviceGroupedConvBwdWeight_Xdl_CShuffle);
-
-// Predicate for DeviceGroupedConvBwdWeightTwoStage_Xdl_CShuffle operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdWeightTwoStage_Xdl_CShuffle =
-    ConvDirectionIsBackwardWeight<Sig> &&
-    (Sig.device_operation._bwd_weight ==
-     BwdWeightGroupConvDeviceOperation::DeviceGroupedConvBwdWeightTwoStage_Xdl_CShuffle);
-
-// Predicate for DeviceGroupedConvBwdWeight_Wmma_CShuffle operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdWeight_Wmma_CShuffle =
-    ConvDirectionIsBackwardWeight<Sig> &&
-    (Sig.device_operation._bwd_weight ==
-     BwdWeightGroupConvDeviceOperation::DeviceGroupedConvBwdWeight_Wmma_CShuffle);
-
-// Predicate for DeviceGroupedConvBwdWeight_Xdl_CShuffleV3 operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdWeight_Xdl_CShuffleV3 =
-    ConvDirectionIsBackwardWeight<Sig> &&
-    (Sig.device_operation._bwd_weight ==
-     BwdWeightGroupConvDeviceOperation::DeviceGroupedConvBwdWeight_Xdl_CShuffleV3);
-
-// Predicate for DeviceGroupedConvBwdWeightMultipleD operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdWeightMultipleD =
-    ConvDirectionIsBackwardWeight<Sig> &&
-    (Sig.device_operation._bwd_weight ==
-     BwdWeightGroupConvDeviceOperation::DeviceGroupedConvBwdWeightMultipleD);
-
-// Predicate for DeviceGroupedConvBwdWeight_Dl operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdWeight_Dl =
-    ConvDirectionIsBackwardWeight<Sig> &&
-    (Sig.device_operation._bwd_weight ==
-     BwdWeightGroupConvDeviceOperation::DeviceGroupedConvBwdWeight_Dl);
-
-// Generic predicate to check if signature uses any backward weight convolution device operation.
-template <auto Sig>
-concept ConvDeviceOpIsBackwardWeight =
-    ConvDeviceOpIs_DeviceGroupedConvBwdWeight<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdWeightMultipleD_Xdl_CShuffle<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdWeight_Xdl_CShuffle<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdWeightTwoStage_Xdl_CShuffle<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdWeight_Wmma_CShuffle<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdWeight_Xdl_CShuffleV3<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdWeightMultipleD<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdWeight_Dl<Sig>;
-
-/**********************************************
- * Conv Bwd Data Device Op Predicates
- **********************************************/
-
-// Predicate for DeviceGroupedConvBwdDataMultipleD_Xdl_CShuffle_v1 operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdDataMultipleD_Xdl_CShuffle_v1 =
-    ConvDirectionIsBackwardData<Sig> &&
-    (Sig.device_operation._bwd_data ==
-     BwdDataGroupConvDeviceOperation::DeviceGroupedConvBwdDataMultipleD_Xdl_CShuffle_v1);
-
-// Predicate for DeviceGroupedConvBwdDataMultipleD operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdDataMultipleD =
-    ConvDirectionIsBackwardData<Sig> &&
-    (Sig.device_operation._bwd_data ==
-     BwdDataGroupConvDeviceOperation::DeviceGroupedConvBwdDataMultipleD);
-
-// Predicate for DeviceGroupedConvBwdDataMultipleD_Wmma_CShuffle operation.
-template <auto Sig>
-concept ConvDeviceOpIs_DeviceGroupedConvBwdDataMultipleD_Wmma_CShuffle =
-    ConvDirectionIsBackwardData<Sig> &&
-    (Sig.device_operation._bwd_data ==
-     BwdDataGroupConvDeviceOperation::DeviceGroupedConvBwdDataMultipleD_Wmma_CShuffle);
-
-// Generic predicate to check if signature uses any backward data convolution device operation.
-template <auto Sig>
-concept ConvDeviceOpIsBackwardData =
-    ConvDeviceOpIs_DeviceGroupedConvBwdDataMultipleD_Xdl_CShuffle_v1<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdDataMultipleD<Sig> ||
-    ConvDeviceOpIs_DeviceGroupedConvBwdDataMultipleD_Wmma_CShuffle<Sig>;
-
-/**********************************************
- * Generic Device Op Predicates
- **********************************************/
-
-// Generic predicate to check if signature uses any device operation.
-template <auto Sig>
-concept IsValidConvDeviceOp = ConvDeviceOpIsForward<Sig> || ConvDeviceOpIsBackwardData<Sig> ||
-                              ConvDeviceOpIsBackwardWeight<Sig>;
-
-} // namespace ck_tile::builder

experimental/builder/include/ck_tile/builder/device_op_types.hpp

@@ -1,22 +0,0 @@
-// Copyright (C) Advanced Micro Devices, Inc., or its affiliates.
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-namespace ck_tile::builder {
-
-// Enumeration for CK Device Operation types.
-// This allows the builder to select which device operation template to instantiate
-// based on the user's requirements.
-enum class DeviceOpType
-{
-    // Forward Convolution - Non-grouped
-    CONV_FWD, // Maps to: DeviceConvFwd (TODO: No implementation with tuning params exists yet)
-
-    // Forward Convolution - Grouped
-    GROUPED_CONV_FWD_MULTIPLE_ABD, // Maps to: DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle
-    GROUPED_CONV_FWD_MULTIPLE_ABD_XDL_CSHUFFLE_V3, // Maps to:
-                                                   // DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3
-};
-
-} // namespace ck_tile::builder

experimental/builder/include/ck_tile/builder/reflect/instance_traits_device_grouped_conv_fwd_dl_multiple_d_nhwc_kyxc_nhwk.hpp

@@ -14,6 +14,7 @@
 #pragma once
 
 #include "instance_traits.hpp"
+#include "instance_traits_util.hpp"
 
 // Forward declaration to avoid circular dependency.
 // This file will be included by the device implementation header, so we cannot include

experimental/builder/include/ck_tile/builder/types.hpp

@@ -74,52 +74,6 @@ enum class ConvDirection
     BACKWARD_WEIGHT
 };
 
-// Forward convolution device operations.
-enum class FwdGroupConvDeviceOperation
-{
-    DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK,
-    DeviceGroupedConvFwdMultipleD_Wmma_CShuffle,
-    DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle,
-    DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3,
-    DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor
-};
-
-// Backward data convolution device operations.
-enum class BwdDataGroupConvDeviceOperation
-{
-    DeviceGroupedConvBwdDataMultipleD,
-    DeviceGroupedConvBwdDataMultipleD_Wmma_CShuffle,
-    DeviceGroupedConvBwdDataMultipleD_Xdl_CShuffle_v1
-};
-
-// Backward weight convolution device operations.
-enum class BwdWeightGroupConvDeviceOperation
-{
-    DeviceGroupedConvBwdWeight,
-    DeviceGroupedConvBwdWeight_Dl,
-    DeviceGroupedConvBwdWeight_Xdl_CShuffle,
-    DeviceGroupedConvBwdWeight_Xdl_CShuffleV3,
-    DeviceGroupedConvBwdWeight_Wmma_CShuffle,
-    DeviceGroupedConvBwdWeightTwoStage_Xdl_CShuffle,
-    DeviceGroupedConvBwdWeightMultipleD,
-    DeviceGroupedConvBwdWeightMultipleD_Xdl_CShuffle,
-};
-
-// Structural type for device operation
-struct GroupConvDeviceOp
-{
-    union
-    {
-        FwdGroupConvDeviceOperation _fwd;
-        BwdDataGroupConvDeviceOperation _bwd_data;
-        BwdWeightGroupConvDeviceOperation _bwd_weight;
-    };
-
-    constexpr GroupConvDeviceOp(FwdGroupConvDeviceOperation op) : _fwd(op) {}
-    constexpr GroupConvDeviceOp(BwdDataGroupConvDeviceOperation op) : _bwd_data(op) {}
-    constexpr GroupConvDeviceOp(BwdWeightGroupConvDeviceOperation op) : _bwd_weight(op) {}
-};
-
 // Fused element-wise operations.
 enum class ElementwiseOperation
 {
@@ -219,6 +173,11 @@ enum class PipelineScheduler
     INTERWAVE
 };
 
+enum class ConvAlgorithmSpecialization
+{
+    LARGE_TENSOR
+};
+
 // ostream operator overloads for enum classes
 inline std::ostream& operator<<(std::ostream& os, DataType dt)
 {
@@ -286,61 +245,6 @@ inline std::ostream& operator<<(std::ostream& os, GroupConvLayout3D layout)
     }
 }
 
-inline std::ostream& operator<<(std::ostream& os, FwdGroupConvDeviceOperation op)
-{
-    using enum FwdGroupConvDeviceOperation;
-    switch(op)
-    {
-    case DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK:
-        return os << "DeviceGroupedConvFwdDlMultipleD_NHWC_KYXC_NHWK";
-    case DeviceGroupedConvFwdMultipleD_Wmma_CShuffle:
-        return os << "DeviceGroupedConvFwdMultipleD_Wmma_CShuffle";
-    case DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle:
-        return os << "DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle";
-    case DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3:
-        return os << "DeviceGroupedConvFwdMultipleABD_Xdl_CShuffle_V3";
-    case DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor:
-        return os << "DeviceGroupedConvFwdMultipleD_Xdl_CShuffle_Large_Tensor";
-    default: return os << "Unknown";
-    }
-}
-
-inline std::ostream& operator<<(std::ostream& os, BwdDataGroupConvDeviceOperation op)
-{
-    using enum BwdDataGroupConvDeviceOperation;
-    switch(op)
-    {
-    case DeviceGroupedConvBwdDataMultipleD: return os << "DeviceGroupedConvBwdDataMultipleD";
-    case DeviceGroupedConvBwdDataMultipleD_Wmma_CShuffle:
-        return os << "DeviceGroupedConvBwdDataMultipleD_Wmma_CShuffle";
-    case DeviceGroupedConvBwdDataMultipleD_Xdl_CShuffle_v1:
-        return os << "DeviceGroupedConvBwdDataMultipleD_Xdl_CShuffle_v1";
-    default: return os << "Unknown";
-    }
-}
-
-inline std::ostream& operator<<(std::ostream& os, BwdWeightGroupConvDeviceOperation op)
-{
-    using enum BwdWeightGroupConvDeviceOperation;
-    switch(op)
-    {
-    case DeviceGroupedConvBwdWeight: return os << "DeviceGroupedConvBwdWeight";
-    case DeviceGroupedConvBwdWeight_Dl: return os << "DeviceGroupedConvBwdWeight_Dl";
-    case DeviceGroupedConvBwdWeight_Xdl_CShuffle:
-        return os << "DeviceGroupedConvBwdWeight_Xdl_CShuffle";
-    case DeviceGroupedConvBwdWeight_Xdl_CShuffleV3:
-        return os << "DeviceGroupedConvBwdWeight_Xdl_CShuffleV3";
-    case DeviceGroupedConvBwdWeight_Wmma_CShuffle:
-        return os << "DeviceGroupedConvBwdWeight_Wmma_CShuffle";
-    case DeviceGroupedConvBwdWeightTwoStage_Xdl_CShuffle:
-        return os << "DeviceGroupedConvBwdWeightTwoStage_Xdl_CShuffle";
-    case DeviceGroupedConvBwdWeightMultipleD: return os << "DeviceGroupedConvBwdWeightMultipleD";
-    case DeviceGroupedConvBwdWeightMultipleD_Xdl_CShuffle:
-        return os << "DeviceGroupedConvBwdWeightMultipleD_Xdl_CShuffle";
-    default: return os << "Unknown";
-    }
-}
-
 inline std::ostream& operator<<(std::ostream& os, ElementwiseOperation op)
 {
     using enum ElementwiseOperation;