[llvm] r304609 - Revert "[SLP] Improve comments and naming of functions/variables/members, NFC."

Alexey Bataev via llvm-commits llvm-commits at lists.llvm.org
Mon Jun 5 07:08:01 PDT 2017


Hi Adam,
Ok, I just had no time. I need to pacify the LTO buildbots that's why I had to revert the patch and replace WeakVH by the WeakTrackingVH.
Thanks for the hint with git-svnrevert

6/5/17 12:41 AM, Adam Nemet пишет:




On Jun 2, 2017, at 4:09 PM, Alexey Bataev via llvm-commits <llvm-commits at lists.llvm.org><mailto:llvm-commits at lists.llvm.org> wrote:

Author: abataev
Date: Fri Jun  2 18:09:15 2017
New Revision: 304609

URL: http://llvm.org/viewvc/llvm-project?rev=304609&view=rev
Log:
Revert "[SLP] Improve comments and naming of functions/variables/members, NFC."

This reverts commit 6e311de8b907aa20da9a1a13ab07c3ce2ef4068a.



Please always include why you revert.  Also if you use git-svn, use utils/git-svn/git-svnrevert to revert so that the subversion revision is included.

Adam




Modified:
   llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp

Modified: llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp?rev=304609&r1=304608&r2=304609&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp (original)
+++ llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp Fri Jun  2 18:09:15 2017
@@ -4749,18 +4749,56 @@ static Value *getReductionValue(const Do
  return nullptr;
}

