working version without isZeroTrip

Author: mbagherbeikTT

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

@@ -16,7 +16,6 @@
 
 #include "mlir/IR/Dominance.h"
 #include "mlir/IR/OpDefinition.h"
-#include "mlir/Interfaces/LoopLikeInterface.h"
 
 namespace mlir {
 namespace SideEffects {
@@ -349,7 +348,7 @@ struct AlwaysSpeculatableImplTrait
 
 namespace MemoryEffects {
 enum Priority {
-  kDefault = 0,
+  kDefaultPriority = 0,
   kAllocPriority = 1,
   kFreePriority = 2,
   kReadPriority = 3,
@@ -371,7 +370,7 @@ struct Effect : public SideEffects::Effect {
 
 protected:
   /// Priority value for this effect. Lower numbers indicate higher precedence.
-  Priority priority = kDefault;
+  Priority priority = Priority::kDefaultPriority;
 };
 using EffectInstance = SideEffects::EffectInstance<Effect>;
 
@@ -384,28 +383,28 @@ getMemoryEffectsSorted(Operation *op);
 /// resource. An 'allocate' effect implies only allocation of the resource, and
 /// not any visible mutation or dereference.
 struct Allocate : public Effect::Base<Allocate> {
-  Allocate() : Effect::Base<Allocate>() { this->priority = kAllocPriority; }
+  Allocate() : Effect::Base<Allocate>() { this->priority = Priority::kAllocPriority; }
 };
 
 /// 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> {
-  Free() : Effect::Base<Free>() { this->priority = kFreePriority; }
+  Free() : Effect::Base<Free>() { this->priority = Priority::kFreePriority; }
 };
 
 /// 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> {
-  Read() : Effect::Base<Read>() { this->priority = kReadPriority; }
+  Read() : Effect::Base<Read>() { this->priority = Priority::kReadPriority; }
 };
 
 /// 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> {
-  Write() : Effect::Base<Write>() { this->priority = kWritePriority; }
+  Write() : Effect::Base<Write>() { this->priority = Priority::kWritePriority; }
 };
 } // namespace MemoryEffects
 
@@ -489,15 +488,6 @@ bool isOpTriviallyDead(Operation *op);
 /// Note: Terminators and symbols are never considered to be trivially dead.
 bool wouldOpBeTriviallyDead(Operation *op);
 
-/// Returns TRUE if the loop is dead/zero-trip,
-/// FALSE if loop has constant bounds/steps and has at least 1 iteration
-/// on every dimension, returns nullopt otherwise
-///
-/// Can only infer if loop is dead if it has constant loop bounds/steps.
-/// Otherwise we assume that it's dead to be conservative.
-///
-std::optional<bool> isZeroTrip(mlir::LoopLikeOpInterface &loop);
-
 /// Returns true if the given operation is free of memory effects.
 ///
 /// An operation is free of memory effects if its implementation of

mlir/include/mlir/Transforms/LoopInvariantCodeMotionUtils.h

@@ -13,7 +13,6 @@
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/TypeID.h"
 
