[mlir][SideEffects] Define a set of interfaces and traits for defining side effects

[rriddle]

Summary

This revision introduces the infrastructure for defining side-effects and attaching them to operations. This infrastructure allows for defining different types of side effects, that don't interact with each other, but use the same internal mechanisms. At the base of this is an interface that allows operations to specify the different effect instances that are exhibited by a specific operation instance. An effect instance is comprised of the following:

• Effect: The specific effect being applied. For memory related effects this may be reading from memory, storing to memory, etc.

• Value: A specific value, either operand/result/region argument, the effect pertains to.

• Resource: This is a global entity that represents the domain within which the effect is being applied.

MLIR serves many different abstractions, which cover many different domains. Simple effects are may have very different context, for example writing to an in-memory buffer vs a database. This revision defines uses this infrastructure to define a set of initial MemoryEffects. The are effects that generally correspond to memory of some kind; Allocate, Free, Read, Write.

This set of memory effects will be used in follow revisions to generalize various parts of the compiler, and make others more powerful(e.g. DCE).

This infrastructure was originally proposed here:
https://groups.google.com/a/tensorflow.org/g/mlir/c/v2mNl4vFCUM

Depends On D74438

[jpienaar]

Just very quick skim, but could you add tests here already?

mlir/include/mlir/IR/SideEffects.td

2

Isn't the extra --- normally on the left? https://llvm.org/docs/CodingStandards.html#file-headers

[rriddle]

Add tests

[rriddle]

Update header comment

[rriddle]

Resolve remaining comments.

[rriddle]

In D74439#1870934, @jpienaar wrote:

Just very quick skim, but could you add tests here already?

I had some spread throughout this revision stack, but I moved/added a bunch here.

mlir/include/mlir/IR/SideEffects.td

2

I copied this from one of the other files, I'll have to go back and see which file that was.

[jpienaar]

Nice, looking forward to using (whatever we end up calling) "dynamic" op side effects :)

mlir/include/mlir/IR/OpDefinition.h

1192

Nit: Effect modelling seems like the generic/more abstract part and side-effects more specific, which makes me think these should have the opposite nesting. WDYT?

1233

Perhaps older version of clang-format/version that isn't picking up local config ... I'm assuming you'll run clang-format to fix this before.

1350–1353

A little bit fuzzy for me.

So this is, an op that may have side-effects depending on the whether the operands in its regions have side-effects. Or that is probably too specialized, e.g., I'm excluding attributes, esp. function attributes, but one could also have an attribute "has_side_effect" that determines if the op has side-effects.

Recursive makes me think of descending into regions, but I don't know if it captures attributes that affect effects. Perhaps this was already discussed in the discourse thread ... but would HasDynamicSideEffect ? HasOptionalSideEffect ? MaybeHasSideEffect ?

1356

Document why is HasNoSideEffect used here? (from the comment I can see why, but it is a bit implicit :-))

1391–1393

Reflow ? Seem text lines could be packed.

mlir/include/mlir/IR/SideEffects.td

14

Isn't this MLIR_IR_SIDEEFFECTS ?

30

s/ of the effects that are exhibited by this operation and places them in effects./ the operation's effects into effects/ ?

(same below)

69

ID is implicit with template instantiation, perhaps focus comment on the user interface.

141

But it isn't a class :) [in the TableGen sense of the word]

168

This is an important constraint that could be a bit subtle ... I'm assuming the docs explain rationale :)

mlir/test/lib/TestDialect/TestDialect.cpp

366

Using both effect and affect, show off :)

[mehdi_amini]

Awesome!

mlir/include/mlir/IR/OpDefinition.h

1192

Meta question maybe but: what is an "effect" that isn't a "side-effect"?

1233

Google3 isn't picking on the .clang-format in mlir/

mlir/include/mlir/IR/SideEffects.td

168

I don't understand the reason for "this effect may only be placed on result or region argument", is this explained somewhere else? (maybe link from here if so)

[rriddle]

Rebase and resolve comments

mlir/include/mlir/IR/OpDefinition.h

1192

I have the exact same thoughts as @mehdi_amini. It also keeps consistency with everything else we have, e.g. HasNoSideEffect.

1350–1353

This is explicitly for the region case. This is effectively stating that the effects of operations within nested regions should be included when considering the effects of this operation. For example, if we have the following:

