[mlir] Add a ViewLikeOpInterface

[antiagainst]

Summary

This can help provide a common interface for view-like
ops so that for example Linalg's dependency analysis
can avoid relying on concrete ops.

[mravishankar]

Nice! This looks fine to me, but maybe wait for another set of eyes on it (I am not as intimately familiar with the interface method specification)

[rriddle]

I think this is fine for now.

mlir/include/mlir/Interfaces/ViewLikeInterface.td

22

You could avoid the word "memref" here altogether and just use buffer.

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.h

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/SideEffects.h"
+#include "mlir/Interfaces/ViewLikeInterface.h"
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 namespace linalg {
 
 class ConvOp;
 class PoolingMaxOp;
 class PoolingMinOp;

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

 //===----------------------------------------------------------------------===//
 
 #ifndef LINALG_OPS
 #define LINALG_OPS
 
 include "mlir/Dialect/Affine/IR/AffineOpsBase.td"
 include "mlir/Dialect/Linalg/IR/LinalgBase.td"
 include "mlir/Interfaces/SideEffects.td"
+include "mlir/Interfaces/ViewLikeInterface.td"
 
 // Base class for Linalg dialect ops that do not correspond to library calls.
 class Linalg_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Linalg_Dialect, mnemonic, traits> {
   // For every linalg op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
let extraClassDeclaration = commonExtraClassDeclaration # [{
     }
     SmallVector<AffineMap, 4> getReassociationMaps() {
       return llvm::to_vector<4>(llvm::map_range(reassociation(),
         [](Attribute a) { return a.cast<AffineMapAttr>().getValue(); }));
     }
   }];
 }
 
