refactor: auto-detect operator implementations via SFINAE

Replace the manual `ActiveImplementationsImpl` slot system with
`std::is_base_of`-based compile-time detection. A real `Operator`
specialization inherits from `Key` (e.g., `Gemm`), while the primary
template inherits only from `OperatorBase` — SFINAE distinguishes the
two automatically, eliminating the need for `registry.h` files.

Author: voltjia

src/nvidia/gemm/cublas.h

@@ -3,7 +3,6 @@
 
 #include "cuda/gemm/blas.h"
 #include "nvidia/blas.h"
-#include "nvidia/gemm/registry.h"
 
 namespace infini::ops {
 

src/nvidia/gemm/cublaslt.h

@@ -10,7 +10,6 @@
 
 #include "base/gemm.h"
 #include "nvidia/blas_utils.h"
-#include "nvidia/gemm/registry.h"
 #include "nvidia/runtime_.h"
 
 namespace infini::ops {

src/nvidia/gemm/registry.h

@@ -84,22 +84,9 @@ struct std::equal_to<infini::ops::detail::CacheKey> {
 
 namespace infini::ops {
 
-template <typename Key, Device::Type kDev, std::size_t N = 0>
-struct ActiveImplementationsImpl {
-  using type = List<>;
-};
-
+// Forward declaration — defined after `Operator` using SFINAE auto-detection.
 template <typename Key, Device::Type kDev>
-struct ActiveImplementationsImpl<Key, kDev, 0> {
-  using type = List<0>;
-};
-
-template <typename Key, Device::Type kDev>
-using ActiveImplementations = typename Flatten<
-    typename ActiveImplementationsImpl<Key, kDev, 0>::type,
-    typename ActiveImplementationsImpl<Key, kDev, 1>::type,
-    typename ActiveImplementationsImpl<Key, kDev, 2>::type,
-    typename ActiveImplementationsImpl<Key, kDev, 3>::type>::type;
+struct ActiveImplementations;
 
 class OperatorBase {
  public:
@@ -161,7 +148,7 @@ class Operator : public OperatorBase {
                 }
               },
               "Operator::make(implementation_index)",
-              ActiveImplementations<Key, kDev>{});
+              typename ActiveImplementations<Key, kDev>::type{});
         },
         "Operator::make");
 
@@ -208,7 +195,8 @@ class Operator : public OperatorBase {
         dev_type,
         [&](auto device_tag) {
           constexpr Device::Type kDev = decltype(device_tag)::value;
-          result = detail::ListToVector(ActiveImplementations<Key, kDev>{});
+          result = detail::ListToVector(
+              typename ActiveImplementations<Key, kDev>::type{});
         },
         "Operator::active_implementation_indices");
     return result;
@@ -235,6 +223,31 @@ class Operator : public OperatorBase {
   static constexpr std::size_t implementation_index_{implementation_index};
 };
 
+// SFINAE-based implementation detection. A partial specialization
+// `Operator<Key, kDev, N>` inherits from `Key` (the operator base class),
+// while the unspecialized primary template inherits only from `OperatorBase`.
+// `std::is_base_of` distinguishes the two at compile time, eliminating the
+// need for manual `registry.h` files.
+template <typename Key, Device::Type kDev, std::size_t N,
+          bool = std::is_base_of_v<Key, Operator<Key, kDev, N>>>
+struct ActiveImplementationsImpl {
+  using type = List<>;
+};
+
+template <typename Key, Device::Type kDev, std::size_t N>
+struct ActiveImplementationsImpl<Key, kDev, N, true> {
+  using type = List<N>;
+};
+
+template <typename Key, Device::Type kDev>
+struct ActiveImplementations {
+  using type = typename Flatten<
+      typename ActiveImplementationsImpl<Key, kDev, 0>::type,
+      typename ActiveImplementationsImpl<Key, kDev, 1>::type,
+      typename ActiveImplementationsImpl<Key, kDev, 2>::type,
+      typename ActiveImplementationsImpl<Key, kDev, 3>::type>::type;
+};
+
 }  // namespace infini::ops
 
 #endif

src/operator.h

@@ -2,7 +2,6 @@
 #define INFINI_OPS_TORCH_ADD_H_
 
 #include "base/add.h"
-#include "torch/add/registry.h"
 
 namespace infini::ops {
 

src/torch/add/add.h

@@ -2,7 +2,6 @@
 #define INFINI_OPS_TORCH_GEMM_H_
 
 #include "base/gemm.h"
-#include "torch/gemm/registry.h"
 
 namespace infini::ops {