refactor(tensor-core): remove default fallback to eliminate circular dependency

Delete tensor_core_launcher_impl.cuh and require explicit fallback
specification via launch_tensor_core_sgemm_with_fallback().

Benefits:
- Compile-time decoupling from specific kernels
- Single responsibility: type conversion + Tensor Core launch
- Interface expresses intent: caller must decide fallback strategy

Author: LessUp

CONTEXT.md

@@ -30,8 +30,7 @@
 **位置**: `src/kernels/tensor_core_launcher.cuh`
 
 统一的 SGEMM 启动接口，提供：
-- `launch_tensor_core_sgemm()` - 安全的端到端 FP32 入口点（使用默认 fallback）
-- `launch_tensor_core_sgemm_with_fallback()` - 支持自定义 fallback 策略的模板版本
+- `launch_tensor_core_sgemm_with_fallback()` - 端到端 FP32 入口点（强制显式指定 fallback）
 - `FallbackKernel` - fallback 函数类型定义
 - `kTensorCoreVerifyTolerance` - Tensor Core 验证容差
 
@@ -40,15 +39,17 @@
 - FP32 → FP16 类型转换
 - 不支持情况下的 fallback 到用户指定的策略
 
-**设计优势**：
-- 解耦 Tensor Core 模块与特定 fallback 内核
-- 用户可注入自定义 fallback（如 naive、tiled、bank-conflict-free）
-- 支持运行时选择 fallback 策略
-
-#### Tensor Core Launcher Impl
-**位置**: `src/kernels/tensor_core_launcher_impl.cuh`
-
-默认实现，使用 bank-conflict-free 作为 fallback。
+**设计原则**：
+- **不提供默认 fallback**：调用者必须显式指定 fallback 策略
+- **编译期解耦**：Tensor Core 模块不依赖任何具体内核
+- **深度提升**：模块职责单一（类型转换 + Tensor Core 启动）
+
+**便利函数**：
+调用点可以使用 `defaultTensorCoreFallback()` 便利函数（定义在各自的调用位置）：
+```cpp
+launch_tensor_core_sgemm_with_fallback(A, B, C, M, K, N,
+    defaultTensorCoreFallback(), stream);
+```
 
 #### Tensor Core Benchmark
 **位置**: `src/kernels/tensor_core_benchmark.cuh`

src/benchmark_runner.cuh

@@ -13,6 +13,23 @@
 
 #include <cstdio>
 
+// ============================================================================
+// Tensor Core 便利函数
+// ============================================================================
+
+/**
+ * 默认 Tensor Core fallback 策略
+ *
+ * 使用 bank-conflict-free 内核作为 fallback。
+ * 这是一个便利函数，减少调用点的重复代码。
+ */
+inline auto defaultTensorCoreFallback() {
+    return [](const float* A, const float* B, float* C, int M, int K, int N,
+              cudaStream_t stream) {
+        launch_bank_conflict_free_sgemm<32>(A, B, C, M, K, N, stream);
+    };
+}
+
 // ============================================================================
 // Benchmark 编排器
 // ============================================================================