-/// Attempt to reduce a horizontal reduction.
-/// If it is legal to match a horizontal reduction feeding the phi node \a P
-/// with reduction operators \a Root (or one of its operands) in a basic block
-/// \a BB, then check if it can be done. If horizontal reduction is not found
-/// and root instruction is a binary operation, vectorization of the operands is
-/// attempted.
-/// \returns true if a horizontal reduction was matched and reduced or operands
-/// of one of the binary instruction were vectorized.
-/// \returns false if a horizontal reduction was not matched (or not possible)
-/// or no vectorization of any binary operation feeding \a Root instruction was
-/// performed.
-static bool tryToVectorizeHorReductionOrInstOperands(
+namespace {
+/// Tracks instructons and its children.
+class WeakTrackingVHWithLevel final : public CallbackVH {
+  /// Operand index of the instruction currently beeing analized.
+  unsigned Level = 0;
+  /// Is this the instruction that should be vectorized, or are we now
+  /// processing children (i.e. operands of this instruction) for potential
+  /// vectorization?
+  bool IsInitial = true;
+
+public:
+  explicit WeakTrackingVHWithLevel() = default;
+  WeakTrackingVHWithLevel(Value *V) : CallbackVH(V){};
+  /// Restart children analysis each time it is repaced by the new instruction.
+  void allUsesReplacedWith(Value *New) override {
+    setValPtr(New);
+    Level = 0;
+    IsInitial = true;
+  }
+  /// Check if the instruction was not deleted during vectorization.
+  bool isValid() const { return !getValPtr(); }
+  /// Is the istruction itself must be vectorized?
+  bool isInitial() const { return IsInitial; }
+  /// Try to vectorize children.
+  void clearInitial() { IsInitial = false; }
+  /// Are all children processed already?
+  bool isFinal() const {
+    assert(getValPtr() &&
+           (isa<Instruction>(getValPtr()) &&
+            cast<Instruction>(getValPtr())->getNumOperands() >= Level));
+    return getValPtr() &&
+           cast<Instruction>(getValPtr())->getNumOperands() == Level;
+  }
+  /// Get next child operation.
+  Value *nextOperand() {
+    assert(getValPtr() && isa<Instruction>(getValPtr()) &&
+           cast<Instruction>(getValPtr())->getNumOperands() > Level);
+    return cast<Instruction>(getValPtr())->getOperand(Level++);
+  }
+  virtual ~WeakTrackingVHWithLevel() = default;
+};
+} // namespace
+
+/// \brief Attempt to reduce a horizontal reduction.
+/// If it is legal to match a horizontal reduction feeding
+/// the phi node P with reduction operators Root in a basic block BB, then check
+/// if it can be done.
+/// \returns true if a horizontal reduction was matched and reduced.
+/// \returns false if a horizontal reduction was not matched.
+static bool canBeVectorized(
    PHINode *P, Instruction *Root, BasicBlock *BB, BoUpSLP &R,
    TargetTransformInfo *TTI,
    const function_ref<bool(BinaryOperator *, BoUpSLP &)> Vectorize) {
@@ -4772,62 +4810,56 @@ static bool tryToVectorizeHorReductionOr

  if (Root->getParent() != BB)
    return false;
-  // Start analysis starting from Root instruction. If horizontal reduction is
-  // found, try to vectorize it. If it is not a horizontal reduction or
-  // vectorization is not possible or not effective, and currently analyzed
-  // instruction is a binary operation, try to vectorize the operands, using
-  // pre-order DFS traversal order. If the operands were not vectorized, repeat
-  // the same procedure considering each operand as a possible root of the
-  // horizontal reduction.
-  // Interrupt the process if the Root instruction itself was vectorized or all
-  // sub-trees not higher that RecursionMaxDepth were analyzed/vectorized.
-  SmallVector<std::pair<WeakVH, unsigned>, 8> Stack(1, {Root, 0});
+  SmallVector<WeakTrackingVHWithLevel, 8> Stack(1, Root);
  SmallSet<Value *, 8> VisitedInstrs;
  bool Res = false;
  while (!Stack.empty()) {
-    Value *V;
-    unsigned Level;
-    std::tie(V, Level) = Stack.pop_back_val();
-    if (!V)
+    Value *V = Stack.back();
+    if (!V) {
+      Stack.pop_back();
      continue;
+    }
    auto *Inst = dyn_cast<Instruction>(V);
-    if (!Inst || isa<PHINode>(Inst))
+    if (!Inst || isa<PHINode>(Inst)) {
+      Stack.pop_back();
      continue;
-    if (auto *BI = dyn_cast<BinaryOperator>(Inst)) {
-      HorizontalReduction HorRdx;
-      if (HorRdx.matchAssociativeReduction(P, BI)) {
-        if (HorRdx.tryToReduce(R, TTI)) {
-          Res = true;
-          // Set P to nullptr to avoid re-analysis of phi node in
-          // matchAssociativeReduction function unless this is the root node.
-          P = nullptr;
-          continue;
+    }
+    if (Stack.back().isInitial()) {
+      Stack.back().clearInitial();
+      if (auto *BI = dyn_cast<BinaryOperator>(Inst)) {
+        HorizontalReduction HorRdx;
+        if (HorRdx.matchAssociativeReduction(P, BI)) {
+          if (HorRdx.tryToReduce(R, TTI)) {
+            Res = true;
+            P = nullptr;
+            continue;
+          }
        }
-      }
-      if (P) {
-        Inst = dyn_cast<Instruction>(BI->getOperand(0));
-        if (Inst == P)
-          Inst = dyn_cast<Instruction>(BI->getOperand(1));
-        if (!Inst) {
-          // Set P to nullptr to avoid re-analysis of phi node in
-          // matchAssociativeReduction function unless this is the root node.
-          P = nullptr;
-          continue;
+        if (P) {
+          Inst = dyn_cast<Instruction>(BI->getOperand(0));
+          if (Inst == P)
+            Inst = dyn_cast<Instruction>(BI->getOperand(1));
+          if (!Inst) {
+            P = nullptr;
+            continue;
+          }
        }
      }
+      P = nullptr;
+      if (Vectorize(dyn_cast<BinaryOperator>(Inst), R)) {
+        Res = true;
+        continue;
+      }
    }
-    // Set P to nullptr to avoid re-analysis of phi node in
-    // matchAssociativeReduction function unless this is the root node.
-    P = nullptr;
-    if (Vectorize(dyn_cast<BinaryOperator>(Inst), R)) {
-      Res = true;
+    if (Stack.back().isFinal()) {
+      Stack.pop_back();
      continue;
    }

-    // Try to vectorize operands.
-    if (++Level < RecursionMaxDepth)
-      for (auto *Op : Inst->operand_values())
-        Stack.emplace_back(Op, Level);
+    if (auto *NextV = dyn_cast<Instruction>(Stack.back().nextOperand()))
+      if (NextV->getParent() == BB && VisitedInstrs.insert(NextV).second &&
+          Stack.size() < RecursionMaxDepth)
+        Stack.push_back(NextV);
  }
  return Res;
}
@@ -4844,10 +4876,10 @@ bool SLPVectorizerPass::vectorizeRootIns
  if (!isa<BinaryOperator>(I))
    P = nullptr;
  // Try to match and vectorize a horizontal reduction.
-  return tryToVectorizeHorReductionOrInstOperands(
-      P, I, BB, R, TTI, [this](BinaryOperator *BI, BoUpSLP &R) -> bool {
-        return tryToVectorize(BI, R);
-      });
+  return canBeVectorized(P, I, BB, R, TTI,
+                         [this](BinaryOperator *BI, BoUpSLP &R) -> bool {
+                           return tryToVectorize(BI, R);
+                         });
}

bool SLPVectorizerPass::vectorizeChainsInBlock(BasicBlock *BB, BoUpSLP &R) {


_______________________________________________
llvm-commits mailing list
llvm-commits at lists.llvm.org<mailto:llvm-commits at lists.llvm.org>
http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits







--
-------------
Best regards,
Alexey Bataev
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20170605/c682fded/attachment.html>


More information about the llvm-commits mailing list