-def Linalg_SliceOp : Linalg_Op<"slice", [NoSideEffect]>,
+def Linalg_SliceOp : Linalg_Op<"slice", [
+      DeclareOpInterfaceMethods<ViewLikeOpInterface>, NoSideEffect]>,
     Arguments<(ins AnyStridedMemRef:$view,
                    Variadic<AnyTypeOf<[Range, Index]>>:$indexings)>,
     Results<(outs AnyStridedMemRef)> {
   let summary = "Produce a rank-reduced `subview` of a base `view`.";
   let description = [{
     The `linalg.slice` op allows defining a subregion of a smaller rank than the
     operand `view` within the underlying buffer.
 

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffects.h"
+#include "mlir/Interfaces/ViewLikeInterface.h"
 
 // Pull in all enum type definitions and utility function declarations.
 #include "mlir/Dialect/StandardOps/IR/OpsEnums.h.inc"
 
 namespace mlir {
 class AffineMap;
 class Builder;
 class FuncOp;

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 
 #ifndef STANDARD_OPS
 #define STANDARD_OPS
 
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/SideEffects.td"
+include "mlir/Interfaces/ViewLikeInterface.td"
 
 def StandardOps_Dialect : Dialect {
   let name = "std";
   let cppNamespace = "";
   let hasConstantMaterializer = 1;
 }
 
 // Base class for Standard dialect ops.
def SubIOp : IntArithmeticOp<"subi"> {
   let summary = "integer subtraction operation";
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SubViewOp
 //===----------------------------------------------------------------------===//
 
-def SubViewOp : Std_Op<"subview", [AttrSizedOperandSegments, NoSideEffect]> {
+def SubViewOp : Std_Op<"subview", [
+    AttrSizedOperandSegments, 
+    DeclareOpInterfaceMethods<ViewLikeOpInterface>,
+    NoSideEffect,
+  ]> {
   let summary = "memref subview operation";
   let description = [{
     The "subview" operation converts a memref type to another memref type
     which represents a reduced-size view of the original memref as specified by
     the operation's offsets, sizes and strides arguments.
 
     The SubView operation supports the following arguments:
     *) Memref: the "base" memref on which to create a "view" memref.
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ViewOp
 //===----------------------------------------------------------------------===//
 
-def ViewOp : Std_Op<"view", [NoSideEffect]> {
+def ViewOp : Std_Op<"view", [
+    DeclareOpInterfaceMethods<ViewLikeOpInterface>, NoSideEffect]> {
   let summary = "memref view operation";
   let description = [{
     The "view" operation converts a 1-D memref with i8 element type,
     to an N-D memref with arbitrary element type. In addition, the ViewOp
     supports the following arguments:
     *) A single dynamic offset operand can be specified which represents a
        a dynamic offset within the base 1-D memref at which to create the
        resulting memref view.

mlir/include/mlir/Interfaces/CMakeLists.txt

 mlir_tablegen(LoopLikeInterface.h.inc -gen-op-interface-decls)
 mlir_tablegen(LoopLikeInterface.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIRLoopLikeInterfaceIncGen)
 
 set(LLVM_TARGET_DEFINITIONS SideEffects.td)
 mlir_tablegen(SideEffectInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(SideEffectInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIRSideEffectOpInterfacesIncGen)
+
+set(LLVM_TARGET_DEFINITIONS ViewLikeInterface.td)
+mlir_tablegen(ViewLikeInterface.h.inc -gen-op-interface-decls)
+mlir_tablegen(ViewLikeInterface.cpp.inc -gen-op-interface-defs)
+add_public_tablegen_target(MLIRViewLikeInterfaceIncGen)

mlir/include/mlir/Interfaces/ViewLikeInterface.h

+//===- ViewLikeInterface.h - View-like operations interface ---------------===//
+//
+// 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 implements the operation interface for view-like operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_INTERFACES_VIEWLIKEINTERFACE_H_
+#define MLIR_INTERFACES_VIEWLIKEINTERFACE_H_
+
+#include "mlir/IR/OpDefinition.h"
+
+namespace mlir {
+
+#include "mlir/Interfaces/ViewLikeInterface.h.inc"
+
+} // namespace mlir
+
+#endif // MLIR_INTERFACES_VIEWLIKEINTERFACE_H_

mlir/include/mlir/Interfaces/ViewLikeInterface.td

+//===- ViewLikeInterface.td - ViewLike interface -----------*- tablegen -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the interface for view-like operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_INTERFACES_VIEWLIKEINTERFACE
+#define MLIR_INTERFACES_VIEWLIKEINTERFACE
+
+include "mlir/IR/OpBase.td"
+
+def ViewLikeOpInterface : OpInterface<"ViewLikeOpInterface"> {
+  let description = [{
+    A view-like operation "views" a buffer in a potentially different way. It
+    takes in a (view of) buffer (and potentially some other operands) and returns
+    another view of buffer.
+  }];
+
+  let methods = [
+    InterfaceMethod<
+      "Returns the source buffer from which the view is created.",
+      "Value", "getViewSource">
+  ];
+}
+
+#endif // MLIR_INTERFACES_VIEWLIKEINTERFACE

mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp

Value Aliases::find(Value v) {
   if (it != aliases.end()) {
     assert(it->getSecond().getType().isa<MemRefType>() && "Memref expected");
     return it->getSecond();
   }
 
   while (true) {
     if (v.isa<BlockArgument>())
       return v;
-    if (auto alloc = dyn_cast_or_null<AllocOp>(v.getDefiningOp())) {
+    Operation *defOp = v.getDefiningOp();
+    if (auto alloc = dyn_cast_or_null<AllocOp>(defOp)) {
       if (isStrided(alloc.getType()))
         return alloc.getResult();
     }
-    if (auto slice = dyn_cast_or_null<SliceOp>(v.getDefiningOp())) {
-      auto it = aliases.insert(std::make_pair(v, find(slice.view())));
+    if (auto viewLikeOp = dyn_cast_or_null<ViewLikeOpInterface>(defOp)) {
+      auto it =
+          aliases.insert(std::make_pair(v, find(viewLikeOp.getViewSource())));
       return it.first->second;
     }
-    if (auto view = dyn_cast_or_null<ViewOp>(v.getDefiningOp())) {
-      auto it = aliases.insert(std::make_pair(v, view.source()));
-      return it.first->second;
-    }
-    if (auto view = dyn_cast_or_null<SubViewOp>(v.getDefiningOp())) {
-      v = view.source();
-      continue;
-    }
+
     llvm::errs() << "View alias analysis reduces to: " << v << "\n";
     llvm_unreachable("unsupported view alias case");
   }
 }
 
 StringRef LinalgDependenceGraph::getDependenceTypeStr(DependenceType depType) {
   switch (depType) {
   case LinalgDependenceGraph::DependenceType::RAW:

mlir/lib/Dialect/Linalg/IR/CMakeLists.txt

add_dependencies(MLIRLinalgOps
   MLIRLinalgOpsIncGen
   MLIRLinalgStructuredOpsIncGen
   MLIRLinalgStructuredOpsInterfaceIncGen
   )
 target_link_libraries(MLIRLinalgOps
   PUBLIC
   MLIRIR
   MLIRSideEffects
+  MLIRViewLikeInterface
   MLIRStandardOps
   )

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

for (auto indexing : op.indexings()) {
     ++index;
   }
   if (op.getRank() != rank)
     return op.emitOpError() << "expected rank of the view(" << op.getRank()
                             << ") to be the number of ranges(" << rank << ")";
   return success();
 }
 
+Value SliceOp::getViewSource() { return view(); }
+
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 void mlir::linalg::TransposeOp::build(Builder *b, OperationState &result,
                                       Value view, AffineMapAttr permutation,
                                       ArrayRef<NamedAttribute> attrs) {
   auto permutationMap = permutation.getValue();
   assert(permutationMap);

mlir/lib/Dialect/StandardOps/CMakeLists.txt

add_mlir_dialect_library(MLIRStandardOps
   )
 target_link_libraries(MLIRStandardOps
   PUBLIC
   MLIRCallInterfaces
   MLIRControlFlowInterfaces
   MLIREDSC
   MLIRIR
   MLIRSideEffects
+  MLIRViewLikeInterface
   LLVMSupport
   )

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

for (auto resultStride : enumerate(resultStrides)) {
     if (resultStride.value() < baseStride ||
         resultStride.value() % baseStride != 0)
       return failure();
     staticStrides[resultStride.index()] = resultStride.value() / baseStride;
   }
   return success();
 }
 
+Value SubViewOp::getViewSource() { return source(); }
+
 namespace {
 
 /// Pattern to rewrite a subview op with constant size arguments.
 class SubViewOpShapeFolder final : public OpRewritePattern<SubViewOp> {
 public:
   using OpRewritePattern<SubViewOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(SubViewOp subViewOp,
static LogicalResult verify(ViewOp op) {
   // Verify dynamic strides symbols were added to correct dimensions based
   // on dynamic sizes.
   if (failed(verifyDynamicStrides(viewType, strides)))
     return op.emitError("incorrect dynamic strides in view memref type ")
            << viewType;
   return success();
 }
 
+Value ViewOp::getViewSource() { return source(); }
+
 namespace {
 
 struct ViewOpShapeFolder : public OpRewritePattern<ViewOp> {
   using OpRewritePattern<ViewOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ViewOp viewOp,
                                 PatternRewriter &rewriter) const override {
     // Return if none of the operands are constants.

mlir/lib/Interfaces/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   CallInterfaces.cpp
   ControlFlowInterfaces.cpp
   DerivedAttributeOpInterface.cpp
   InferTypeOpInterface.cpp
   LoopLikeInterface.cpp
   SideEffects.cpp
+  ViewLikeInterface.cpp
   )
 
 add_mlir_library(MLIRCallInterfaces
   CallInterfaces.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Interfaces
 
add_mlir_library(MLIRSideEffects
 
   DEPENDS
   MLIRSideEffectOpInterfacesIncGen
   )
 target_link_libraries(MLIRSideEffects
   PUBLIC
   MLIRIR
   )
+
+add_mlir_library(MLIRViewLikeInterface
+  ViewLikeInterface.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Interfaces
+
+  DEPENDS
+  MLIRViewLikeInterfaceIncGen
+  )
+target_link_libraries(MLIRLoopLikeInterface
+  PUBLIC
+  MLIRIR
+  )

mlir/lib/Interfaces/ViewLikeInterface.cpp

+//===- ViewLikeInterface.cpp - View-like operations in MLIR ---------------===//
+//
+// 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/Interfaces/ViewLikeInterface.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// ViewLike Interfaces
+//===----------------------------------------------------------------------===//
+
+/// Include the definitions of the loop-like interfaces.
+#include "mlir/Interfaces/ViewLikeInterface.cpp.inc"