fix(ci): remove CUDA build job and fix clang-format violations

GitHub Actions has no GPU/CUDA environment, so the cuda-build job always
fails. Remove it and keep only the format-check static analysis. Also
fix all clang-format violations across source files.

Author: LessUp

.github/workflows/ci.yml

@@ -1,5 +1,5 @@
 # Continuous Integration
-# Validates code formatting and CUDA compilation
+# Validates code formatting
 
 name: CI
 
@@ -42,34 +42,3 @@ jobs:
         with:
           clang-format-version: '17'
           fallback-style: 'LLVM'
-
-  cuda-build:
-    name: CUDA Build
-    runs-on: ubuntu-latest
-    container:
-      image: nvidia/cuda:12.4.1-devel-ubuntu22.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          apt-get update
-          apt-get install -y --no-install-recommends cmake git build-essential
-          rm -rf /var/lib/apt/lists/*
-
-      - name: Configure
-        run: >
-          cmake -S . -B build
-          -DCMAKE_BUILD_TYPE=Release
-          -DBUILD_TESTS=OFF
-          -DCMAKE_CUDA_ARCHITECTURES="70;75;80;86;89;90"
-
-      - name: Build
-        run: cmake --build build --target sgemm_benchmark -j$(nproc)
-
-      - name: Info
-        run: |
-          echo "✅ CUDA compilation successful"
-          echo "ℹ️  Supported architectures: sm_70, sm_75, sm_80, sm_86, sm_89, sm_90"
-          echo "ℹ️  GPU runtime tests require a CUDA-capable machine"

src/benchmark_runner.cuh

@@ -24,8 +24,7 @@
  * 这是一个便利函数，减少调用点的重复代码。
  */
 inline auto defaultTensorCoreFallback() {
-    return [](const float* A, const float* B, float* C, int M, int K, int N,
-              cudaStream_t stream) {
+    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);
     };
 }