@@ -158,7 +175,8 @@ class BenchmarkRunner {
         benchmark.run(
             "Tensor Core (WMMA end-to-end)",
             [](const float* A, const float* B, float* C, int M, int K, int N) {
-                launch_tensor_core_sgemm(A, B, C, M, K, N);
+                launch_tensor_core_sgemm_with_fallback(A, B, C, M, K, N,
+                    defaultTensorCoreFallback());
             },
             M, K, N, config_.warmup_runs, config_.benchmark_runs, kTensorCoreVerifyTolerance);
 

src/kernels/tensor_core_launcher.cuh

@@ -101,18 +101,15 @@ inline void launch_tensor_core_sgemm_with_fallback(const float* A, const float*
 }
 
 // ============================================================================
-// 默认接口声明
+// 注意：不提供默认 fallback 版本
 // ============================================================================
-
-/**
- * 使用 bank-conflict-free 作为默认 fallback
- *
- * 注意：此函数实现在 tensor_core_launcher_impl.cuh 中，
- * 以避免与 bank_conflict_free_sgemm.cuh 的循环依赖。
- *
- * 使用方法：
- * 1. 包含 tensor_core_launcher.cuh 和 bank_conflict_free_sgemm.cuh
- * 2. 直接调用 launch_tensor_core_sgemm()
- */
-inline void launch_tensor_core_sgemm(const float* A, const float* B, float* C, int M, int K, int N,
-                                     cudaStream_t stream = 0);
+//
+// 此模块不提供 launch_tensor_core_sgemm() 默认入口。
+// 调用者必须显式指定 fallback 策略：
+//
+//   launch_tensor_core_sgemm_with_fallback(A, B, C, M, K, N, myFallback, stream);
+//
+// 这种设计：
+// - 消除与具体内核的循环依赖
+// - 强制调用者思考"不支持时怎么办"
+// - 保持模块职责单一（类型转换 + Tensor Core 启动）

src/kernels/tensor_core_launcher_impl.cuh

@@ -4,8 +4,8 @@
 // Tensor Core SGEMM - 公共接口
 // ============================================================================
 //
-// 此文件作为 Tensor Core 功能的公共入口点，保持向后兼容。
-// 内部实现已拆分为多个深度模块：
+// 此文件作为 Tensor Core 功能的公共入口点。
+// 内部实现拆分为多个深度模块：
 //
 // 1. tensor_core_capabilities.cuh - 能力查询接口
 //    - tensorCoresAvailable()
@@ -17,25 +17,21 @@
 //    - launch_tensor_core_sgemm_fp16()
 //    - launch_tensor_core_sgemm_fp16_fast_path()
 //
-// 3. tensor_core_launcher.cuh - 统一启动接口（支持自定义 fallback）
+// 3. tensor_core_launcher.cuh - 统一启动接口（强制显式 fallback）
 //    - launch_tensor_core_sgemm_with_fallback()
 //    - FallbackKernel 类型定义
 //    - Tensor Core 容差常量
 //
-// 4. tensor_core_launcher_impl.cuh - 默认实现
-//    - launch_tensor_core_sgemm() 使用 bank-conflict-free 作为默认 fallback
-//
-// 5. tensor_core_benchmark.cuh - Tensor Core 专用 benchmark
+// 4. tensor_core_benchmark.cuh - Tensor Core 专用 benchmark
 //    - runTensorCoreComputeOnlyBenchmark()
 //
-// 这种拆分提高了：
-// - 局部性 (Locality)：每个关注点有独立的测试面
-// - 杠杆 (Leverage)：能力检测可被多个模块使用
-// - 可测试性：可以独立测试能力检测、纯计算路径、fallback 路径
-// - 灵活性：用户可以注入自定义 fallback 策略
+// 设计原则：
+// - 不提供默认 fallback，强制调用者显式指定
+// - 消除与具体内核的循环依赖
+// - 每个模块有独立的测试面
 // ============================================================================
 
 #include "tensor_core_capabilities.cuh"
 #include "tensor_core_compute.cuh"
 #include "tensor_core_launcher.cuh"
-#include "tensor_core_launcher_impl.cuh"
+#include "tensor_core_benchmark.cuh"

src/kernels/tensor_core_sgemm.cuh

@@ -23,6 +23,23 @@
 #include "utils/benchmark_metrics.cuh"
 #include "utils/cuda_utils.cuh"
 
+// ============================================================================
+// Tensor Core 便利函数
+// ============================================================================
+
+/**
+ * 默认 Tensor Core fallback 策略
+ *
+ * 使用 bank-conflict-free 内核作为 fallback。
+ * 这是一个便利函数，减少调用点的重复代码。
+ */
+inline auto defaultTensorCoreFallback() {
+    return [](const float* A, const float* B, float* C, int M, int K, int N,
+              cudaStream_t stream) {
+        launch_bank_conflict_free_sgemm<32>(A, B, C, M, K, N, stream);
+    };
+}
+
 // ============================================================================
 // 性能基线结构
 // ============================================================================
@@ -255,7 +272,11 @@ TEST_F(PerformanceRegressionTest, TensorCoreKernelPerformance) {
     };
 
     for (const auto& [M, K, N] : tc_dimensions) {
-        runPerformanceTest("TensorCore", launch_tensor_core_sgemm, M, K, N, kTensorCoreVerifyTolerance);
+        runPerformanceTest("TensorCore",
+            [](const float* A, const float* B, float* C, int M, int K, int N, cudaStream_t s) {
+                launch_tensor_core_sgemm_with_fallback(A, B, C, M, K, N,
+                    defaultTensorCoreFallback(), s);
+            }, M, K, N, kTensorCoreVerifyTolerance);
     }
 }
 

