[mlir] Introduce support for parametric side-effects

[ftynse]

Summary

The side effect infrastructure is based on the Effect and Resource class
templates, instances of instantiations of which are constructed as
thread-local singletons. With this scheme, it is impossible to further
parameterize either of those, or the EffectInstance class that contains
pointers to an Effect and Resource instances. Such a parameterization is
necessary to express more detailed side effects, e.g. those of a loop or
a function call with affine operations inside where it is possible to
precisely specify the slices of accessed buffers.

Include an additional Attribute to EffectInstance class for further
parameterization. This allows to leverage the dialect-specific
registration and uniquing capabilities of the attribute infrastructure
without requiring Effect or Resource instantiations to be attached to a
dialect themselves.

Split out the generic part of the side effect Tablegen classes into a
separate file to avoid generating built-in MemoryEffect interfaces when
processing any .td file that includes SideEffectInterfaceBase.td.

[rriddle]

LGTM

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

-//===-- SideEffectInterfaces.td - Side Effect Interfaces ------------*- tablegen -*-===//
+//===-- SideEffectInterfaceBase.td - Side Effect Base ------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains a set of interfaces that can be used to define information
-// about what effects are applied by an operation.
+// This file contains base class definitions for side effect interfaces, i.e.
+// the customizable interfaces that provide information about which effects are
+// applied by an operation.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_INTERFACES_SIDEEFFECTS
-#define MLIR_INTERFACES_SIDEEFFECTS
+#ifndef MLIR_INTERFACES_SIDEEFFECTS_BASE
+#define MLIR_INTERFACES_SIDEEFFECTS_BASE
 
 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // Resource Bindings
 //===----------------------------------------------------------------------===//
 
 // A generic resource that can be attached to a general base side effect.
class SideEffectsTraitBase<EffectOpInterfaceBase parentInterface,
 
   /// The name of the base effects class.
   string baseEffectName = parentInterface.baseEffectName;
 
   /// The derived effects being applied.
   list<SideEffect> effects = staticEffects;
 }
 
-//===----------------------------------------------------------------------===//
-// MemoryEffects
-//===----------------------------------------------------------------------===//
-
-// This def represents the definition for the memory effects interface. Users
-// should generally not use this directly, and should instead use
-// `MemoryEffects`.
-def MemoryEffectsOpInterface
-    : EffectOpInterfaceBase<"MemoryEffectOpInterface",
-                            "::mlir::MemoryEffects::Effect"> {
-  let description = [{
-    An interface used to query information about the memory effects applied by
-    an operation.
-  }];
-  let cppNamespace = "::mlir";
-}
-
-// The base class for defining specific memory effects.
-class MemoryEffect<string effectName, Resource resource>
-  : SideEffect<MemoryEffectsOpInterface, effectName, resource>;
-
-// This class represents the trait for memory effects that may be placed on
-// operations.
-class MemoryEffects<list<MemoryEffect> effects = []>
-  : SideEffectsTraitBase<MemoryEffectsOpInterface, effects>;
-
-//===----------------------------------------------------------------------===//
-// Effects
-
-// The following effect indicates that the operation allocates from some
-// resource. An 'allocate' effect implies only allocation of the resource, and
-// not any visible mutation or dereference.
-class MemAlloc<Resource resource>
-  : MemoryEffect<"MemoryEffects::Allocate", resource>;
-def MemAlloc : MemAlloc<DefaultResource>;
-
-// The following effect indicates that the operation frees some resource that
-// has been allocated. A 'free' effect implies only de-allocation of the
-// resource, and not any visible allocation, mutation or dereference.
-class MemFree<Resource resource>
-  : MemoryEffect<"MemoryEffects::Free", resource>;
-def MemFree : MemFree<DefaultResource>;
-
-// The following effect indicates that the operation reads from some
-// resource. A 'read' effect implies only dereferencing of the resource, and
-// not any visible mutation.
-class MemRead<Resource resource>
-  : MemoryEffect<"MemoryEffects::Read", resource>;
-def MemRead : MemRead<DefaultResource>;
-
-// The following effect indicates that the operation writes to some
-// resource. A 'write' effect implies only mutating a resource, and not any
-// visible dereference or read.
-class MemWrite<Resource resource>
-  : MemoryEffect<"MemoryEffects::Write", resource>;
-def MemWrite : MemWrite<DefaultResource>;
-
-//===----------------------------------------------------------------------===//
-// Effect Traits
-//===----------------------------------------------------------------------===//
-
-// Op has no side effect.
-def NoSideEffect : MemoryEffects<[]>;
-// Op has recursively computed side effects.
-def RecursiveSideEffects : NativeOpTrait<"HasRecursiveSideEffects">;
-
-#endif // MLIR_INTERFACES_SIDEEFFECTS
+#endif // MLIR_INTERFACES_SIDEEFFECTS_BASE

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

 /// parent AutomaticAllocationScope trait.
 struct AutomaticAllocationScopeResource
     : public Resource::Base<AutomaticAllocationScopeResource> {
   StringRef getName() final { return "AutomaticAllocationScope"; }
 };
 
 /// This class represents a specific instance of an effect. It contains the
 /// effect being applied, a resource that corresponds to where the effect is
