fix: resolve integer overflow risks and improve CLI validation

- Fix integer overflow in verify.cuh: use size_t for element counts
- Fix integer overflow in tensor_core_sgemm.cuh: use size_t for grid calc
- Replace atoi() with safeStrToInt() for robust CLI parsing
- Add .clang-tidy for static analysis configuration
- Remove duplicate LICENSE file (keep LICENSE.md with third-party info)

Author: LessUp

.clang-tidy

@@ -0,0 +1,47 @@
+---
+# Clang-tidy configuration for SGEMM Optimization Project
+# Focuses on correctness and performance issues, avoids style nitpicks
+
+Checks: >
+  -*,
+  bugprone-*,
+  -bugprone-easily-swappable-parameters,
+  concurrency-*,
+  modernize-*,
+  -modernize-use-trailing-return-type,
+  -modernize-use-nodiscard,
+  performance-*,
+  readability-identifier-naming,
+  -readability-function-cognitive-complexity,
+  -readability-identifier-length,
+  -readability-magic-numbers
+
+WarningsAsErrors: ''
+
+HeaderFilterRegex: '.*'
+
+CheckOptions:
+  - key: readability-identifier-naming.NamespaceCase
+    value: lower_case
+  - key: readability-identifier-naming.FunctionCase
+    value: lower_case
+  - key: readability-identifier-naming.VariableCase
+    value: lower_case
+  - key: readability-identifier-naming.ConstantCase
+    value: UPPER_CASE
+  - key: readability-identifier-naming.ConstantPrefix
+    value: 'k'
+  - key: readability-identifier-naming.ParameterCase
+    value: lower_case
+  - key: readability-identifier-naming.StructCase
+    value: lower_case
+  - key: readability-identifier-naming.ClassCase
+    value: lower_case
+  - key: readability-identifier-naming.EnumConstantCase
+    value: lower_case
+  - key: readability-identifier-naming.MemberCase
+    value: lower_case
+  - key: readability-identifier-naming.PrivateMemberSuffix
+    value: '_'
+  - key: performance-move-const-arg.CheckTriviallyCopyableMove
+    value: '0'

LICENSE

@@ -123,15 +123,19 @@ inline void launch_tensor_core_sgemm(const float *A, const float *B, float *C, i
         return;
     }
 
-    DeviceMemory<half> d_A_fp16(M * K);
-    DeviceMemory<half> d_B_fp16(K * N);
+    size_t num_A = static_cast<size_t>(M) * K;
+    size_t num_B = static_cast<size_t>(K) * N;
+    DeviceMemory<half> d_A_fp16(num_A);
+    DeviceMemory<half> d_B_fp16(num_B);
 
     int blockSize = 256;
-    int gridSizeA = (M * K + blockSize - 1) / blockSize;
-    int gridSizeB = (K * N + blockSize - 1) / blockSize;
+    int gridSizeA = static_cast<int>((num_A + blockSize - 1) / blockSize);
+    int gridSizeB = static_cast<int>((num_B + blockSize - 1) / blockSize);
 
-    float_to_half_kernel<<<gridSizeA, blockSize, 0, stream>>>(A, d_A_fp16.get(), M * K);
-    float_to_half_kernel<<<gridSizeB, blockSize, 0, stream>>>(B, d_B_fp16.get(), K * N);
+    float_to_half_kernel<<<gridSizeA, blockSize, 0, stream>>>(A, d_A_fp16.get(),
+                                                              static_cast<int>(num_A));
+    float_to_half_kernel<<<gridSizeB, blockSize, 0, stream>>>(B, d_B_fp16.get(),
+                                                              static_cast<int>(num_B));
     CUDA_CHECK(cudaGetLastError());
 
     launch_tensor_core_sgemm_fp16_fast_path(d_A_fp16.get(), d_B_fp16.get(), C, M, K, N, stream);

src/kernels/tensor_core_sgemm.cuh

@@ -6,6 +6,8 @@
  * GPU matrix multiplication optimization techniques.
  */
 
+#include <cerrno>
+#include <climits>
 #include <cstdio>
 #include <cstdlib>
 #include <string>
@@ -32,6 +34,30 @@ const std::vector<std::tuple<int, int, int>> DEFAULT_CASES = {
     {256, 384, 640},
     {511, 513, 1025},
 };
