style: apply clang-format

Author: voltjia

src/operator.h

@@ -95,12 +95,11 @@ struct ActiveImplementationsImpl<Key, kDev, 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;
+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;
 
 class OperatorBase {
  public:

src/torch/add/add.cc

@@ -7,20 +7,19 @@ namespace infini::ops {
 template <Device::Type kDev>
 Operator<Add, kDev, 1>::Operator(const Tensor input, const Tensor other,
                                  Tensor out)
-    : Add{input, other, out},
-      device_index_{out.device().index()} {}
+    : Add{input, other, out}, device_index_{out.device().index()} {}
 
 template <Device::Type kDev>
 void Operator<Add, kDev, 1>::operator()(const Tensor input, const Tensor other,
                                         Tensor out) const {
-  auto at_input = ToAtenTensor<kDev>(
-      const_cast<void*>(input.data()), input_shape_, input_strides_,
-      input_type_, device_index_);
-  auto at_other = ToAtenTensor<kDev>(
-      const_cast<void*>(other.data()), other_shape_, other_strides_,
-      other_type_, device_index_);
-  auto at_out = ToAtenTensor<kDev>(
-      out.data(), out_shape_, out_strides_, out_type_, device_index_);
+  auto at_input =
+      ToAtenTensor<kDev>(const_cast<void*>(input.data()), input_shape_,
+                         input_strides_, input_type_, device_index_);
+  auto at_other =
+      ToAtenTensor<kDev>(const_cast<void*>(other.data()), other_shape_,
+                         other_strides_, other_type_, device_index_);
+  auto at_out = ToAtenTensor<kDev>(out.data(), out_shape_, out_strides_,
+                                   out_type_, device_index_);
 
   at::add_out(at_out, at_input, at_other);
 }

src/torch/gemm/gemm.cc

@@ -17,10 +17,12 @@ Operator<Gemm, kDev, 2>::Operator(const Tensor a, const Tensor b,
       device_index_{c.device().index()} {}
 
 template <Device::Type kDev>
-void Operator<Gemm, kDev, 2>::operator()(
-    const Tensor a, const Tensor b, std::optional<float> alpha,
-    std::optional<float> beta, std::optional<int> trans_a,
-    std::optional<int> trans_b, Tensor c) const {
+void Operator<Gemm, kDev, 2>::operator()(const Tensor a, const Tensor b,
+                                         std::optional<float> alpha,
+                                         std::optional<float> beta,
+                                         std::optional<int> trans_a,
+                                         std::optional<int> trans_b,
+                                         Tensor c) const {
   auto at_a = ToAtenTensor<kDev>(const_cast<void*>(a.data()), a_shape_,
                                  a_strides_, a_type_, device_index_);
   auto at_b = ToAtenTensor<kDev>(const_cast<void*>(b.data()), b_shape_,

src/torch/tensor_.h

@@ -64,8 +64,9 @@ inline at::Tensor ToAtenTensor(void* data, const Tensor::Shape& shape,
   auto options = at::TensorOptions().dtype(ToAtenDtype(dtype));
 
   if constexpr (kDev != Device::Type::kCpu) {
-    std::string device_str = std::string(detail::TorchDeviceName<kDev>::kValue) +
-                             ":" + std::to_string(device_index);
+    std::string device_str =
+        std::string(detail::TorchDeviceName<kDev>::kValue) + ":" +
+        std::to_string(device_index);
     options = options.device(device_str);
   }