mlir
affine.for ... {
  affine.store ...
}

The affine.for itself is side effect free, but for analysis sake we also consider the effects of its body. So an analysis could look at affine.for and say "this loop has a write". This also allows for treating lambda like operations as side-effect free:

%foo = my.lambda { 
                 std.store ...
             } : () -> i32

%foo has no side effects, as it does not execute the body.

The optional side effect case is already handled by the interface itself. The operation can freely query attributes/etc. before populating the set of effects that are applied. This was intentional so that we can support things like function/call attributes that define various effect bits(LLVM style).

mlir/include/mlir/IR/SideEffects.td

168

There is no good reason other than forcing a specific usage pattern. I removed that comment. I can see use cases where a we allocate to an existing Value(e.g. placement new-esque).

[rriddle]

Rebase

mlir/include/mlir/IR/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS OpAsmInterface.td)
 mlir_tablegen(OpAsmInterface.h.inc -gen-op-interface-decls)
 mlir_tablegen(OpAsmInterface.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIROpAsmInterfacesIncGen)
+
+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)

mlir/include/mlir/IR/OpBase.td

 // Op behaves like a function.
 def FunctionLike : NativeOpTrait<"FunctionLike">;
 // Op is isolated from above.
 def IsolatedFromAbove : NativeOpTrait<"IsIsolatedFromAbove">;
 // Op results are float or vectors/tensors thereof.
 def ResultsAreFloatLike : NativeOpTrait<"ResultsAreFloatLike">;
 // Op has no side effect.
 def NoSideEffect : NativeOpTrait<"HasNoSideEffect">;
+// Op has recursively computed side effects.
+def RecursiveSideEffects : NativeOpTrait<"HasRecursiveSideEffects">;
 // Op has the same operand type.
 def SameTypeOperands : NativeOpTrait<"SameTypeOperands">;
 // Op has same shape for all operands.
 def SameOperandsShape : NativeOpTrait<"SameOperandsShape">;
 // Op has same operand and result shape.
 def SameOperandsAndResultShape : NativeOpTrait<"SameOperandsAndResultShape">;
 // Op has the same operand and result type.
 def SameOperandsAndResultType : NativeOpTrait<"SameOperandsAndResultType">;

mlir/include/mlir/IR/OpDefinition.h

 class IsCommutative : public TraitBase<ConcreteType, IsCommutative> {
 public:
   static AbstractOperation::OperationProperties getTraitProperties() {
     return static_cast<AbstractOperation::OperationProperties>(
         OperationProperty::Commutative);
   }
 };
 
