[mlir][NFC] Move getOrCreateRanges to ViewLikeInterface

[springerm]

Summary

getOrCreateRanges is a helper function for ViewLikeInterface. This function is currently defined in the MemRefDialect (and pre-declared in the TensorDialect).

Depends On D104676

[rriddle]

This is adding a dialect dependency to an interface, which is generally a code smell for something being off. Why does this interface need to depend on the standard dialect?

mlir/lib/Interfaces/CMakeLists.txt

52 ↗

(On Diff #353557)

Interfaces generally should not depend on dialects.

[springerm]

In D104690#2832378, @rriddle wrote:

This is adding a dialect dependency to an interface, which is generally a code smell for something being off. Why does this interface need to depend on the standard dialect?

The purpose of this revision is to move getOrCreateRanges from MemRefOps.cpp to some other place. (As part of cleaning up MemRefOps.cpp.) This function does not conceptually belong to the MemRef dialect. Also, this function is predeclared in MemRef dialect and in the Tensor dialect, but only defined in the MemRef dialect.

Actually, it doesn't necessarily have to go to ViewLikeInterface.cpp. Moving it into a util file...

[springerm]

address comments

[springerm]

small update

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

 
 namespace mlir {
 
 class Location;
 class OpBuilder;
 
 raw_ostream &operator<<(raw_ostream &os, Range &range);
 
-/// Return the list of Range (i.e. offset, size, stride). Each Range
-/// entry contains either the dynamic value or a ConstantIndexOp constructed
-/// with `b` at location `loc`.
-SmallVector<Range, 8> getOrCreateRanges(OffsetSizeAndStrideOpInterface op,
-                                        OpBuilder &b, Location loc);
-
 /// Given an operation, retrieves the value of each dynamic dimension through
 /// constructing the necessary DimOp operators.
 SmallVector<Value, 4> getDynOperands(Location loc, Value val, OpBuilder &b);
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // MemRef Dialect
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/Tensor/IR/Tensor.h

 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
 //===----------------------------------------------------------------------===//
-// Tensor Dialect Helpers
-//===----------------------------------------------------------------------===//
-
-namespace mlir {
-
-/// Return the list of Range (i.e. offset, size, stride). Each Range
-/// entry contains either the dynamic value or a ConstantIndexOp constructed
-/// with `b` at location `loc`.
-SmallVector<Range, 8> getOrCreateRanges(OffsetSizeAndStrideOpInterface op,
-                                        OpBuilder &b, Location loc);
-
-} // namespace mlir
-
-//===----------------------------------------------------------------------===//
 // Tensor Dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Tensor/IR/TensorOpsDialect.h.inc"
 
 //===----------------------------------------------------------------------===//
 // Tensor Dialect Operations
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/Utils/StaticValueUtils.h

 // is used in multiple dialects.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef THIRD_PARTY_LLVM_LLVM_PROJECT_MLIR_INCLUDE_MLIR_DIALECT_UTILS_STATICVALUEUTILS_H_
 #define THIRD_PARTY_LLVM_LLVM_PROJECT_MLIR_INCLUDE_MLIR_DIALECT_UTILS_STATICVALUEUTILS_H_
 
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/ViewLikeInterface.h"
 
 #include "llvm/ADT/SmallVector.h"
 
 namespace mlir {
 
 /// Helper function to dispatch an OpFoldResult into either the `dynamicVec` if
 /// it is a Value or into `staticVec` if it is an IntegerAttr.
 /// In the case of a Value, a copy of the `sentinel` value is also pushed to

 
 /// Extract int64_t values from the assumed ArrayAttr of IntegerAttr.
 SmallVector<int64_t, 4> extractFromI64ArrayAttr(Attribute attr);
 
 /// If ofr is a constant integer, i.e., an IntegerAttr or a ConstantOp with an
 /// IntegerAttr, return the integer.
 llvm::Optional<int64_t> getConstantIntValue(OpFoldResult ofr);
 
+/// Return the list of Range (i.e. offset, size, stride). Each Range
+/// entry contains either the dynamic value or a ConstantIndexOp constructed
+/// with `b` at location `loc`.
+llvm::SmallVector<mlir::Range, 8>
+getOrCreateRanges(OffsetSizeAndStrideOpInterface op, OpBuilder &b,
+                  Location loc);
+
 /// Return true if ofr and value are the same integer.
 /// Ignore integer bitwidth and type mismatch that come from the fact there is
 /// no IndexAttr and that IndexType has no bitwidth.
 bool isEqualConstantInt(OpFoldResult ofr, int64_t value);
 
 /// Return true if ofr1 and ofr2 are the same integer constant attribute values
 /// or the same SSA value.
 /// Ignore integer bitwitdh and type mismatch that come from the fact there is
 /// no IndexAttr and that IndexType have no bitwidth.
 bool isEqualConstantIntOrValue(OpFoldResult ofr1, OpFoldResult ofr2);
 
 } // namespace mlir
 
 #endif // THIRD_PARTY_LLVM_LLVM_PROJECT_MLIR_INCLUDE_MLIR_DIALECT_UTILS_STATICVALUEUTILS_H_

mlir/include/mlir/IR/OpBase.td

class BaseOpWithOffsetSizesAndStrides<Dialect dialect, string mnemonic,
   // functions.
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 
   code extraBaseClassDeclaration = [{
     /// Returns the dynamic sizes for this subview operation if specified.
     operand_range getDynamicSizes() { return sizes(); }
-
-    /// Return the list of Range (i.e. offset, size, stride). Each
-    /// Range entry contains either the dynamic value or a ConstantIndexOp
-    /// constructed with `b` at location `loc`.
-    SmallVector<Range, 8> getOrCreateRanges(OpBuilder &b, Location loc) {
-      return mlir::getOrCreateRanges(*this, b, loc);
-    }
   }];
 }
 
 // The arguments of an op.
 class Arguments<dag args> {
   dag arguments = args;
 }
 

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

 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
+#include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/ScopeExit.h"

 }
 
 /// Get the loop range for a dimension `dim` based on the `shapedOperand`. It is
 /// expected to be defined by a subview op or an extract_slice op.
 static Range getRangeFromOperandShape(OpBuilder &b, Location loc,
                                       Value shapedOperand, unsigned dim) {
   Operation *shapeProducingOp = shapedOperand.getDefiningOp();
   if (auto subViewOp = dyn_cast<memref::SubViewOp>(shapeProducingOp))
-    return subViewOp.getOrCreateRanges(b, loc)[dim];
+    return getOrCreateRanges(subViewOp, b, loc)[dim];
   if (auto sliceOp = dyn_cast<tensor::ExtractSliceOp>(shapeProducingOp))
-    return sliceOp.getOrCreateRanges(b, loc)[dim];
+    return getOrCreateRanges(sliceOp, b, loc)[dim];
   llvm_unreachable("SubviewOp or ExtractSliceOp expected");
 }
 
 /// Fuses the producer into the loop immediately enclosing the consumer.
 /// This is achieved by "recomputing" the producer at the time it
 /// is needed just before the consumer.
 static LinalgOp fuse(OpBuilder &b, LinalgOp producerOp, AffineMap producerMap,
                      OpOperand &consumerOpOperand) {

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

 #include "PassDetail.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/SCF/SCF.h"
+#include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/TypeSwitch.h"
Optional<PromotionInfo> mlir::linalg::promoteSubviewAsNewBuffer(
     OpBuilder &b, Location loc, memref::SubViewOp subView,
     AllocBufferCallbackFn allocationFn, DataLayout &layout) {
   auto viewType = subView.getType();
   auto rank = viewType.getRank();
   SmallVector<Value, 4> fullSizes;
   SmallVector<OpFoldResult> partialSizes;
   fullSizes.reserve(rank);
   partialSizes.reserve(rank);
-  for (auto en : llvm::enumerate(subView.getOrCreateRanges(b, loc))) {
+  for (auto en : llvm::enumerate(getOrCreateRanges(subView, b, loc))) {
     auto rangeValue = en.value();
     // Try to extract a tight constant.
     LLVM_DEBUG(llvm::dbgs() << "Extract tightest: " << rangeValue.size << "\n");
     IntegerAttr sizeAttr = getSmallestBoundingIndex(rangeValue.size);
     Value size =
         (!sizeAttr) ? rangeValue.size : b.create<ConstantOp>(loc, sizeAttr);
     LLVM_DEBUG(llvm::dbgs() << "Extracted tightest: " << size << "\n");
     fullSizes.push_back(size);

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

static LogicalResult verify(SubViewOp op) {
   return produceSubViewErrorMsg(result, op, expectedType, errMsg);
 }
 
 raw_ostream &mlir::operator<<(raw_ostream &os, Range &range) {
   return os << "range " << range.offset << ":" << range.size << ":"
             << range.stride;
 }
 
-/// Return the list of Range (i.e. offset, size, stride). Each Range
-/// entry contains either the dynamic value or a ConstantIndexOp constructed
-/// with `b` at location `loc`.
-SmallVector<Range, 8> mlir::getOrCreateRanges(OffsetSizeAndStrideOpInterface op,
-                                              OpBuilder &b, Location loc) {
-  std::array<unsigned, 3> ranks = op.getArrayAttrMaxRanks();
-  assert(ranks[0] == ranks[1] && "expected offset and sizes of equal ranks");
-  assert(ranks[1] == ranks[2] && "expected sizes and strides of equal ranks");
-  SmallVector<Range, 8> res;
-  unsigned rank = ranks[0];
-  res.reserve(rank);
-  for (unsigned idx = 0; idx < rank; ++idx) {
-    Value offset =
-        op.isDynamicOffset(idx)
-            ? op.getDynamicOffset(idx)
-            : b.create<ConstantIndexOp>(loc, op.getStaticOffset(idx));
-    Value size = op.isDynamicSize(idx)
-                     ? op.getDynamicSize(idx)
-                     : b.create<ConstantIndexOp>(loc, op.getStaticSize(idx));
-    Value stride =
-        op.isDynamicStride(idx)
-            ? op.getDynamicStride(idx)
-            : b.create<ConstantIndexOp>(loc, op.getStaticStride(idx));
-    res.emplace_back(Range{offset, size, stride});
-  }
-  return res;
-}
-
 /// Infer the canonical type of the result of a subview operation. Returns a
 /// type with rank `resultRank` that is either the rank of the rank-reduced
 /// type, or the non-rank-reduced type.
 static MemRefType
 getCanonicalSubViewResultType(unsigned resultRank, MemRefType sourceType,
                               ArrayRef<OpFoldResult> mixedOffsets,
                               ArrayRef<OpFoldResult> mixedSizes,
                               ArrayRef<OpFoldResult> mixedStrides) {

mlir/lib/Dialect/Utils/CMakeLists.txt

 add_mlir_library(MLIRDialectUtils
   StructuredOpsUtils.cpp
   StaticValueUtils.cpp
 
   LINK_LIBS PUBLIC
   MLIRIR
+  MLIRViewLikeInterface
 )

mlir/lib/Dialect/Utils/StaticValueUtils.cpp

 //===- StaticValueUtils.cpp - Utilities for dealing with static values ----===//
 //
 // 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/Utils/StaticValueUtils.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
+using namespace mlir;
+
 /// Helper function to dispatch an OpFoldResult into either the `dynamicVec` if
 /// it is a Value or into `staticVec` if it is an IntegerAttr.
 /// In the case of a Value, a copy of the `sentinel` value is also pushed to
 /// `staticVec`. This is useful to extract mixed static and dynamic entries that
 /// come from an AttrSizedOperandSegments trait.
 void mlir::dispatchIndexOpFoldResult(OpFoldResult ofr,
                                      SmallVectorImpl<Value> &dynamicVec,
                                      SmallVectorImpl<int64_t> &staticVec,
llvm::Optional<int64_t> mlir::getConstantIntValue(OpFoldResult ofr) {
   // Note: isa+cast-like pattern allows writing the condition below as 1 line.
   if (!attr && ofr.get<Value>().getDefiningOp<ConstantOp>())
     attr = ofr.get<Value>().getDefiningOp<ConstantOp>().getValue();
   if (auto intAttr = attr.dyn_cast_or_null<IntegerAttr>())
     return intAttr.getValue().getSExtValue();
   return llvm::None;
 }
 
+/// Return the list of Range (i.e. offset, size, stride). Each Range
+/// entry contains either the dynamic value or a ConstantIndexOp constructed
+/// with `b` at location `loc`.
+llvm::SmallVector<mlir::Range, 8>
+mlir::getOrCreateRanges(OffsetSizeAndStrideOpInterface op, OpBuilder &b,
+                        Location loc) {
+  std::array<unsigned, 3> ranks = op.getArrayAttrMaxRanks();
+  assert(ranks[0] == ranks[1] && "expected offset and sizes of equal ranks");
+  assert(ranks[1] == ranks[2] && "expected sizes and strides of equal ranks");
+  SmallVector<Range, 8> res;
+  unsigned rank = ranks[0];
+  res.reserve(rank);
+  for (unsigned idx = 0; idx < rank; ++idx) {
+    Value offset =
+        op.isDynamicOffset(idx)
+            ? op.getDynamicOffset(idx)
+            : b.create<ConstantIndexOp>(loc, op.getStaticOffset(idx));
+    Value size = op.isDynamicSize(idx)
+                     ? op.getDynamicSize(idx)
+                     : b.create<ConstantIndexOp>(loc, op.getStaticSize(idx));
+    Value stride =
+        op.isDynamicStride(idx)
+            ? op.getDynamicStride(idx)
+            : b.create<ConstantIndexOp>(loc, op.getStaticStride(idx));
+    res.emplace_back(Range{offset, size, stride});
+  }
+  return res;
+}
+
 /// Return true if ofr and value are the same integer.
 /// Ignore integer bitwidth and type mismatch that come from the fact there is
 /// no IndexAttr and that IndexType has no bitwidth.
 bool mlir::isEqualConstantInt(OpFoldResult ofr, int64_t value) {
   auto ofrValue = getConstantIntValue(ofr);
   return ofrValue && *ofrValue == value;
 }