-/// applied, and an optional value(either operand, result, or region entry
-/// argument) that the effect is applied to.
+/// applied, an optional value (either operand, result, or region entry
+/// argument) that the effect is applied to, and an optional parameters
+/// attribute further specifying the details of the effect.
 template <typename EffectT> class EffectInstance {
 public:
   EffectInstance(EffectT *effect, Resource *resource = DefaultResource::get())
       : effect(effect), resource(resource) {}
   EffectInstance(EffectT *effect, Value value,
                  Resource *resource = DefaultResource::get())
       : effect(effect), resource(resource), value(value) {}
+  EffectInstance(EffectT *effect, Attribute parameters,
+                 Resource *resource = DefaultResource::get())
+      : effect(effect), resource(resource), parameters(parameters) {}
+  EffectInstance(EffectT *effect, Value value, Attribute parameters,
+                 Resource *resource = DefaultResource::get())
+      : effect(effect), resource(resource), value(value),
+        parameters(parameters) {}
 
   /// Return the effect being applied.
   EffectT *getEffect() const { return effect; }
 
   /// Return the value the effect is applied on, or nullptr if there isn't a
   /// known value being affected.
   Value getValue() const { return value; }
 
   /// Return the resource that the effect applies to.
   Resource *getResource() const { return resource; }
 
+  /// Return the parameters of the effect, if any.
+  Attribute getParameters() const { return parameters; }
+
 private:
   /// The specific effect being applied.
   EffectT *effect;
 
   /// The resource that the given value resides in.
   Resource *resource;
 
   /// The value that the effect applies to. This is optionally null.
   Value value;
+
+  /// Additional parameters of the effect instance. An attribute is used for
+  /// type-safe structured storage and context-based uniquing. Concrete effects
+  /// can use this at their convenience. This is optionally null.
+  Attribute parameters;
 };
 } // namespace SideEffects
 
 //===----------------------------------------------------------------------===//
 // SideEffect Traits
 //===----------------------------------------------------------------------===//
 
 namespace OpTrait {

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

-//===-- SideEffectInterfaces.td - Side Effect Interfaces ------------*- tablegen -*-===//
+//===-- SideEffectInterfaces.td - Side Effect Interfaces ---*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a set of interfaces that can be used to define information
 // about what effects are applied by an operation.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INTERFACES_SIDEEFFECTS
 #define MLIR_INTERFACES_SIDEEFFECTS
 
-include "mlir/IR/OpBase.td"
-
-//===----------------------------------------------------------------------===//
-// Resource Bindings
-//===----------------------------------------------------------------------===//
-
-// A generic resource that can be attached to a general base side effect.
-class Resource<string resourceName> {
-  /// The resource that the associated effect is being applied to.
-  string name = resourceName;
-}
-
-// An intrinsic resource that lives in the ::mlir::SideEffects namespace.
-class IntrinsicResource<string resourceName> :
-  Resource<!strconcat("::mlir::SideEffects::", resourceName)> {
-}
-
-// A link to the DefaultResource class.
-def DefaultResource : IntrinsicResource<"DefaultResource">;
-// A link to the AutomaticAllocationScopeResource class.
-def AutomaticAllocationScopeResource :
-  IntrinsicResource<"AutomaticAllocationScopeResource">;
-
-//===----------------------------------------------------------------------===//
-// EffectOpInterface
-//===----------------------------------------------------------------------===//
-
-// A base interface used to query information about the side effects applied to
-// an operation. This template class takes the name of the derived interface
-// class, as well as the name of the base effect class.
-class EffectOpInterfaceBase<string name, string baseEffect>
-    : OpInterface<name> {
-  let methods = [
-    InterfaceMethod<[{
-        Collects all of the operation's effects into `effects`.
-      }],
-      "void", "getEffects",
-         (ins "SmallVectorImpl<::mlir::SideEffects::EffectInstance<"
-              # baseEffect # ">> &":$effects)
-    >,
-  ];
-
-  let extraClassDeclaration = [{
-    /// Collect all of the effect instances that correspond to the given
-    /// `Effect` and place them in 'effects'.
-    template <typename Effect> void getEffects(
-      SmallVectorImpl<::mlir::SideEffects::EffectInstance<
-                                              }] # baseEffect # [{>> &effects) {
-      getEffects(effects);
-      llvm::erase_if(effects, [&](auto &it) {
-        return !llvm::isa<Effect>(it.getEffect());
-      });
-    }
-
-    /// Returns true if this operation exhibits the given effect.
-    template <typename Effect> bool hasEffect() {
-      SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
-      getEffects(effects);
-      return llvm::any_of(effects, [](const auto &it) {
-        return llvm::isa<Effect>(it.getEffect());
-      });
-    }
-
-    /// Returns true if this operation only has the given effect.
-    template <typename Effect> bool onlyHasEffect() {
-      SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
-      getEffects(effects);
-      return !effects.empty() && llvm::all_of(effects, [](const auto &it) {
-        return isa<Effect>(it.getEffect());
-      });
-    }
-
-    /// Returns true if this operation has no effects.
-    bool hasNoEffect() {
-      SmallVector<::mlir::SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
-      getEffects(effects);
-      return effects.empty();
-    }
-
-    /// Returns true if the given operation has no effects for this interface.
-    static bool hasNoEffect(Operation *op) {
-      if (auto interface = dyn_cast<}] # name # [{>(op))
-        return interface.hasNoEffect();
-      return op->hasTrait<::mlir::OpTrait::HasRecursiveSideEffects>();
-    }
-
-    /// Collect all of the effect instances that operate on the provided value
-    /// and place them in 'effects'.
-    void getEffectsOnValue(::mlir::Value value,
-              llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
-              }] # baseEffect # [{>> & effects) {
-      getEffects(effects);
-      llvm::erase_if(effects, [&](auto &it) { return it.getValue() != value; });
-    }
-
-    /// Collect all of the effect instances that operate on the provided
-    /// resource and place them in 'effects'.
-    void getEffectsOnValue(::mlir::SideEffects::Resource *resource,
-              llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
-              }] # baseEffect # [{>> & effects) {
-      getEffects(effects);
-      llvm::erase_if(effects, [&](auto &it) {
-        return it.getResource() != resource;
-      });
-    }
-  }];
-
-  // The base effect name of this interface.
-  string baseEffectName = baseEffect;
-}
-
-// This class is the general base side effect class. This is used by derived
-// effect interfaces to define their effects.
-class SideEffect<EffectOpInterfaceBase interface, string effectName,
-                 Resource resourceReference> : OpVariableDecorator {
-  /// The name of the base effects class.
-  string baseEffectName = interface.baseEffectName;
-
-  /// The parent interface that the effect belongs to.
-  string interfaceTrait = interface.trait;
-
-  /// The cpp namespace of the interface trait.
-  string cppNamespace = interface.cppNamespace;
-
-  /// The derived effect that is being applied.
-  string effect = effectName;
-
-  /// The resource that the effect is being applied to.
-  string resource = resourceReference.name;
-}
-
-// This class is the base used for specifying effects applied to an operation.
-class SideEffectsTraitBase<EffectOpInterfaceBase parentInterface,
-                           list<SideEffect> staticEffects>
-    : OpInterfaceTrait<""> {
-  /// The name of the interface trait to use.
-  let trait = parentInterface.trait;
-
-  /// The cpp namespace of the interface trait.
-  string cppNamespace = parentInterface.cppNamespace;
-
-  /// The name of the base effects class.
-  string baseEffectName = parentInterface.baseEffectName;
-
-  /// The derived effects being applied.
-  list<SideEffect> effects = staticEffects;
-}
+include "mlir/Interfaces/SideEffectInterfaceBase.td"
 
 //===----------------------------------------------------------------------===//
 // MemoryEffects
 //===----------------------------------------------------------------------===//
 
 // This def represents the definition for the memory effects interface. Users
 // should generally not use this directly, and should instead use
 // `MemoryEffects`.