-/// This class adds property that the operation has no side effects.
-template <typename ConcreteType>
-class HasNoSideEffect : public TraitBase<ConcreteType, HasNoSideEffect> {
-public:
-  static AbstractOperation::OperationProperties getTraitProperties() {
-    return static_cast<AbstractOperation::OperationProperties>(
-        OperationProperty::NoSideEffect);
-  }
-};
-
 /// This class verifies that all operands of the specified op have a float type,
 /// a vector thereof, or a tensor thereof.
 template <typename ConcreteType>
 class OperandsAreFloatLike
     : public TraitBase<ConcreteType, OperandsAreFloatLike> {
 public:
   static LogicalResult verifyTrait(Operation *op) {
     return impl::verifyOperandsAreFloatLike(op);
static Concept *getInterfaceFor(Operation *op) {
     auto *abstractOp = op->getAbstractOperation();
     return abstractOp ? abstractOp->getInterface<ConcreteType>() : nullptr;
   }
 
   /// A pointer to the impl concept object.
   Concept *impl;
 };
 
+//===----------------------------------------------------------------------===//
+// Operation Side-Effect Modeling
+//===----------------------------------------------------------------------===//
+
+// TODO(riverriddle) This should be in its own file in a proper
+// traits/interfaces directory. Move it there when we have one.
+
+namespace SideEffects {
+//===--------------------------------------------------------------------===//
+// Effects
+
+/// This class represents a base class for a specific effect type.
+class Effect {
+public:
+  /// This base class is used for derived effects that are non-parametric.
+  template <typename DerivedEffect, typename BaseEffect = Effect>
+  class Base : public BaseEffect {
+  public:
+    using BaseT = Base<DerivedEffect>;
+
+    /// Return the unique identifier for the base effects class.
+    static ClassID *getEffectID() { return ClassID::getID<DerivedEffect>(); }
+
+    /// 'classof' used to support llvm style cast functionality.
+    static bool classof(const Effect *effect) {
+      return effect->getEffectID() == BaseT::getEffectID();
+    }
+
+    /// Returns a unique instance for the derived effect class.
+    static DerivedEffect *get() {
+      return BaseEffect::template get<DerivedEffect>();
+    }
+    using BaseEffect::get;
+
+  protected:
+    Base() : BaseEffect(BaseT::getEffectID()){};
+  };
+
+  /// Return the unique identifier for the base effects class.
+  ClassID *getEffectID() const { return id; }
+
+  /// Returns a unique instance for the given effect class.
+  template <typename DerivedEffect> static DerivedEffect *get() {
+    static_assert(std::is_base_of_v<Effect, DerivedEffect>,
+                  "expected DerivedEffect to inherit from Effect");
+
+    static DerivedEffect instance;
+    return &instance;
+  }
+
+protected:
+  Effect(ClassID *id) : id(id) {}
+
+private:
+  /// The id of the derived effect class.
+  ClassID *id;
+};
+
+//===--------------------------------------------------------------------===//
+// Resources
+
+/// This class represents a specific resource that an effect applies to. This
+/// class represents an abstract interface for a given resource.
+class Resource {
+public:
+  virtual ~Resource() {}
+
+  /// This base class is used for derived effects that are non-parametric.
+  template <typename DerivedResource, typename BaseResource = Resource>
+  class Base : public BaseResource {
+  public:
+    using BaseT = Base<DerivedResource>;
+
+    /// Returns a unique instance for the given effect class.
+    static DerivedResource *get() {
+      static DerivedResource instance;
+      return &instance;
+    }
+
+    /// Return the unique identifier for the base resource class.
+    static ClassID *getResourceID() {
+      return ClassID::getID<DerivedResource>();
+    }
+
+    /// 'classof' used to support llvm style cast functionality.
+    static bool classof(const Resource *resource) {
+      return resource->getResourceID() == BaseT::getResourceID();
+    }
+
+  protected:
+    Base() : BaseResource(BaseT::getResourceID()){};
+  };
+
+  /// Return the unique identifier for the base resource class.
+  ClassID *getResourceID() const { return id; }
+
+  /// Return a string name of the resource.
+  virtual StringRef getName() = 0;
+
+protected:
+  Resource(ClassID *id) : id(id) {}
+
+private:
+  /// The id of the derived resource class.
+  ClassID *id;
+};
+
+/// A conservative default resource kind.
+struct DefaultResource : public Resource::Base<DefaultResource> {
+  StringRef getName() final { return "<Default>"; }
+};
+
+/// 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.
+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) {}
+
+  /// 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; }
+
+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;
+};
+} // namespace SideEffects
+
+//===----------------------------------------------------------------------===//
+// SideEffect Traits
+
+namespace OpTrait {
+/// This trait indicates that an operation never has side effects.
+template <typename ConcreteType>
+class HasNoSideEffect : public TraitBase<ConcreteType, HasNoSideEffect> {
+public:
+  static AbstractOperation::OperationProperties getTraitProperties() {
+    return static_cast<AbstractOperation::OperationProperties>(
+        OperationProperty::NoSideEffect);
+  }
+};
+/// This trait indicates that the side effects of an operation includes the
+/// effects of operations nested within its regions. If the operation has no
+/// derived effects interfaces, the operation itself can be assumed to have no
+/// side effects.
+template <typename ConcreteType>
+class HasRecursiveSideEffects
+    : public TraitBase<ConcreteType, HasNoSideEffect> {};
+} // namespace OpTrait
+
+//===----------------------------------------------------------------------===//
+// Operation Memory-Effect Modeling
+//===----------------------------------------------------------------------===//
+
+namespace MemoryEffects {
+/// This class represents the base class used for memory effects.
+struct Effect : public SideEffects::Effect {
+  using SideEffects::Effect::Effect;
+
+  /// A base class for memory effects that provides helper utilities.
+  template <typename DerivedEffect>
+  using Base = SideEffects::Effect::Base<DerivedEffect, Effect>;
+
+  static bool classof(const SideEffects::Effect *effect);
+};
+using EffectInstance = SideEffects::EffectInstance<Effect>;
+
+/// 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.
+struct Allocate : public Effect::Base<Allocate> {};
+
+/// The following effect indicates that the operation frees some resource that
+/// has been allocated. An 'allocate' effect implies only de-allocation of the
+/// resource, and not any visible allocation, mutation or dereference.
+struct Free : public Effect::Base<Free> {};
+
+/// 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.
+struct Read : public Effect::Base<Read> {};
+
+/// 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.
+struct Write : public Effect::Base<Write> {};
+}; // namespace MemoryEffects
+
+//===----------------------------------------------------------------------===//
+// SideEffect Interfaces
+
+/// Include the definitions of the side effect interfaces.
+#include "mlir/IR/SideEffectInterfaces.h.inc"
+
+//===----------------------------------------------------------------------===//
+// Common Operation Folders/Parsers/Printers
+//===----------------------------------------------------------------------===//
+
 // These functions are out-of-line implementations of the methods in UnaryOp and
 // BinaryOp, which avoids them being template instantiated/duplicated.
 namespace impl {
 ParseResult parseOneResultOneOperandTypeOp(OpAsmParser &parser,
                                            OperationState &result);
 
 void buildBinaryOp(Builder *builder, OperationState &result, Value lhs,
                    Value rhs);

mlir/include/mlir/IR/SideEffects.td

+//===-- SideEffects.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_SIDEEFFECTS
+#define MLIR_SIDEEFFECTS
+
+include "mlir/IR/OpBase.td"
+
+//===----------------------------------------------------------------------===//
+// 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 effects that are exhibited by this operation and
+        places them in `effects`.
+      }],
+      "void", "getEffects",
+         (ins "SmallVectorImpl<SideEffects::EffectInstance<"
+              # baseEffect # ">> &":$effects)
+    >,
+    InterfaceMethod<[{
+        Collects all of the effects that are exhibited by this operation on the
+        given value and place them in 'effects'.
+      }],
+      "void", "getEffectsOnValue",
+         (ins "Value":$value,
+              "SmallVectorImpl<SideEffects::EffectInstance<"
+              # baseEffect # ">> &":$effects), [{
+          op.getEffects(effects);
+          llvm::erase_if(effects, [&](auto &it) {
+            return it.getValue() != value;
+          });
+       }]
+    >,
+    InterfaceMethod<[{
+        Collects all of the effects that are exhibited by this operation on the
+        given resource and place them in 'effects'.
+      }],
+      "void", "getEffectsOnResource",
+         (ins "SideEffects::Resource *":$resource,
+              "SmallVectorImpl<SideEffects::EffectInstance<"
+              # baseEffect # ">> &":$effects), [{
+          op.getEffects(effects);
+          llvm::erase_if(effects, [&](auto &it) {
+            return it.getResource() != resource;
+          });
+       }]
+    >
+  ];
+
+  let extraClassDeclaration = [{
+    /// Collect all of the effect instances that correspond to the given effect
+    /// ID and place them in 'effects'.
+    template <typename Effect> void getEffects(
+      SmallVectorImpl<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 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 if this operation has no effects.
+    bool hasNoEffect() {
+      SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
+      getEffects(effects);
+      return effects.empty();
+    }
+  }];
+
+  // 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,
+                 string resourceName> {
+  /// The parent interface that the effect belongs to.
+  string interfaceTrait = interface.trait;
+
+  /// The name of the base effects class.
+  string baseEffect = interface.baseEffectName;
+
+  /// The derived effect that is being applied.
+  string effect = effectName;
+
+  /// The resource that the effect is being applied to.
+  string resource = resourceName;
+}
+
+// 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 derived effects being applied.
+  list<SideEffect> effects = staticEffects;
+}
+
+//===----------------------------------------------------------------------===//
+// MemoryEffects
+//===----------------------------------------------------------------------===//
+
+// This class represents the definition for the memory effects interface. Users
+// should generally not use this directly, and should instead use
+// `MemoryEffects`.
+def MemoryEffectsOpInterface
+    : EffectOpInterfaceBase<"MemoryEffectOpInterface",
+                            "MemoryEffects::Effect"> {
+  let description = [{
+    An interface used to query information about the memory effects applied by
+    an operation.
+  }];
+}
+
+// The base class for defining specific memory effects.
+class MemoryEffect<string effectName, string resourceName>
+  : SideEffect<MemoryEffectsOpInterface, effectName, resourceName>;
+
+// 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. This effect may only be placed on
+// a result or region argument.
+class MemAlloc<string resourceName>
+  : MemoryEffect<"MemoryEffects::Allocate", resourceName>;
+def MemAlloc : MemAlloc<"">;
+
+// 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<string resourceName>
+  : MemoryEffect<"MemoryEffects::Free", resourceName>;
+def MemFree : MemFree<"">;
+
+// 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<string resourceName>
+  : MemoryEffect<"MemoryEffects::Read", resourceName>;
+def MemRead : MemRead<"">;
+
+// 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<string resourceName>
+  : MemoryEffect<"MemoryEffects::Write", resourceName>;
+def MemWrite : MemWrite<"">;
+
+#endif // MLIR_SIDEEFFECTS