-#include "llvm/ADT/SmallVector.h"
 #include <utility>
 
 namespace mlir {

mlir/lib/Interfaces/SideEffectInterfaces.cpp

@@ -8,7 +8,6 @@
 
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-#include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/IR/SymbolTable.h"
 #include <optional>
@@ -320,38 +319,15 @@ bool mlir::wouldOpBeTriviallyDead(Operation *op) {
   return wouldOpBeTriviallyDeadImpl(op);
 }
 
-std::optional<bool> mlir::isZeroTrip(mlir::LoopLikeOpInterface &loop) {
-  auto lbs = loop.getLoopLowerBounds();
-  auto ubs = loop.getLoopUpperBounds();
-  auto steps = loop.getLoopSteps();
-
-  if (!lbs || !ubs || !steps)
-    return std::nullopt;
-
-  if (lbs->size() != ubs->size() || ubs->size() != steps->size())
-    return std::nullopt;
-
-  for (size_t i = 0; i < steps->size(); ++i) {
-    auto lb = getConstantIntValue((*lbs)[i]);
-    auto ub = getConstantIntValue((*ubs)[i]);
-    auto st = getConstantIntValue((*steps)[i]);
-
-    if (!lb || !ub || !st)
-      return std::nullopt; // non-constant -> unknown
-
-    if (*st >= 0 && *lb >= *ub)
-      return true;
-    if (*st < 0 && *lb <= *ub)
-      return true;
-  }
-  return false;
-}
-
 llvm::SmallVector<MemoryEffects::EffectInstance>
 mlir::MemoryEffects::getMemoryEffectsSorted(Operation *op) {
+  llvm::SmallVector<MemoryEffects::EffectInstance> effectsSorted;
+
   auto memInterface = dyn_cast<MemoryEffectOpInterface>(op);
 
-  llvm::SmallVector<MemoryEffects::EffectInstance> effectsSorted;
+  if (!memInterface)
+    return effectsSorted; // return empty vec
+
   memInterface.getEffects(effectsSorted);
 
   auto sortEffects = 

mlir/lib/Transforms/Utils/LoopInvariantCodeMotionUtils.cpp

@@ -15,6 +15,7 @@
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/IR/Value.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Interfaces/SubsetOpInterface.h"
@@ -64,20 +65,18 @@ static void mergeResource(
   const MemoryEffects::EffectInstance &srcEffect,
   bool srcHasConflict) {
 
-  TypeID srcResourceID = srcEffect.getEffect()->getEffectID();
+  TypeID srcResourceID = srcEffect.getResource()->getResourceID();
 
   bool srcIsAllocOrFree = isa<MemoryEffects::Allocate>(srcEffect.getEffect())
     || isa<MemoryEffects::Free>(srcEffect.getEffect());
 
   bool conflict = srcHasConflict || srcIsAllocOrFree;
 
-  DenseMap<mlir::Value, std::pair<int, bool>> myMap;
-
   auto dstIt = dstMap.find(srcResourceID);
 
-  // if it doesnt already exist, create entry for resource in map
+  // if it doesn't already exist, create entry for resource in map
   if (dstIt == dstMap.end()) {
-    dstMap.try_emplace(srcResourceID, std::make_pair(conflict, srcEffect));
+    dstMap.insert(std::make_pair(srcResourceID, std::make_pair(conflict, srcEffect)));
     return;
   }
 
@@ -94,12 +93,12 @@ static void mergeResource(
 
   conflict = conflict || readBeforeWrite;
 
-  dstMap.try_emplace(srcResourceID, std::make_pair(conflict, srcEffect));
+  dstIt->second =std::make_pair(conflict, srcEffect);
 }
 
 static bool hasLoopVariantInput(LoopLikeOpInterface loopLike, Operation *op) {
-  for (const auto &input : op->getOperands())
-    if (loopLike.isDefinedOutsideOfLoop(input))
+  for (OpOperand &input : op->getOpOperands())
+    if (!loopLike.isDefinedOutsideOfLoop(input.get()))
       return true;
 
   return false;
@@ -187,9 +186,9 @@ size_t mlir::moveLoopInvariantCode(
   size_t numMoved = 0;
 
   // check that the loop isn't dead
-  auto isDead = isZeroTrip(loopLike);
-  if (!isDead.has_value() || isDead.value())
-    return numMoved;
+  // auto isDead = loopLike.isZeroTrip();
+  // if (!isDead.has_value() || isDead.value())
+  //   return numMoved;
 
   // go through loop body and map out resource usages
   // op->regions are essentially merged sequentially
@@ -200,8 +199,8 @@ size_t mlir::moveLoopInvariantCode(
   DenseMap<TypeID, std::pair<bool, MemoryEffects::EffectInstance>> resourceConflicts;
   mlir::gatherResourceConflicts(loopLike, loopLike.getOperation(), resourceConflicts);
 
-
-  for (Region *region : loopLike.getLoopRegions()) {
+  auto regions = loopLike.getLoopRegions();
+  for (Region *region : regions) {
     LDBG() << "Original loop:\n" << *region->getParentOp();
 
     std::queue<Operation *> worklist;