mlir/test/IR/test-side-effects.mlir

 %2 = "test.side_effect_op"() {effects = [
   {effect="write", test_resource}
 ]} : () -> i32
 
 // expected-remark@+1 {{found an instance of 'allocate' on a value, on resource '<Test>'}}
 %3 = "test.side_effect_op"() {effects = [
   {effect="allocate", on_result, test_resource}
 ]} : () -> i32
+
+// No _memory_ effects, but a parametric test effect.
+// expected-remark@+2 {{operation has no memory effects}}
+// expected-remark@+1 {{found a parametric effect with affine_map<(d0, d1) -> (d1, d0)>}}
+%4 = "test.side_effect_op"() {
+  effect_parameter = affine_map<(i, j) -> (j, i)>
+} : () -> i32

mlir/test/lib/Dialect/Test/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   TestDialect.cpp
   TestPatterns.cpp
   TestTraits.cpp
 )
 
 set(LLVM_TARGET_DEFINITIONS TestInterfaces.td)
 mlir_tablegen(TestTypeInterfaces.h.inc -gen-type-interface-decls)
 mlir_tablegen(TestTypeInterfaces.cpp.inc -gen-type-interface-defs)
+mlir_tablegen(TestOpInterfaces.h.inc -gen-op-interface-decls)
+mlir_tablegen(TestOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIRTestInterfaceIncGen)
 
 set(LLVM_TARGET_DEFINITIONS TestTypeDefs.td)
 mlir_tablegen(TestTypeDefs.h.inc -gen-typedef-decls)
 mlir_tablegen(TestTypeDefs.cpp.inc -gen-typedef-defs)
 add_public_tablegen_target(MLIRTestDefIncGen)
 
 
 set(LLVM_TARGET_DEFINITIONS TestOps.td)
 mlir_tablegen(TestOps.h.inc -gen-op-decls)
 mlir_tablegen(TestOps.cpp.inc -gen-op-defs)
 mlir_tablegen(TestOpsDialect.h.inc -gen-dialect-decls)
 mlir_tablegen(TestOpEnums.h.inc -gen-enum-decls)
 mlir_tablegen(TestOpEnums.cpp.inc -gen-enum-defs)
 mlir_tablegen(TestOpStructs.h.inc -gen-struct-attr-decls)
 mlir_tablegen(TestOpStructs.cpp.inc -gen-struct-attr-defs)
 mlir_tablegen(TestPatterns.inc -gen-rewriters)
 add_public_tablegen_target(MLIRTestOpsIncGen)
 
 # Exclude tests from libMLIR.so
 add_mlir_library(MLIRTestDialect
   TestDialect.cpp
+  TestInterfaces.cpp
   TestPatterns.cpp
   TestTraits.cpp
   TestTypes.cpp
 
   EXCLUDE_FROM_LIBMLIR
 
   DEPENDS
   MLIRTestInterfaceIncGen

mlir/test/lib/Dialect/Test/TestDialect.h

 //===- TestDialect.h - MLIR Dialect for testing -----------------*- 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 a fake 'test' dialect that can be used for testing things
 // that do not have a respective counterpart in the main source directories.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TESTDIALECT_H
 #define MLIR_TESTDIALECT_H
 
+#include "TestInterfaces.h"
 #include "mlir/Dialect/Traits.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/RegionKindInterface.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/CopyOpInterface.h"
 #include "mlir/Interfaces/DerivedAttributeOpInterface.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 #include "TestOpEnums.h.inc"
-
+#include "TestOpInterfaces.h.inc"
 #include "TestOpStructs.h.inc"
 #include "TestOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
 namespace mlir {
 namespace test {
 void registerTestDialect(DialectRegistry &registry);
 } // namespace test
 } // namespace mlir
 
 #endif // MLIR_TESTDIALECT_H

mlir/test/lib/Dialect/Test/TestDialect.cpp

for (Attribute element : effectsAttr) {
     SideEffects::Resource *resource = SideEffects::DefaultResource::get();
     if (effectElement.get("test_resource"))
       resource = TestResource::get();
 
     effects.emplace_back(effect, value, resource);
   }
 }
 
