[mlir] Move duplicated function getSingleOpOfType into BlockUtilities.h

[clementval]

Summary

The tenmplated function getSingleOpOfType was duplicated in two files.
This function is generic enough that other conversion/anaylsis might use it. In
order to avoid more copy/paste of this function, this patch move it into a new
header files for utility function working on Blocks.

https://llvm.discourse.group/t/where-to-move-utility-function/4330

[clementval]

Add missing newline

[clementval]

Update header guard

[jozefl]

mlir/include/mlir/IR/BlockUtilities.h

19

This refactor might be a good opportunity to use "\p block" to refer to the "block" parameter in the function's Doxygen comment.

[ftynse]

mlir/include/mlir/IR/BlockUtilities.h

17

Please don't do using namespace in a header.

19

We don't use backslash Doxygen commands in MLIR. Doxygen is also able to render Markdown AFAIK.

22

Please fix the linter (may need to #include Block.h)

[clementval]

Address review comment

[mehdi_amini]

mlir/include/mlir/IR/BlockUtilities.h

24

I don't think static is usual for such function in headers.

26

From the function description, I didn't expect a walk: this will traverse nested region and so could return an operation that isn't directly in this block. That makes it a confusing/dangerous API right now.
Would current client work with: for (auto op : block.getOps<OpType>()) instead?

[clementval]

Remove static modifier + simplify the code and make it closer to the description.

[rriddle]

mlir/include/mlir/IR/BlockUtilities.h

24

Does a method like this pull its weight as a general utility? This feels like a very small code block, which would likely be better resolved by something in STLExtras if we really wanted to simplify it.

auto ops = blocks.getOps<OpType>();
OpType op = ops.empty() ? OpType() : *ops.begin();

^ That already feels very simple.

[mehdi_amini]

mlir/include/mlir/IR/BlockUtilities.h

24

OpType op = ops.empty() ? OpType() : *ops.begin();

This does not exactly do the same thing, the method here return nullptr if ops has two elements or more.

[rriddle]

mlir/include/mlir/IR/BlockUtilities.h

24

Updated:

auto ops = blocks.getOps<OpType>();
OpType op = llvm::hasSingleElement(ops) ? *ops.begin() : OpType();

[clementval]

mlir/include/mlir/IR/BlockUtilities.h

24

At this point it might just makes more sense to just replace the function with the small code snippet where it was used.

[clementval]

mlir/include/mlir/IR/BlockUtilities.h

24

From the FIR side, we do not really need this function anymore. Anyway, I'm happy to update this patch to remove the duplicates.

[clementval]

Not needed for FIR anymore.

mlir/include/mlir/IR/BlockUtilities.h

+//===- BlockUtilities.h - MLIR Block utility functions-----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines utility functions working on Blocks.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_IR_BLOCK_UTILITIES_H
+#define MLIR_IR_BLOCK_UTILITIES_H
+
+using namespace mlir;
+
+/// 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 = nullptr;
+  block.walk([&](OpType op) {
+    if (res) {
+      res = nullptr;
+      return WalkResult::interrupt();
+    }
+    res = op;
+    return WalkResult::advance();
+  });
+  return res;
+}
+
+#endif // MLIR_IR_BLOCK_UTILITIES_H

mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp

 //===- LinalgInterfaces.cpp - Linalg interfaces implementation ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/IR/LinalgInterfaces.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/AffineMap.h"
+#include "mlir/IR/BlockUtilities.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "llvm/ADT/SmallSet.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 /// Include the definitions of the copy operation interface.
 #include "mlir/Dialect/Linalg/IR/LinalgInterfaces.cpp.inc"
if (v == from)
       return true;
     Operation *op = v.getDefiningOp();
     if (!op || op->getNumOperands() != 1)
       return false;
     v = op->getOperand(0);
   };
 }
 
-/// 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 = nullptr;
-  block.walk([&](OpType op) {
-    if (res) {
-      res = nullptr;
-      return WalkResult::interrupt();
-    }
-    res = op;
-    return WalkResult::advance();
-  });
-  return res;
-}
-
 /// Detect whether res is any permutation of `u5(u1(c) + u2(u3(a) * u4(b)))`
 /// on the field (AddOpType, MulOpType), where u1, u2, u3, u4 and u5 represent
 /// unary operations that may change the type.
 template <typename AddOpType, typename MulOpType>
 static bool isAddMul(Block &block) {
   if (block.getNumArguments() != 3)
     return false;
   Operation *yieldOp = block.getTerminator();

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

 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
+#include "mlir/IR/BlockUtilities.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/ScopeExit.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>
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 using llvm::dbgs;
 
 #define DEBUG_TYPE "linalg-vectorization"
 
-/// 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;
-    return WalkResult::advance();
-  });
-  return res;
-}
-
 /// Given an indexing `map` coming from a LinalgOp indexing, restricted to a
 /// projectedPermutation, compress the unused dimensions to serve as a
 /// permutation_map for a vector transfer operation.
 /// For example, given a linalg op such as:
 ///
 /// ```
 ///   %0 = linalg.generic {
 ///        indexing_maps = affine_map<(d0, d1, d2, d3, d4) -> (d4, d0, d2)>,