[pre-commit.ci] auto fixes from pre-commit.com hooks

pre-commit-ci[bot] · pre-commit-ci[bot] · commit 73ba45345e05 · 2026-03-25T07:33:37.000Z
for more information, see https://pre-commit.ci
diff --git a/csrc/multi_tensor_apply.cuh b/csrc/multi_tensor_apply.cuh
@@ -3,9 +3,10 @@
 #include <ATen/cuda/CUDAContext.h>
 #include <ATen/cuda/Exceptions.h>
 #include <assert.h>
-#include <climits>
 #include <c10/cuda/CUDAGuard.h>
 
+#include <climits>
+
 // #include <iostream>
 
 // This header is the one-stop shop for all your multi-tensor apply needs.
diff --git a/csrc/multi_tensor_l2norm_kernel.cu b/csrc/multi_tensor_l2norm_kernel.cu
@@ -321,10 +321,9 @@ std::tuple<at::Tensor, at::Tensor> multi_tensor_l2norm_cuda(int chunk_size, at::
                               per_tensor ? output_per_tensor.data_ptr<float>() : nullptr, per_tensor,
                               max_chunks_per_tensor);
       } else {
-        multi_tensor_apply<1>(BLOCK_SIZE, chunk_size, noop_flag, tensor_lists,
-                              L2NormFunctor<scalar_t_0, int32_t>(), output.data_ptr<float>(),
-                              per_tensor ? output_per_tensor.data_ptr<float>() : nullptr, per_tensor,
-                              max_chunks_per_tensor);
+        multi_tensor_apply<1>(BLOCK_SIZE, chunk_size, noop_flag, tensor_lists, L2NormFunctor<scalar_t_0, int32_t>(),
+                              output.data_ptr<float>(), per_tensor ? output_per_tensor.data_ptr<float>() : nullptr,
+                              per_tensor, max_chunks_per_tensor);
       })
 
   AT_CUDA_CHECK(cudaGetLastError());
@@ -428,16 +427,17 @@ void multi_tensor_norm_out_cuda(int chunk_size, at::Tensor noop_flag, std::vecto
   output_per_tensor = at::zeros({ntensors * max_chunks_per_tensor}, float_options);
 
   if (norm_type == 0) {
-    DISPATCH_FLOAT_AND_HALF(tensor_lists[0][0].scalar_type(), 0, "multi_tensor_maxnorm_cuda",
-                            if (requires_64bit_indexing) {
-                              multi_tensor_apply<1>((int64_t)BLOCK_SIZE, (int64_t)chunk_size, noop_flag, tensor_lists,
-                                                    MaxNormFunctor<scalar_t_0, int64_t>(), output.data_ptr<float>(),
-                                                    output_per_tensor.data_ptr<float>(), true, max_chunks_per_tensor);
-                            } else {
-                              multi_tensor_apply<1>(BLOCK_SIZE, chunk_size, noop_flag, tensor_lists,
-                                                    MaxNormFunctor<scalar_t_0, int32_t>(), output.data_ptr<float>(),
-                                                    output_per_tensor.data_ptr<float>(), true, max_chunks_per_tensor);
-                            })
+    DISPATCH_FLOAT_AND_HALF(
+        tensor_lists[0][0].scalar_type(), 0, "multi_tensor_maxnorm_cuda",
+        if (requires_64bit_indexing) {
+          multi_tensor_apply<1>((int64_t)BLOCK_SIZE, (int64_t)chunk_size, noop_flag, tensor_lists,
+                                MaxNormFunctor<scalar_t_0, int64_t>(), output.data_ptr<float>(),
+                                output_per_tensor.data_ptr<float>(), true, max_chunks_per_tensor);
+        } else {
+          multi_tensor_apply<1>(BLOCK_SIZE, chunk_size, noop_flag, tensor_lists, MaxNormFunctor<scalar_t_0, int32_t>(),
+                                output.data_ptr<float>(), output_per_tensor.data_ptr<float>(), true,
+                                max_chunks_per_tensor);
+        })
   } else {
     DISPATCH_FLOAT_HALF_AND_BFLOAT(
         tensor_lists[0][0].scalar_type(), 0, "multi_tensor_l2norm_cuda",
@@ -446,9 +446,9 @@ void multi_tensor_norm_out_cuda(int chunk_size, at::Tensor noop_flag, std::vecto
                                 L2NormFunctor<scalar_t_0, int64_t>(), output.data_ptr<float>(),
                                 output_per_tensor.data_ptr<float>(), true, max_chunks_per_tensor);
         } else {
-          multi_tensor_apply<1>(BLOCK_SIZE, chunk_size, noop_flag, tensor_lists,
-                                L2NormFunctor<scalar_t_0, int32_t>(), output.data_ptr<float>(),
-                                output_per_tensor.data_ptr<float>(), true, max_chunks_per_tensor);
+          multi_tensor_apply<1>(BLOCK_SIZE, chunk_size, noop_flag, tensor_lists, L2NormFunctor<scalar_t_0, int32_t>(),
+                                output.data_ptr<float>(), output_per_tensor.data_ptr<float>(), true,
+                                max_chunks_per_tensor);
         })
   }
   AT_CUDA_CHECK(cudaGetLastError());
diff --git a/csrc/multi_tensor_l2norm_kernel_mp.cu b/csrc/multi_tensor_l2norm_kernel_mp.cu
@@ -152,10 +152,9 @@ std::tuple<at::Tensor, at::Tensor> multi_tensor_l2norm_mp_cuda(int chunk_size, a
                               per_tensor ? output_per_tensor.data_ptr<float>() : nullptr, per_tensor,
                               max_chunks_per_tensor);
       } else {
-        multi_tensor_apply<1>(BLOCK_SIZE, chunk_size, noop_flag, tensor_lists,
-                              L2NormFunctor<scalar_t_0, int32_t>(), output.data_ptr<float>(),
-                              per_tensor ? output_per_tensor.data_ptr<float>() : nullptr, per_tensor,
-                              max_chunks_per_tensor);
+        multi_tensor_apply<1>(BLOCK_SIZE, chunk_size, noop_flag, tensor_lists, L2NormFunctor<scalar_t_0, int32_t>(),
+                              output.data_ptr<float>(), per_tensor ? output_per_tensor.data_ptr<float>() : nullptr,
+                              per_tensor, max_chunks_per_tensor);
       })
 
   AT_CUDA_CHECK(cudaGetLastError());
diff --git a/tests/L0/run_optimizers/test_large_tensor_l2norm.py b/tests/L0/run_optimizers/test_large_tensor_l2norm.py
@@ -16,6 +16,7 @@
 INT32_MAX = 2_147_483_647
 LARGE_NUMEL = INT32_MAX + 1
 
+
 @unittest.skipIf(not HAS_APEX, "`apex` is not found.")
 class LargeTensorL2NormTest(unittest.TestCase):
     def setUp(self):
@@ -77,4 +78,4 @@ def test_multi_tensor_l2norm_scale_large_tensor(self):
 
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()