mlir/lib/IR/CMakeLists.txt

 file(GLOB globbed *.c *.cpp)
 add_llvm_library(MLIRIR
   ${globbed}
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
   )
-add_dependencies(MLIRIR MLIRCallOpInterfacesIncGen MLIROpAsmInterfacesIncGen MLIRSupport LLVMSupport)
+add_dependencies(MLIRIR
+  MLIRCallOpInterfacesIncGen
+  MLIROpAsmInterfacesIncGen
+  MLIRSideEffectOpInterfacesIncGen
+  MLIRSupport
+  LLVMSupport
+  )
 target_link_libraries(MLIRIR MLIRSupport LLVMSupport)

mlir/lib/IR/Operation.cpp

 }
 
 LogicalResult OpTrait::impl::verifyResultSizeAttr(Operation *op,
                                                   StringRef attrName) {
   return verifyValueSizeAttr(op, attrName, /*isOperand=*/false);
 }
 
 //===----------------------------------------------------------------------===//
+// SideEffect Interfaces
+
+/// Include the definitions of the side effect interfaces.
+#include "mlir/IR/SideEffectInterfaces.cpp.inc"
+
+bool MemoryEffects::Effect::classof(const SideEffects::Effect *effect) {
+  return isa<Allocate>(effect) || isa<Free>(effect) || isa<Read>(effect) ||
+         isa<Write>(effect);
+}
+
+//===----------------------------------------------------------------------===//
 // BinaryOp implementation
 //===----------------------------------------------------------------------===//
 
 // These functions are out-of-line implementations of the methods in BinaryOp,
 // which avoids them being template instantiated/duplicated.
 
 void impl::buildBinaryOp(Builder *builder, OperationState &result, Value lhs,
                          Value rhs) {

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

+// RUN: mlir-opt %s -test-side-effects -verify-diagnostics
+
+// expected-remark@+1 {{operation has no memory effects}}
+%0 = "test.side_effect_op"() {} : () -> i32
+
+// expected-remark@+2 {{found an instance of 'read' on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'free' on resource '<Default>'}}
+%1 = "test.side_effect_op"() {effects = [
+  {effect="read"}, {effect="free"}
+]} : () -> i32
+
+// expected-remark@+1 {{found an instance of 'write' on resource '<Test>'}}
+%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

mlir/test/lib/IR/CMakeLists.txt

 add_llvm_library(MLIRTestIR
   TestFunc.cpp
   TestMatchers.cpp
+  TestSideEffects.cpp
   TestSymbolUses.cpp
 
   ADDITIONAL_HEADER_DIRS
   )
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../TestDialect)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/../TestDialect)
 add_dependencies(MLIRTestIR
   MLIRTestDialect
   )
 target_link_libraries(MLIRTestIR
   MLIRPass
   )