+
+// Safe string to int conversion with error handling
+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;
+    errno = 0;
+    long val = strtol(str, &endptr, 10);
+
+    if (errno == ERANGE || val > INT_MAX || val < INT_MIN) {
+        fprintf(stderr, "Error: %s value '%s' is out of range\n", argName, str);
+        return false;
+    }
+    if (*endptr != '\0') {
+        fprintf(stderr, "Error: Invalid %s value '%s' (not a valid integer)\n", argName, str);
+        return false;
+    }
+
+    *result = static_cast<int>(val);
+    return true;
+}
 } // namespace
 
 void naive_kernel(const float *A, const float *B, float *C, int M, int K, int N) {
@@ -168,7 +194,10 @@ int main(int argc, char **argv) {
                 return 1;
             }
 
-            int size = atoi(argv[++i]);
+            int size;
+            if (!safeStrToInt(argv[++i], &size, "size")) {
+                return 1;
+            }
             if (size <= 0) {
                 fprintf(stderr, "Error: Size must be positive\n");
                 return 1;
@@ -184,9 +213,12 @@ int main(int argc, char **argv) {
                 return 1;
             }
 
-            int M = atoi(argv[++i]);
-            int K = atoi(argv[++i]);
-            int N = atoi(argv[++i]);
+            int M, K, N;
+            if (!safeStrToInt(argv[++i], &M, "M dimension") ||
+                !safeStrToInt(argv[++i], &K, "K dimension") ||
+                !safeStrToInt(argv[++i], &N, "N dimension")) {
+                return 1;
+            }
             if (M <= 0 || K <= 0 || N <= 0) {
                 fprintf(stderr, "Error: Dimensions must be positive\n");
                 return 1;
@@ -207,7 +239,10 @@ int main(int argc, char **argv) {
                 return 1;
             }
 
-            int warmup = atoi(argv[++i]);
+            int warmup;
+            if (!safeStrToInt(argv[++i], &warmup, "warmup")) {
+                return 1;
+            }
             if (warmup < 0) {
                 fprintf(stderr, "Error: Warmup runs must be non-negative\n");
                 return 1;
@@ -223,7 +258,10 @@ int main(int argc, char **argv) {
                 return 1;
             }
 
-            int bench = atoi(argv[++i]);
+            int bench;
+            if (!safeStrToInt(argv[++i], &bench, "benchmark")) {
+                return 1;
+            }
             if (bench <= 0) {
                 fprintf(stderr, "Error: Benchmark runs must be positive\n");
                 return 1;

src/main.cu

@@ -18,14 +18,14 @@ struct VerifyResult {
     float max_abs_error;
     float max_rel_error;
     int error_count;
-    int total_elements;
+    size_t total_elements;
 
     void print(const char *kernel_name = "Kernel") const {
         printf("  %s Verification: %s\n", kernel_name, passed ? "PASSED" : "FAILED");
         printf("    Max Absolute Error: %.6e\n", max_abs_error);
         printf("    Max Relative Error: %.6e\n", max_rel_error);
         if (!passed) {
-            printf("    Error Count: %d / %d (%.2f%%)\n", error_count, total_elements,
+            printf("    Error Count: %d / %zu (%.2f%%)\n", error_count, total_elements,
                    100.0f * error_count / total_elements);
         }
     }
@@ -112,12 +112,14 @@ class SGEMMVerifier {
     // Verify with device pointers (copies to host internally)
     VerifyResult verifyDevice(const float *d_test, const float *d_ref, int M, int N,
                               VerifyTolerance tolerance = kStandardVerifyTolerance) {
-        std::vector<float> h_test(M * N);
-        std::vector<float> h_ref(M * N);
+        size_t num_elements = static_cast<size_t>(M) * N;
+        std::vector<float> h_test(num_elements);
+        std::vector<float> h_ref(num_elements);
 
+        CUDA_CHECK(cudaMemcpy(h_test.data(), d_test, num_elements * sizeof(float),
+                              cudaMemcpyDeviceToHost));
         CUDA_CHECK(
-            cudaMemcpy(h_test.data(), d_test, M * N * sizeof(float), cudaMemcpyDeviceToHost));
-        CUDA_CHECK(cudaMemcpy(h_ref.data(), d_ref, M * N * sizeof(float), cudaMemcpyDeviceToHost));
+            cudaMemcpy(h_ref.data(), d_ref, num_elements * sizeof(float), cudaMemcpyDeviceToHost));
 
         return verify(h_test.data(), h_ref.data(), M, N, tolerance);
     }
@@ -143,9 +145,9 @@ inline VerifyResult compareMatrices(const float *h_test, const float *h_ref, int
     result.max_abs_error = 0.0f;
     result.max_rel_error = 0.0f;
     result.error_count = 0;
-    result.total_elements = M * N;
+    result.total_elements = static_cast<size_t>(M) * N;
 
-    for (int i = 0; i < M * N; ++i) {
+    for (size_t i = 0; i < static_cast<size_t>(M) * N; ++i) {
         float ref_val = h_ref[i];
         float test_val = h_test[i];