[mlir][linalg] Fix formatting of file Vectorization.cpp

[dcaballe]

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

51

hmmm... this formatting seems odd to me. Are you using the latest version of clang-format with the LLVM formatting?

[devajith-huawei]

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

51

Perhaps, both

clang-format -style=llvm mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp -i

and

git-clang-format HEAD~

generates different results for me.

[devajith-huawei]

Update diff with context

[dcaballe]

Clang-format is not passing. Assuming the llvm configuration is used, I wonder if the problem is that your clang-format is outdated. Perhaps, the formatting issues that you see in https://reviews.llvm.org/D145160 are related only to your code and this diff wouldn't be necessary?

[devajith-huawei]

In D145267#4168771, @dcaballe wrote:

Clang-format is not passing. Assuming the llvm configuration is used, I wonder if the problem is that your clang-format is outdated. Perhaps, the formatting issues that you see in https://reviews.llvm.org/D145160 are related only to your code and this diff wouldn't be necessary?

Thanks for reviewing. Yes, there's no clang-format build error now for https://reviews.llvm.org/D145160. This diff isn't necessary.

[devajith-huawei]

Diff not necessary.

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-#include <type_traits>
 #include <optional>
+#include <type_traits>
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 #define DEBUG_TYPE "linalg-vectorization"
 
 #define DBGS() (llvm::dbgs() << '[' << DEBUG_TYPE << "] ")
 #define LDBG(X) LLVM_DEBUG(DBGS() << X << "\n")
 
 /// Try to vectorize `convOp` as a convolution.
 static FailureOr<Operation *> vectorizeConvolution(RewriterBase &rewriter,
                                                    LinalgOp convOp);
 
 /// Return the unique instance of OpType in `block` if it is indeed unique.
 /// Return null if none or more than 1 instances exist.
 template <typename OpType>
 static OpType getSingleOpOfType(Block &block) {
   OpType res;
   block.walk([&](OpType op) {
     if (res) {
       res = nullptr;
       return WalkResult::interrupt();
     }
     res = op;

 //===----------------------------------------------------------------------===//
 // Convolution vectorization patterns
 //===----------------------------------------------------------------------===//
 
 template <int N>
 static void bindShapeDims(ShapedType shapedType) {}
 
 template <int N, typename IntTy, typename... IntTy2>
-static void bindShapeDims(ShapedType shapedType, IntTy &val, IntTy2 &...vals) {
+static void bindShapeDims(ShapedType shapedType, IntTy &val, IntTy2 &... vals) {
   val = shapedType.getShape()[N];
   bindShapeDims<N + 1, IntTy2 &...>(shapedType, vals...);
 }
 
 /// Bind a pack of int& to the leading dimensions of shapedType.getShape().
 template <typename... IntTy>
-static void bindShapeDims(ShapedType shapedType, IntTy &...vals) {
+static void bindShapeDims(ShapedType shapedType, IntTy &... vals) {
   bindShapeDims<0>(shapedType, vals...);
 }
 
 namespace {
 bool isCastOfBlockArgument(Operation *op) {
   return isa<CastOpInterface>(op) && op->getNumOperands() == 1 &&
          op->getOperand(0).isa<BlockArgument>();
 }
Conv1DGenerator(RewriterBase &rewriter, LinalgOp linalgOp, int strideW,
     if (!maybeKind || (*maybeKind != vector::CombiningKind::ADD &&
                        (oper != Pool || !isSupportedPoolKind(*maybeKind)))) {
       return;
     }
 
     auto rhsRank = rhsShapedType.getRank();
     switch (oper) {
     case Conv:
-      if (rhsRank != 2 && rhsRank!= 3)
+      if (rhsRank != 2 && rhsRank != 3)
         return;
       break;
     case Pool:
       if (rhsRank != 1)
         return;
       break;
     }
     // The op is now known to be valid.
FailureOr<Operation *> depthwiseConv() {
 
     auto linearIndex = [&](int64_t kw, int64_t w) {
       return kw * (wSize / wSizeStep) + w;
     };
 
     // Compute contraction: O{n, w, c} += I{n, sw * w + dw * kw, c} * F{c}
     for (int64_t kw = 0; kw < kwSize; ++kw) {
       for (int64_t w = 0; w < wSize; w += wSizeStep) {
-        resVals[w] = depthwiseConv1dSliceAsMulAcc(
-            rewriter, loc, lhsVals[linearIndex(kw, w)], rhsVals[kw], resVals[w]);
+        resVals[w] = depthwiseConv1dSliceAsMulAcc(rewriter, loc,
+                                                  lhsVals[linearIndex(kw, w)],
+                                                  rhsVals[kw], resVals[w]);
       }
     }
 
     // Its possible we failed to create the Fma.
     if (!llvm::all_of(resVals, [](Value v) { return v; })) {
       // Manually revert (in reverse order) to avoid leaving a bad IR state.
-      for (auto &collection : {resVals, rhsVals, lhsVals, {res, rhs, lhs, zero}})
+      for (auto &collection :
+           {resVals, rhsVals, lhsVals, {res, rhs, lhs, zero}})
         for (Value v : collection)
           rewriter.eraseOp(v.getDefiningOp());
       return rewriter.notifyMatchFailure(op, "failed to create FMA");
     }
 
     // Write back res slice: {n, wSizeStep, c} @ [0, w, 0].
     // This does not depend on kw.
     for (int64_t w = 0; w < wSize; w += wSizeStep) {