mlir/test/lib/IR/TestSideEffects.cpp

+//===- TestSidEffects.cpp - Pass to test side effects ---------------------===//
+//
+// 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 "TestDialect.h"
+#include "mlir/Pass/Pass.h"
+
+using namespace mlir;
+
+namespace {
+struct SideEffectsPass : public ModulePass<SideEffectsPass> {
+  void runOnModule() override {
+    auto module = getModule();
+
+    // Walk operations detecting side effects.
+    SmallVector<MemoryEffects::EffectInstance, 8> effects;
+    module.walk([&](MemoryEffectOpInterface op) {
+      effects.clear();
+      op.getEffects(effects);
+
+      // Check to see if this operation has any memory effects.
+      if (effects.empty()) {
+        op.emitRemark() << "operation has no memory effects";
+        return;
+      }
+
+      for (MemoryEffects::EffectInstance instance : effects) {
+        auto diag = op.emitRemark() << "found an instance of ";
+
+        if (isa<MemoryEffects::Allocate>(instance.getEffect()))
+          diag << "'allocate'";
+        else if (isa<MemoryEffects::Free>(instance.getEffect()))
+          diag << "'free'";
+        else if (isa<MemoryEffects::Read>(instance.getEffect()))
+          diag << "'read'";
+        else if (isa<MemoryEffects::Write>(instance.getEffect()))
+          diag << "'write'";
+
+        if (instance.getValue())
+          diag << " on a value,";
+
+        diag << " on resource '" << instance.getResource()->getName() << "'";
+      }
+    });
+  }
+};
+} // end anonymous namespace
+
+static PassRegistration<SideEffectsPass> pass("test-side-effects",
+                                              "Test side effects interfaces");

