Run clang-format (#2553)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: fifield

.github/workflows/lintAndFormat.yml

@@ -153,7 +153,7 @@ jobs:
           tool_name: clang-format
           level: error
           cleanup: true
-          fail_on_error: true
+          fail_level: any
 
       - name: Run black format
         if: success() || failure()
@@ -175,7 +175,7 @@ jobs:
         with:
           tool_name: black
           level: error
-          fail_on_error: true
+          fail_level: any
 
   code-coverage:
 

aie_kernels/aie2p/layer_norm.cc

@@ -43,7 +43,7 @@ void layer_norm(const T *restrict input, T *restrict output, int32_t cols) {
 
   ::aie::vector<T, N> mean_v = ::aie::broadcast<T, N>(mean);
   ::aie::vector<T, N> inv_std_v = ::aie::broadcast<T, N>(inv_std);
-  
+
   for (int i = 0; i < vector_chunks; i++) {
     ::aie::vector<T, N> reg_a = ::aie::load_v<N>(input + i * N);
     ::aie::vector<T, N> diff_v = ::aie::sub(reg_a, mean_v);

aie_kernels/aie2p/mm.cc

@@ -342,7 +342,8 @@ matmul_vectorized_8x8x8_bf16_f32(const bfloat16 *__restrict pA,
   static_assert(n % (2 * t) == 0);
 
   return matmul_vectorized_2x2_mmul<bfloat16, float, (m / r), (k / s), (n / t),
-                                    r, s, t, is_b_row_maj, is_c_row_maj>(pA, pB, pC);
+                                    r, s, t, is_b_row_maj, is_c_row_maj>(pA, pB,
+                                                                         pC);
 }
 
 template <unsigned m, unsigned k, unsigned n>
@@ -481,8 +482,8 @@ extern "C" {
                              r, s, t)                                          \
   void matmul_scalar_##mlir_type_in##_##mlir_type_out(                         \
       ctype_in *a_in, ctype_in *b_in, ctype_out *c_out) {                      \
-    matmul_scalar<ctype_in, ctype_out, DIM_M, DIM_K, DIM_N, is_b_row_maj, is_c_row_maj>(a_in, b_in,        \
-                                                            c_out);            \
+    matmul_scalar<ctype_in, ctype_out, DIM_M, DIM_K, DIM_N, is_b_row_maj,      \
+                  is_c_row_maj>(a_in, b_in, c_out);                            \
   }
 
 #define zero_vectorized_c_func(ctype_in, mlir_type_in, ctype_out,              \

aie_kernels/aie2p/mm_bfp.cc

@@ -86,72 +86,72 @@ void matmul_vectorized_2x2_bfp16(const bfp16ebs8 *__restrict pA,
   AIE_PREPARE_FOR_PIPELINING
   AIE_LOOP_MIN_ITERATION_COUNT(4)
   for (unsigned z = 0; z < rowA; z += 2) {
-      aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pC1In(pC);
-      pC1In.seek(z * colB);
-      aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pC2In(pC);
-      pC2In.seek((z + 1) * colB);
-      aie::block_vector_output_buffer_stream<bfp16ebs8, 64> pC1Out(pC);
-      pC1Out.seek(z * colB);
-      aie::block_vector_output_buffer_stream<bfp16ebs8, 64> pC2Out(pC);
-      pC2Out.seek((z + 1) * colB);
-
-      for (unsigned j = 0; j < colB; j += 2)
+    aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pC1In(pC);
+    pC1In.seek(z * colB);
+    aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pC2In(pC);
+    pC2In.seek((z + 1) * colB);
+    aie::block_vector_output_buffer_stream<bfp16ebs8, 64> pC1Out(pC);
+    pC1Out.seek(z * colB);
+    aie::block_vector_output_buffer_stream<bfp16ebs8, 64> pC2Out(pC);
+    pC2Out.seek((z + 1) * colB);
+
+    for (unsigned j = 0; j < colB; j += 2)
 #ifdef OPT_PERF_ENABLED
       AIE_LOOP_FLATTEN
 #endif
-        {
-          aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pA1bfp16(pA);
-          aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pA2bfp16(pA);
-          pA1bfp16.seek(z * colA);
-          pA2bfp16.seek((z + 1) * colA);
-
-          aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pB1bfp16(pB);
-          aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pB2bfp16(pB);
-          // For non transposed matrix
-          // pB1bfp16.seek(j);
-          // pB2bfp16.seek(j + 1);
-          pB1bfp16.seek(j * colA);
-          pB2bfp16.seek((j + 1) * colA);
-
-          aie::block_vector<bfp16ebs8, sizeA> A0;
-          aie::block_vector<bfp16ebs8, sizeA> A1;
-          aie::block_vector<bfp16ebs8, sizeB> B0;
-          aie::block_vector<bfp16ebs8, sizeB> B1;
-
-          // Note that unlike the example mentioned above, we need
-          // to use a mac to take into account results from previous kernel
-          // calls but this is completely unrelated to the block datatype.
-          aie::accum<accfloat, sizeC> accC00(pC1In.pop());
-          aie::accum<accfloat, sizeC> accC01(pC1In.pop());
-          aie::accum<accfloat, sizeC> accC10(pC2In.pop());
-          aie::accum<accfloat, sizeC> accC11(pC2In.pop());
-
-          for (unsigned i = 0; i < colA; ++i)
+      {
+        aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pA1bfp16(pA);
+        aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pA2bfp16(pA);
+        pA1bfp16.seek(z * colA);
+        pA2bfp16.seek((z + 1) * colA);
+
+        aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pB1bfp16(pB);
+        aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pB2bfp16(pB);
+        // For non transposed matrix
+        // pB1bfp16.seek(j);
+        // pB2bfp16.seek(j + 1);
+        pB1bfp16.seek(j * colA);
+        pB2bfp16.seek((j + 1) * colA);
+
+        aie::block_vector<bfp16ebs8, sizeA> A0;
+        aie::block_vector<bfp16ebs8, sizeA> A1;
+        aie::block_vector<bfp16ebs8, sizeB> B0;
+        aie::block_vector<bfp16ebs8, sizeB> B1;
+
+        // Note that unlike the example mentioned above, we need
+        // to use a mac to take into account results from previous kernel
+        // calls but this is completely unrelated to the block datatype.
+        aie::accum<accfloat, sizeC> accC00(pC1In.pop());
+        aie::accum<accfloat, sizeC> accC01(pC1In.pop());
+        aie::accum<accfloat, sizeC> accC10(pC2In.pop());
+        aie::accum<accfloat, sizeC> accC11(pC2In.pop());
+
+        for (unsigned i = 0; i < colA; ++i)
 #ifdef OPT_PERF_ENABLED
-      AIE_LOOP_FLATTEN
+          AIE_LOOP_FLATTEN
 #endif
-            {
-              A0 = pA1bfp16.pop();
-              A1 = pA2bfp16.pop();
-
-              // For non transposed matrix
-              // B0 = pB1bfp16.pop_seek(colB - 1);
-              // B1 = pB2bfp16.pop_seek(colB - 1);
-              B0 = pB1bfp16.pop();
-              B1 = pB2bfp16.pop();
-
-              accC00 = mac_8x8_8x8T(A0, B0, accC00);
-              accC01 = mac_8x8_8x8T(A0, B1, accC01);
-              accC10 = mac_8x8_8x8T(A1, B0, accC10);
-              accC11 = mac_8x8_8x8T(A1, B1, accC11);
-            }
-
-          pC1Out.push(accC00.template to_vector<bfp16ebs8>());
-          pC1Out.push(accC01.template to_vector<bfp16ebs8>());
-          pC2Out.push(accC10.template to_vector<bfp16ebs8>());
-          pC2Out.push(accC11.template to_vector<bfp16ebs8>());
-        }
-    }
+          {
+            A0 = pA1bfp16.pop();
+            A1 = pA2bfp16.pop();
+
+            // For non transposed matrix
+            // B0 = pB1bfp16.pop_seek(colB - 1);
+            // B1 = pB2bfp16.pop_seek(colB - 1);
+            B0 = pB1bfp16.pop();
+            B1 = pB2bfp16.pop();
+
+            accC00 = mac_8x8_8x8T(A0, B0, accC00);
+            accC01 = mac_8x8_8x8T(A0, B1, accC01);
+            accC10 = mac_8x8_8x8T(A1, B0, accC10);
+            accC11 = mac_8x8_8x8T(A1, B1, accC11);
+          }
+
+        pC1Out.push(accC00.template to_vector<bfp16ebs8>());
+        pC1Out.push(accC01.template to_vector<bfp16ebs8>());
+        pC2Out.push(accC10.template to_vector<bfp16ebs8>());
+        pC2Out.push(accC11.template to_vector<bfp16ebs8>());
+      }
+  }
 }
 
 extern "C" {

aie_kernels/aie2p/mm_bfp_mixed.cc

@@ -38,77 +38,77 @@ void matmul_vectorized_2x2_bfp16_bf16(const bfloat16 *__restrict pA,
   AIE_PREPARE_FOR_PIPELINING
   AIE_LOOP_MIN_ITERATION_COUNT(4)
   for (unsigned z = 0; z < rowA; z += 2) {
-      bfloat16 *__restrict pC1 = pC + (z * colB + 0) * sizeC;
-      bfloat16 *__restrict pC2 = pC + ((z + 1) * colB + 0) * sizeC;
+    bfloat16 *__restrict pC1 = pC + (z * colB + 0) * sizeC;
+    bfloat16 *__restrict pC2 = pC + ((z + 1) * colB + 0) * sizeC;
 
-      for (unsigned j = 0; j < colB; j += 2)
+    for (unsigned j = 0; j < colB; j += 2)
 #ifdef OPT_PERF_ENABLED
       AIE_LOOP_FLATTEN
 #endif
-        {
-          const bfloat16 *__restrict pA1 = pA + (z * colA + 0) * sizeA;
-          const bfloat16 *__restrict pA2 = pA + ((z + 1) * colA + 0) * sizeA;
-
-          aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pB1bfp16(pB);
-          aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pB2bfp16(pB);
-          // For non transposed matrix
-          // pB1bfp16.seek(j);
-          // pB2bfp16.seek(j + 1);
-          pB1bfp16.seek(j * colA);
-          pB2bfp16.seek((j + 1) * colA);
-
-          aie::vector<bfloat16, sizeA> A0;
-          aie::vector<bfloat16, sizeA> A1;
-          aie::block_vector<bfp16ebs8, sizeB> B0;
-          aie::block_vector<bfp16ebs8, sizeB> B1;
-
-          aie::accum<accfloat, sizeC> accC00(aie::load_v<sizeC>(pC1));
-          aie::accum<accfloat, sizeC> accC01(aie::load_v<sizeC>(pC1 + sizeC));
-          aie::accum<accfloat, sizeC> accC10(aie::load_v<sizeC>(pC2));
-          aie::accum<accfloat, sizeC> accC11(aie::load_v<sizeC>(pC2 + sizeC));
-
-          aie::accum<accfloat, 64> accA0;
-          aie::accum<accfloat, 64> accA1;
-
-          for (unsigned i = 0; i < colA; ++i)
+      {
+        const bfloat16 *__restrict pA1 = pA + (z * colA + 0) * sizeA;
+        const bfloat16 *__restrict pA2 = pA + ((z + 1) * colA + 0) * sizeA;
+
+        aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pB1bfp16(pB);
+        aie::block_vector_input_buffer_stream<bfp16ebs8, 64> pB2bfp16(pB);
+        // For non transposed matrix
+        // pB1bfp16.seek(j);
+        // pB2bfp16.seek(j + 1);
+        pB1bfp16.seek(j * colA);
+        pB2bfp16.seek((j + 1) * colA);
+
+        aie::vector<bfloat16, sizeA> A0;
+        aie::vector<bfloat16, sizeA> A1;
+        aie::block_vector<bfp16ebs8, sizeB> B0;
+        aie::block_vector<bfp16ebs8, sizeB> B1;
+
+        aie::accum<accfloat, sizeC> accC00(aie::load_v<sizeC>(pC1));
+        aie::accum<accfloat, sizeC> accC01(aie::load_v<sizeC>(pC1 + sizeC));
+        aie::accum<accfloat, sizeC> accC10(aie::load_v<sizeC>(pC2));
+        aie::accum<accfloat, sizeC> accC11(aie::load_v<sizeC>(pC2 + sizeC));
+
+        aie::accum<accfloat, 64> accA0;
+        aie::accum<accfloat, 64> accA1;
+
+        for (unsigned i = 0; i < colA; ++i)
 #ifdef OPT_PERF_ENABLED
-      AIE_LOOP_FLATTEN
+          AIE_LOOP_FLATTEN
 #endif
-            {
-              A0 = aie::load_v<sizeA>(pA1);
-              pA1 += sizeA;
-              A1 = aie::load_v<sizeA>(pA2);
-              pA2 += sizeA;
-
-              // Convert A0 into bfp16
-              accA0 = A0;
-              // Convert A1 into bfp16 through a different path (see bfp
-              // conversion example)
-              accA1 = mul_elem_64(A1, concat(broadcast_one_to_v32bfloat16(),
-                                             broadcast_one_to_v32bfloat16()));
-
-              // For non transposed matrix
-              // B0 = pB1bfp16.pop_seek(colB - 1);
-              // B1 = pB2bfp16.pop_seek(colB - 1);
-              B0 = pB1bfp16.pop();
-              B1 = pB2bfp16.pop();
-
-              accC00 = mac_8x8_8x8T(accA0.to_vector<bfp16ebs8>(), B0, accC00);
-              accC01 = mac_8x8_8x8T(accA0.to_vector<bfp16ebs8>(), B1, accC01);
-              accC10 = mac_8x8_8x8T(accA1.to_vector<bfp16ebs8>(), B0, accC10);
-              accC11 = mac_8x8_8x8T(accA1.to_vector<bfp16ebs8>(), B1, accC11);
-            }
-
-          aie::store_v(pC1, accC00.template to_vector<bfloat16>());
-          pC1 += sizeC;
-          aie::store_v(pC1, accC01.template to_vector<bfloat16>());
-          pC1 += sizeC;
-          aie::store_v(pC2, accC10.template to_vector<bfloat16>());
-          pC2 += sizeC;
-          aie::store_v(pC2, accC11.template to_vector<bfloat16>());
-          pC2 += sizeC;
-        }
-    }
+          {
+            A0 = aie::load_v<sizeA>(pA1);
+            pA1 += sizeA;
+            A1 = aie::load_v<sizeA>(pA2);
+            pA2 += sizeA;
+
+            // Convert A0 into bfp16
+            accA0 = A0;
+            // Convert A1 into bfp16 through a different path (see bfp
+            // conversion example)
+            accA1 = mul_elem_64(A1, concat(broadcast_one_to_v32bfloat16(),
+                                           broadcast_one_to_v32bfloat16()));
+
+            // For non transposed matrix
+            // B0 = pB1bfp16.pop_seek(colB - 1);
+            // B1 = pB2bfp16.pop_seek(colB - 1);
+            B0 = pB1bfp16.pop();
+            B1 = pB2bfp16.pop();
+
+            accC00 = mac_8x8_8x8T(accA0.to_vector<bfp16ebs8>(), B0, accC00);
+            accC01 = mac_8x8_8x8T(accA0.to_vector<bfp16ebs8>(), B1, accC01);
+            accC10 = mac_8x8_8x8T(accA1.to_vector<bfp16ebs8>(), B0, accC10);
+            accC11 = mac_8x8_8x8T(accA1.to_vector<bfp16ebs8>(), B1, accC11);
+          }
+
+        aie::store_v(pC1, accC00.template to_vector<bfloat16>());
+        pC1 += sizeC;
+        aie::store_v(pC1, accC01.template to_vector<bfloat16>());
+        pC1 += sizeC;
+        aie::store_v(pC2, accC10.template to_vector<bfloat16>());
+        pC2 += sizeC;
+        aie::store_v(pC2, accC11.template to_vector<bfloat16>());
+        pC2 += sizeC;
+      }
+  }
 }
 
 extern "C" {

aie_kernels/aie2p/rope.cc

@@ -9,14 +9,14 @@
 //===----------------------------------------------------------------------===//
 
 #include <aie_api/aie.hpp>
+#include <math.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <math.h>
 
 template <typename T, int N>
 void rope_kernel(const T *restrict input, const T *restrict lut,
-                        T *restrict output, int32_t dims) {
+                 T *restrict output, int32_t dims) {
   event0();
 
   for (int v = 0; v < dims; v += N) {