MachineScheduler/ScheduleDAG: Add support for GetSubGraph

[axeldavy]

Summary

GetSubGraph is a new ScheduleDAG function to get the
subgraph of nodes between two SUs.

[axeldavy]

This patch is required for https://reviews.llvm.org/D30152

I don't know who should be reviewer for this code. Anyone ?

[axeldavy]

Rebased on master.

[axeldavy]

ping.

[hfinkel]

Can you please post this patch with full context? See http://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface for instructions.

[atrick]

This seems reasonable to me. Hopefully the linker will strip utilities like this for build targets that don't need them.

[axeldavy]

Added full context

[MatzeB]

include/llvm/CodeGen/ScheduleDAG.h

718

Do not repeat the function name in the doxygen comment.

723–724

Use references instead of pointers for things that cannot be nullptr.

lib/CodeGen/ScheduleDAG.cpp

579

Better use SUnit::isBoundaryNode()

587

Isn't there a mismatch here? I would assume you either test+set visited at the beginning of the loop or you do both when inserting into the worklist.

Testing before insertion but only setting the visited flag when pulling out of the worklist can lead to situations in which elements are pulled out multiple times.

611

Better use SUnit::isBoundaryNode()

[hfinkel]

In D30626#700951, @axeldavy wrote:

Added full context

Small comment about the assert, but otherwise LGTM too.

lib/CodeGen/ScheduleDAG.cpp

624

This assert should have a comment, but instead of tracking Found again, maybe it would be even better to do this:

assert(VisitedBack.size() == Visited.size() && "Did not collect all subgraph nodes?");

[axeldavy]

lib/CodeGen/ScheduleDAG.cpp

579

Thanks, I update the diff with that.

587

Right, it sounds better to set Visited directly there.

It may be possible without it items get added several times to the WorkList, though the second time the items would be pulled, the operation would be noop.

624

Thanks, I add a comment in the assert.

However please note that VisitedBack and Visited likely don't have the same size.
Visited can contain more elements.

[axeldavy]

Updated according to the review comments.

[MatzeB]

LGTM

[axeldavy]

The Visited set was incorrectly set in the previous diff.

[vpykhtin]

include/llvm/CodeGen/ScheduleDAG.h

723

Isn't it enough to return empty vector on failure, without error flag?

[axeldavy]

include/llvm/CodeGen/ScheduleDAG.h

723

Empty vector currently means that TargetSU is a direct successor for StartSU.

If we don't have error flag and say that a failure return empty vector,
we have to check if TargetSU is in StartSU's Succs.

I think it's better having directly an error flag.

include/llvm/CodeGen/ScheduleDAG.h

class ScheduleDAGTopologicalSort {
     void Allocate(int n, int index);
 
   public:
     ScheduleDAGTopologicalSort(std::vector<SUnit> &SUnits, SUnit *ExitSU);
 
     /// Creates the initial topological ordering from the DAG to be scheduled.
     void InitDAGTopologicalSorting();
 
+    /// GetSubGraph - Returns an array of SUs that are both in the successor
+    /// subtree of StartSU and in the predecessor subtree of TargetSU.
+    /// StartSU and TargetSU are not in the array.
+    /// Success is false if TargetSU is not in the successor subtree of
+    /// StartSU, else it is true.
+    std::vector<int> GetSubGraph(const SUnit *StartSU, const SUnit *TargetSU,
+                                 bool &Success);
+
     /// Checks if \p SU is reachable from \p TargetSU.
     bool IsReachable(const SUnit *SU, const SUnit *TargetSU);
 
     /// Returns true if addPred(TargetSU, SU) creates a cycle.
     bool WillCreateCycle(SUnit *TargetSU, SUnit *SU);
 
     /// \brief Updates the topological ordering to accommodate an edge to be
     /// added from SUnit \p X to SUnit \p Y.

lib/CodeGen/ScheduleDAG.cpp

for (const SDep &SuccDep
       // Visit successors if not already and in affected region.
       if (!Visited.test(s) && Node2Index[s] < UpperBound) {
         WorkList.push_back(SuccDep.getSUnit());
       }
     }
   } while (!WorkList.empty());
 }
 
+std::vector<int> ScheduleDAGTopologicalSort::GetSubGraph(const SUnit *StartSU,
+                                                         const SUnit *TargetSU,
+                                                         bool &Success) {
+  std::vector<const SUnit*> WorkList;
+  int LowerBound = Node2Index[StartSU->NodeNum];
+  int UpperBound = Node2Index[TargetSU->NodeNum];
+  bool Found = false;
+  BitVector VisitedBack;
+  std::vector<int> Nodes;
+
+  if (LowerBound > UpperBound) {
+    Success = false;
+    return Nodes;
+  }
+
+  WorkList.reserve(SUnits.size());
+  Visited.reset();
+
+  // Starting from StartSU, visit all successors up
+  // to UpperBound.
+  WorkList.push_back(StartSU);
+  do {
+    const SUnit *SU = WorkList.back();
+    WorkList.pop_back();
+    Visited.set(SU->NodeNum);
+    for (int I = SU->Succs.size()-1; I >= 0; --I) {
+      unsigned s = SU->Succs[I].getSUnit()->NodeNum;
+      // Edges to non-SUnits are allowed but ignored (e.g. ExitSU).
+      if (s >= Node2Index.size())
+        continue;
+      if (Node2Index[s] == UpperBound) {
+        Found = true;
+        continue;
+      }
+      // Visit successors if not already and in affected region.
+      if (!Visited.test(s) && Node2Index[s] < UpperBound)
+        WorkList.push_back(SU->Succs[I].getSUnit());
+    }
+  } while (!WorkList.empty());
+
+  if (!Found) {
+    Success = false;
+    return Nodes;
+  }
+
+  WorkList.clear();
+  VisitedBack.resize(SUnits.size());
+  Found = false;
+
+  // Starting from TargetSU, visit all predecessors up
+  // to LowerBound. SUs that are visited by the two
+  // passes are added to Path.
+  WorkList.push_back(TargetSU);
+  do {
+    const SUnit *SU = WorkList.back();
+    WorkList.pop_back();
+    VisitedBack.set(SU->NodeNum);
+    for (int I = SU->Preds.size()-1; I >= 0; --I) {
+      unsigned s = SU->Preds[I].getSUnit()->NodeNum;
+      // Edges to non-SUnits are allowed but ignored (e.g. EntrySU).
+      if (s >= Node2Index.size())
+        continue;
+      if (Node2Index[s] == LowerBound) {
+        Found = true;
+        continue;
+      }
+      if (!VisitedBack.test(s) && Visited.test(s)) {
+        WorkList.push_back(SU->Preds[I].getSUnit());
+        Nodes.push_back(s);
+      }
+    }
+  } while (!WorkList.empty());
+
+  assert(Found);
+  Success = true;
+  return Nodes;
+}
+
 void ScheduleDAGTopologicalSort::Shift(BitVector& Visited, int LowerBound,
                                        int UpperBound) {
   std::vector<int> L;
   int shift = 0;
   int i;
 
   for (i = LowerBound; i <= UpperBound; ++i) {
     // w is node at topological index i.