+void SideEffectOp::getEffects(
+    SmallVectorImpl<TestEffects::EffectInstance> &effects) {
+  auto effectsAttr = getAttrOfType<AffineMapAttr>("effect_parameter");
+  if (!effectsAttr)
+    return;
+
+  effects.emplace_back(TestEffects::Concrete::get(), effectsAttr);
+}
+
 //===----------------------------------------------------------------------===//
 // StringAttrPrettyNameOp
 //===----------------------------------------------------------------------===//
 
 // This op has fancy handling of its SSA result name.
 static ParseResult parseStringAttrPrettyNameOp(OpAsmParser &parser,
                                                OperationState &result) {
   // Add the result types.
void RegionIfOp::getSuccessorRegions(
   }
 
   // The then and else regions are the entry regions of this op.
   regions.push_back(RegionSuccessor(&thenRegion(), getThenArgs()));
   regions.push_back(RegionSuccessor(&elseRegion(), getElseArgs()));
 }
 
 #include "TestOpEnums.cpp.inc"
+#include "TestOpInterfaces.cpp.inc"
 #include "TestOpStructs.cpp.inc"
 #include "TestTypeInterfaces.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.cpp.inc"

mlir/test/lib/Dialect/Test/TestInterfaces.h

+//===- TestInterfaces.h - MLIR interfaces for testing -----------*- 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 declares interfaces for the 'test' dialect that can be used for
+// testing the interface infrastructure.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TEST_LIB_DIALECT_TEST_TESTINTERFACES_H
+#define MLIR_TEST_LIB_DIALECT_TEST_TESTINTERFACES_H
+
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+
+namespace mlir {
+namespace TestEffects {
+struct Effect : public SideEffects::Effect {
+  using SideEffects::Effect::Effect;
+
+  template <typename Derived>
+  using Base = SideEffects::Effect::Base<Derived, Effect>;
+
+  static bool classof(const SideEffects::Effect *effect);
+};
+
+using EffectInstance = SideEffects::EffectInstance<Effect>;
+
+struct Concrete : public Effect::Base<Concrete> {};
+
+} // namespace TestEffects
+} // namespace mlir
+
+#endif // MLIR_TEST_LIB_DIALECT_TEST_TESTINTERFACES_H