tests/test_performance.cu

@@ -24,6 +24,15 @@
 namespace {
 constexpr int PBT_ITERATIONS = 100;
 
+// Tensor Core 默认 fallback（使用 bank-conflict-free）
+auto defaultTensorCoreFallback() {
+    return [](const float* A, const float* B, float* C, int M, int K, int N,
+              cudaStream_t stream) {
+        launch_bank_conflict_free_sgemm<32>(A, B, C, M, K, N, stream);
+    };
+}
+} // namespace
+
 std::vector<std::tuple<int, int, int>> getStandardDimensions() {
     return {
         {1, 1, 1},       {2, 2, 2},      {4, 4, 4},       {16, 16, 16},
@@ -246,7 +255,10 @@ TEST_P(TensorCoreSGEMMTest, FastPathCorrectnessProperty) {
     ASSERT_TRUE(tensorCoreDimensionsSupported(M_, K_, N_));
 
     VerifyResult result = runKernelAndCompare(
-        [&] { launch_tensor_core_sgemm(d_A_->get(), d_B_->get(), d_C_->get(), M_, K_, N_); },
+        [&] {
+            launch_tensor_core_sgemm_with_fallback(d_A_->get(), d_B_->get(), d_C_->get(),
+                M_, K_, N_, defaultTensorCoreFallback());
+        },
         kTensorCoreVerifyTolerance);
 
     EXPECT_TRUE(result.passed) << "TensorCore SGEMM fast path failed for dimensions " << M_ << "x"
@@ -261,7 +273,10 @@ class TensorCoreFallbackTest : public SGEMMKernelTest {};
 
 TEST_P(TensorCoreFallbackTest, NonAlignedInputsFallbackSafely) {
     VerifyResult result = runKernelAndCompare(
-        [&] { launch_tensor_core_sgemm(d_A_->get(), d_B_->get(), d_C_->get(), M_, K_, N_); },
+        [&] {
+            launch_tensor_core_sgemm_with_fallback(d_A_->get(), d_B_->get(), d_C_->get(),
+                M_, K_, N_, defaultTensorCoreFallback());
+        },
         kStandardVerifyTolerance);
 
     EXPECT_TRUE(result.passed) << "TensorCore fallback failed for dimensions " << M_ << "x" << K_
@@ -272,9 +287,10 @@ INSTANTIATE_TEST_SUITE_P(TensorCoreFallbackDimensions, TensorCoreFallbackTest,
                          ::testing::ValuesIn(getTensorCoreFallbackDimensions()));
 
 TEST(TensorCoreWrapperTest, ZeroSizeInputsReturnSafely) {
-    EXPECT_NO_THROW(launch_tensor_core_sgemm(nullptr, nullptr, nullptr, 0, 16, 16));
-    EXPECT_NO_THROW(launch_tensor_core_sgemm(nullptr, nullptr, nullptr, 16, 0, 16));
-    EXPECT_NO_THROW(launch_tensor_core_sgemm(nullptr, nullptr, nullptr, 16, 16, 0));
+    auto fallback = [](const float*, const float*, float*, int, int, int, cudaStream_t) {};
+    EXPECT_NO_THROW(launch_tensor_core_sgemm_with_fallback(nullptr, nullptr, nullptr, 0, 16, 16, fallback));
+    EXPECT_NO_THROW(launch_tensor_core_sgemm_with_fallback(nullptr, nullptr, nullptr, 16, 0, 16, fallback));
+    EXPECT_NO_THROW(launch_tensor_core_sgemm_with_fallback(nullptr, nullptr, nullptr, 16, 16, 0, fallback));
 }
 
 class DimensionInvarianceTest : public ::testing::Test {