@@ -42,15 +41,15 @@ inline auto defaultTensorCoreFallback() {
  */
 class BenchmarkRunner {
   public:
-    explicit BenchmarkRunner(const BenchmarkConfig& config) : config_(config) {}
+    explicit BenchmarkRunner(const BenchmarkConfig &config) : config_(config) {}
 
     /**
      * 运行所有配置的 benchmark
      */
     void runAll() {
         printHeader();
 
-        for (const auto& [M, K, N] : config_.dimensions) {
+        for (const auto &[M, K, N] : config_.dimensions) {
             runBenchmarks(M, K, N);
         }
 
@@ -125,41 +124,41 @@ class BenchmarkRunner {
         benchmark.exportRooflineData(filename);
     }
 
-    void runStandardKernels(SGEMMBenchmark& benchmark, int M, int K, int N) {
+    void runStandardKernels(SGEMMBenchmark &benchmark, int M, int K, int N) {
         printf("Running Naive SGEMM...\n");
         benchmark.run(
             "Naive",
-            [](const float* A, const float* B, float* C, int M, int K, int N) {
+            [](const float *A, const float *B, float *C, int M, int K, int N) {
                 launch_naive_sgemm<32>(A, B, C, M, K, N);
             },
             M, K, N, config_.warmup_runs, config_.benchmark_runs, kStandardVerifyTolerance);
 
         printf("Running Tiled SGEMM...\n");
         benchmark.run(
             "Tiled (32x32)",
-            [](const float* A, const float* B, float* C, int M, int K, int N) {
+            [](const float *A, const float *B, float *C, int M, int K, int N) {
                 launch_tiled_sgemm<32>(A, B, C, M, K, N);
             },
             M, K, N, config_.warmup_runs, config_.benchmark_runs, kStandardVerifyTolerance);
 
         printf("Running Bank Conflict Free SGEMM...\n");
         benchmark.run(
             "Bank Conflict Free",
-            [](const float* A, const float* B, float* C, int M, int K, int N) {
+            [](const float *A, const float *B, float *C, int M, int K, int N) {
                 launch_bank_conflict_free_sgemm<32>(A, B, C, M, K, N);
             },
             M, K, N, config_.warmup_runs, config_.benchmark_runs, kStandardVerifyTolerance);
 
         printf("Running Double Buffer SGEMM...\n");
         benchmark.run(
             "Double Buffer",
-            [](const float* A, const float* B, float* C, int M, int K, int N) {
+            [](const float *A, const float *B, float *C, int M, int K, int N) {
                 launch_double_buffer_sgemm<32>(A, B, C, M, K, N);
             },
             M, K, N, config_.warmup_runs, config_.benchmark_runs, kStandardVerifyTolerance);
     }
 
-    void runTensorCoreKernels(SGEMMBenchmark& benchmark, int M, int K, int N) {
+    void runTensorCoreKernels(SGEMMBenchmark &benchmark, int M, int K, int N) {
         if (!tensorCoresAvailable()) {
             int device;
             CUDA_CHECK(cudaGetDevice(&device));
@@ -174,9 +173,9 @@ class BenchmarkRunner {
                "conversion/fallback)...\n");
         benchmark.run(
             "Tensor Core (WMMA end-to-end)",
-            [](const float* A, const float* B, float* C, int M, int K, int N) {
+            [](const float *A, const float *B, float *C, int M, int K, int N) {
                 launch_tensor_core_sgemm_with_fallback(A, B, C, M, K, N,
-                    defaultTensorCoreFallback());
+                                                       defaultTensorCoreFallback());
             },
             M, K, N, config_.warmup_runs, config_.benchmark_runs, kTensorCoreVerifyTolerance);
 

src/cli_parser.cuh

@@ -42,13 +42,13 @@ const std::vector<std::tuple<int, int, int>> BenchmarkConfig::DEFAULT_CASES = {
 namespace detail {
 
 // 安全的字符串到整数转换
-inline bool safeStrToInt(const char* str, int* result, const char* argName) {
+inline bool safeStrToInt(const char *str, int *result, const char *argName) {
     if (str == nullptr || str[0] == '\0') {
         fprintf(stderr, "Error: %s requires a valid number\n", argName);
         return false;
     }
 
-    char* endptr;
+    char *endptr;
     errno = 0;
     long val = strtol(str, &endptr, 10);
 
@@ -80,15 +80,15 @@ inline bool safeStrToInt(const char* str, int* result, const char* argName) {
  */
 class CliParser {
   public:
-    CliParser(int argc, char** argv) : argc_(argc), argv_(argv) {}
+    CliParser(int argc, char **argv) : argc_(argc), argv_(argv) {}
 
     /**
      * 解析命令行参数
      *
      * @param config 输出配置对象
      * @return 0 成功，1 错误，2 显示帮助后退出
      */
-    int parse(BenchmarkConfig& config) {
+    int parse(BenchmarkConfig &config) {
         for (int i = 1; i < argc_; ++i) {
             std::string arg = argv_[i];
 
@@ -143,7 +143,7 @@ class CliParser {
         return 0;
     }
 
-    void printUsage(const char* program) const {
+    void printUsage(const char *program) const {
         printf("Usage: %s [options]\n", program);
         printf("\nOptions:\n");
         printf("  -s, --size SIZE          Benchmark one square SIZE x SIZE x SIZE case\n");
@@ -163,7 +163,7 @@ class CliParser {
     }
 
   private:
-    int parseSizeArg(int& i, BenchmarkConfig& config) {
+    int parseSizeArg(int &i, BenchmarkConfig &config) {
         if (i + 1 >= argc_) {
             fprintf(stderr, "Error: -s requires a size argument\n");
             return 1;
@@ -182,7 +182,7 @@ class CliParser {
         return 0;
     }
 
-    int parseDimsArg(int& i, BenchmarkConfig& config) {
+    int parseDimsArg(int &i, BenchmarkConfig &config) {
         if (i + 3 >= argc_) {
             fprintf(stderr, "Error: --dims requires M K N arguments\n");
             return 1;
@@ -203,7 +203,7 @@ class CliParser {
         return 0;
     }
 
-    int parseWarmupArg(int& i, BenchmarkConfig& config) {
+    int parseWarmupArg(int &i, BenchmarkConfig &config) {
         if (i + 1 >= argc_) {
             fprintf(stderr, "Error: --warmup requires a number argument\n");
             return 1;
@@ -222,7 +222,7 @@ class CliParser {
         return 0;
     }
 
-    int parseBenchmarkArg(int& i, BenchmarkConfig& config) {
+    int parseBenchmarkArg(int &i, BenchmarkConfig &config) {
         if (i + 1 >= argc_) {
             fprintf(stderr, "Error: --benchmark requires a number argument\n");
             return 1;
@@ -242,5 +242,5 @@ class CliParser {
     }
 
     int argc_;
-    char** argv_;
+    char **argv_;
 };

src/kernels/tensor_core_benchmark.cuh

@@ -33,9 +33,10 @@
  * @param tolerance 验证容差
  * @return BenchmarkResult 包含性能数据
  */
-inline BenchmarkResult runTensorCoreComputeOnlyBenchmark(
-    SGEMMBenchmark &benchmark, int M, int K, int N, int warmup_runs = 5, int benchmark_runs = 20,
-    VerifyTolerance tolerance = kTensorCoreVerifyTolerance) {
+inline BenchmarkResult
+runTensorCoreComputeOnlyBenchmark(SGEMMBenchmark &benchmark, int M, int K, int N,
+                                  int warmup_runs = 5, int benchmark_runs = 20,
+                                  VerifyTolerance tolerance = kTensorCoreVerifyTolerance) {
 
     if (!tensorCoresAvailable() || !tensorCoreDimensionsSupported(M, K, N)) {
         throw CudaError("Tensor Core compute-only benchmark requires sm_70+ and "
@@ -102,7 +103,8 @@ inline BenchmarkResult runTensorCoreComputeOnlyBenchmark(
     result.time_ms = total_time_ms / benchmark_runs;
     double flops = 2.0 * result.M * result.N * result.K;
     result.gflops = (flops / (result.time_ms * 1e-3)) / 1e9;
-    double bytes = (result.M * result.K + result.K * result.N + result.M * result.N) * sizeof(float);
+    double bytes =
+        (result.M * result.K + result.K * result.N + result.M * result.N) * sizeof(float);
     result.bandwidth_gb_s = (bytes / (result.time_ms * 1e-3)) / 1e9;
 
     d_C.copyToHost(h_C.data(), M * N);

src/kernels/tensor_core_capabilities.cuh

@@ -41,7 +41,7 @@ inline bool tensorCoreDimensionsSupported(int M, int K, int N) {
 /**
  * 获取当前设备的 Tensor Core 信息字符串
  */
-inline const char* getTensorCoreArchName() {
+inline const char *getTensorCoreArchName() {
     int device;
     CUDA_CHECK(cudaGetDevice(&device));
 

src/kernels/tensor_core_launcher.cuh

@@ -24,15 +24,15 @@ inline constexpr VerifyTolerance kTensorCoreVerifyTolerance{5e-2f, 1e-2f};
  * 签名与所有标准 SGEMM 内核一致：
  * void(const float* A, const float* B, float* C, int M, int K, int N, cudaStream_t stream)
  */
-using FallbackKernel = std::function<void(const float*, const float*, float*, int, int, int,
-                                          cudaStream_t)>;
+using FallbackKernel =
+    std::function<void(const float *, const float *, float *, int, int, int, cudaStream_t)>;
 
 /**
  * 默认 fallback 策略
  *
  * 提供一个空的 fallback（用于测试或显式配置场景）
  */
-inline void nullFallback(const float*, const float*, float*, int, int, int, cudaStream_t = 0) {
+inline void nullFallback(const float *, const float *, float *, int, int, int, cudaStream_t = 0) {
     // 空实现 - 用于测试
 }
 
@@ -57,7 +57,7 @@ inline void nullFallback(const float*, const float*, float*, int, int, int, cuda
  * @param stream CUDA 流
  */
 template <typename FallbackFunc>
-inline void launch_tensor_core_sgemm_with_fallback(const float* A, const float* B, float* C, int M,
+inline void launch_tensor_core_sgemm_with_fallback(const float *A, const float *B, float *C, int M,
                                                    int K, int N, FallbackFunc fallback,
                                                    cudaStream_t stream = 0) {
     if (M <= 0 || K <= 0 || N <= 0) {
@@ -94,8 +94,8 @@ inline void launch_tensor_core_sgemm_with_fallback(const float* A, const float*
  *
  * 允许运行时选择 fallback 策略。
  */
-inline void launch_tensor_core_sgemm_with_fallback(const float* A, const float* B, float* C, int M,
-                                                   int K, int N, const FallbackKernel& fallback,
+inline void launch_tensor_core_sgemm_with_fallback(const float *A, const float *B, float *C, int M,
+                                                   int K, int N, const FallbackKernel &fallback,
                                                    cudaStream_t stream = 0) {
     launch_tensor_core_sgemm_with_fallback(A, B, C, M, K, N, fallback, stream);
 }

src/kernels/tensor_core_sgemm.cuh

@@ -31,7 +31,7 @@
 // - 每个模块有独立的测试面
 // ============================================================================
 
+#include "tensor_core_benchmark.cuh"
 #include "tensor_core_capabilities.cuh"
 #include "tensor_core_compute.cuh"
 #include "tensor_core_launcher.cuh"
-#include "tensor_core_benchmark.cuh"

src/main.cu

@@ -13,7 +13,7 @@
 #include "benchmark_runner.cuh"
 #include "cli_parser.cuh"
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
     BenchmarkConfig config;
     CliParser parser(argc, argv);
 

src/utils/benchmark.cuh

@@ -81,7 +81,7 @@ class SGEMMBenchmark {
      * @param tolerance 验证容差
      */
     template <typename KernelFunc>
-    BenchmarkResult run(const std::string& name, KernelFunc kernel_func, int M, int K, int N,
+    BenchmarkResult run(const std::string &name, KernelFunc kernel_func, int M, int K, int N,
                         int warmup_runs = 5, int benchmark_runs = 20,
                         VerifyTolerance tolerance = kStandardVerifyTolerance) {
         BenchmarkResult result;
@@ -208,15 +208,15 @@ class SGEMMBenchmark {
         printf("--------------------------------------------------------------------"
                "------------\n");
 
-        for (const auto& result : results_) {
+        for (const auto &result : results_) {
             result.print();
         }
 
         printf("===================================================================="
                "============\n");
     }
 
-    void exportRooflineData(const std::string& filename) const {
+    void exportRooflineData(const std::string &filename) const {
         std::ofstream file(filename);
         if (!file.is_open()) {
             fprintf(stderr, "Failed to open file: %s\n", filename.c_str());
@@ -225,7 +225,7 @@ class SGEMMBenchmark {
 
         file << "kernel,M,K,N,time_ms,gflops,bandwidth_gb_s,arithmetic_intensity\n";
 
-        for (const auto& result : results_) {
+        for (const auto &result : results_) {
             double flops = 2.0 * result.M * result.N * result.K;
             double bytes =
                 (result.M * result.K + result.K * result.N + result.M * result.N) * sizeof(float);
@@ -240,7 +240,7 @@ class SGEMMBenchmark {
         printf("Approximate roofline data exported to: %s\n", filename.c_str());
     }
 
-    const std::vector<BenchmarkResult>& getResults() const { return results_; }
+    const std::vector<BenchmarkResult> &getResults() const { return results_; }
     void clearResults() { results_.clear(); }
     cublasHandle_t getCublasHandle() const { return cublas_handle_; }
 
@@ -254,7 +254,7 @@ class SGEMMBenchmark {
 // 实用工具函数
 // ============================================================================
 
-inline void printPerformanceComparison(const std::vector<BenchmarkResult>& results,
+inline void printPerformanceComparison(const std::vector<BenchmarkResult> &results,
                                        float cublas_gflops) {
     printf("\n");
     printf("Performance Comparison (vs cuBLAS):\n");
@@ -264,7 +264,7 @@ inline void printPerformanceComparison(const std::vector<BenchmarkResult>& resul
     printf("---------------------------------------------------------------------"
            "-----------\n");
 
-    for (const auto& result : results) {
+    for (const auto &result : results) {
         float percentage = (result.gflops / cublas_gflops) * 100.0f;
         printf("  %-30s | %10.2f     | %8.1f%%\n", result.kernel_name.c_str(), result.gflops,
                percentage);

src/utils/benchmark_core.cuh

@@ -26,8 +26,8 @@ class CudaTimer {
     }
 
     // 禁用拷贝
-    CudaTimer(const CudaTimer&) = delete;
-    CudaTimer& operator=(const CudaTimer&) = delete;
+    CudaTimer(const CudaTimer &) = delete;
+    CudaTimer &operator=(const CudaTimer &) = delete;
 
     // 记录开始事件
     void start() { CUDA_CHECK(cudaEventRecord(start_)); }