mlir/test/lib/Dialect/Test/TestInterfaces.cpp

+#include "TestInterfaces.h"
+
+using namespace mlir;
+
+bool mlir::TestEffects::Effect::classof(
+    const mlir::SideEffects::Effect *effect) {
+  return isa<mlir::TestEffects::Concrete>(effect);
+}

mlir/test/lib/Dialect/Test/TestInterfaces.td

 //===-- TestInterfaces.td - Test dialect interfaces --------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef TEST_INTERFACES
-#define TEST_INTERFACES
+#ifndef MLIR_TEST_DIALECT_TEST_INTERFACES
+#define MLIR_TEST_DIALECT_TEST_INTERFACES
 
 include "mlir/IR/OpBase.td"
+include "mlir/Interfaces/SideEffectInterfaceBase.td"
 
 // A type interface used to test the ODS generation of type interfaces.
 def TestTypeInterface : TypeInterface<"TestTypeInterface"> {
   let methods = [
     InterfaceMethod<"Prints the type name.",
       "void", "printTypeA", (ins "Location":$loc), [{
         emitRemark(loc) << $_type << " - TestA";
       }]
def TestTypeInterface : TypeInterface<"TestTypeInterface"> {
   let extraTraitClassDeclaration = [{
     /// Prints the type name.
     void printTypeE(Location loc) const {
       emitRemark(loc) << $_type << " - TestE";
     }
   }];
 }
 
-#endif // TEST_INTERFACES
+def TestEffectOpInterface
+    : EffectOpInterfaceBase<"TestEffectOpInterface",
+                            "::mlir::TestEffects::Effect"> {
+  let cppNamespace = "::mlir";
+}
+
+class TestEffect<string effectName>
+    : SideEffect<TestEffectOpInterface, effectName, DefaultResource>;
+
+class TestEffects<list<TestEffect> effects = []>
+   : SideEffectsTraitBase<TestEffectOpInterface, effects>;
+
+def TestConcreteEffect : TestEffect<"TestEffects::Concrete">;
+
+#endif // MLIR_TEST_DIALECT_TEST_INTERFACES

mlir/test/lib/Dialect/Test/TestOps.td

 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/RegionKindInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/CopyOpInterface.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
+include "TestInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "::mlir::test";
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
 }
def FormatTypesMatchAttrOp : TEST_Op<"format_types_match_attr", [
   let assemblyFormat = "attr-dict $value";
 }
 
 //===----------------------------------------------------------------------===//
 // Test SideEffects
 //===----------------------------------------------------------------------===//
 
 def SideEffectOp : TEST_Op<"side_effect_op",
-    [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
+    [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
+     DeclareOpInterfaceMethods<TestEffectOpInterface>]> {
   let results = (outs AnyType:$result);
 }
 
 //===----------------------------------------------------------------------===//
 // Test CopyOpInterface
 //===----------------------------------------------------------------------===//
 
 def CopyOp : TEST_Op<"copy", [CopyOpInterface]> {

mlir/test/lib/IR/TestSideEffects.cpp

module.walk([&](MemoryEffectOpInterface op) {
           diag << "'write'";
 
         if (instance.getValue())
           diag << " on a value,";
 
         diag << " on resource '" << instance.getResource()->getName() << "'";
       }
     });
+
+    SmallVector<TestEffects::EffectInstance, 1> testEffects;
+    module.walk([&](TestEffectOpInterface op) {
+      testEffects.clear();
+      op.getEffects(testEffects);
+
+      if (testEffects.empty())
+        return;
+
+      for (const TestEffects::EffectInstance &instance : testEffects) {
+        op.emitRemark() << "found a parametric effect with "
+                        << instance.getParameters();
+      }
+    });
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 void registerSideEffectTestPasses() {
   PassRegistration<SideEffectsPass>("test-side-effects",
                                     "Test side effects interfaces");
 }
 } // namespace mlir