mlir/test/lib/TestDialect/TestDialect.cpp

for (auto operandType : operands.getTypes()) {
     }
   }
   inferedComponents.reserve(1);
   auto type = IntegerType::get(17, context);
   inferedComponents.emplace_back(shape, type);
   return success();
 }
 
+//===----------------------------------------------------------------------===//
+// Test SideEffect interfaces
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// A test resource for side effects.
+struct TestResource : public SideEffects::Resource::Base<TestResource> {
+  StringRef getName() final { return "<Test>"; }
+};
+} // end anonymous namespace
+
+void SideEffectOp::getEffects(
+    SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
+  // Check for an effects attribute on the op instance.
+  ArrayAttr effectsAttr = getAttrOfType<ArrayAttr>("effects");
+  if (!effectsAttr)
+    return;
+
+  // If there is one, it is an array of dictionary attributes that hold
+  // information on the effects of this operation.
+  for (Attribute element : effectsAttr) {
+    DictionaryAttr effectElement = element.cast<DictionaryAttr>();
+
+    // Get the specific memory effect.
+    MemoryEffects::Effect *effect =
+        llvm::StringSwitch<MemoryEffects::Effect *>(
+            effectElement.get("effect").cast<StringAttr>().getValue())
+            .Case("allocate", MemoryEffects::Allocate::get())
+            .Case("free", MemoryEffects::Free::get())
+            .Case("read", MemoryEffects::Read::get())
+            .Case("write", MemoryEffects::Write::get());
+
+    // Check for a result to affect.
+    Value value;
+    if (effectElement.get("on_result"))
+      value = getResult();
+
+    // Check for a non-default resource to use.
+    SideEffects::Resource *resource = SideEffects::DefaultResource::get();
+    if (effectElement.get("test_resource"))
+      resource = TestResource::get();
+
+    effects.emplace_back(effect, value, resource);
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// Dialect Registration
+//===----------------------------------------------------------------------===//
+
 // Static initialization for Test dialect registration.
 static mlir::DialectRegistration<mlir::TestDialect> testDialect;
 
 #include "TestOpEnums.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.cpp.inc"

mlir/test/lib/TestDialect/TestOps.td

 //===-- TestOps.td - Test dialect operation definitions ----*- 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_OPS
 #define TEST_OPS
 
-include "mlir/IR/OpBase.td"
 include "mlir/IR/OpAsmInterface.td"
+include "mlir/IR/SideEffects.td"
 include "mlir/Analysis/CallInterfaces.td"
 include "mlir/Analysis/InferTypeOpInterface.td"
 
 def TEST_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "";
 }
 

 }]>;
 def FormatOperandDOp : FormatOperandBase<"format_operand_d_op", [{
   $buildable `,` $operand `:` type($operand) attr-dict
 }]>;
 def FormatOperandEOp : FormatOperandBase<"format_operand_e_op", [{
   $buildable `,` $operand `:` type($buildable) `,` type($operand) attr-dict
 }]>;
 
+//===----------------------------------------------------------------------===//
+// Test SideEffects
+//===----------------------------------------------------------------------===//
+
+def SideEffectOp : TEST_Op<"side_effect_op",
+    [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
+  let results = (outs AnyType:$result);
+}
+
 #endif // TEST_OPS