[NFC] Move InPQueue into normal argument in releaseNode

[qiucf]

Summary

D72069 has been committed quickly to remove build block. But as discussed in the revision, directly put InPQueue into function arguments of releaseNode is a quite cleaner approach.

[merge_guards_bot]

Unit tests: pass. 61172 tests passed, 0 failed and 729 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[DoktorC]

llvm/include/llvm/CodeGen/MachineScheduler.h

967

Would it be worth to add a /*InPQueue=*/ comment next to the new argument?

[fhahn]

LGTM, but it would be great to document the releaseNode function, including the parameters :)

llvm/include/llvm/CodeGen/MachineScheduler.h

760–769

It would be great if you could add a brief doc comment here, stating what the arguments mean.

967

IIRC the comments are only used for arguments with default values. I don't think it is necessary here.

[lkail]

LGTM.

llvm/include/llvm/CodeGen/MachineScheduler.h

std::pair<unsigned, unsigned> getNextResourceCycle(unsigned PIdx,
                                                      unsigned Cycles);
 
   bool checkHazard(SUnit *SU);
 
   unsigned findMaxLatency(ArrayRef<SUnit*> ReadySUs);
 
   unsigned getOtherResourceCount(unsigned &OtherCritIdx);
 
-  template <bool InPQueue>
-  void releaseNode(SUnit *SU, unsigned ReadyCycle, unsigned Idx = 0);
+  /// Release SU to make it ready. If it's not in hazard, remove it from
+  /// pending queue (if already in) and push into available queue.
+  /// Otherwise, push the SU into pending queue.
+  ///
+  /// @param SU The unit to be released.
+  /// @param ReadyCycle Until which cycle the unit is ready.
+  /// @param InPQueue Whether SU is already in pending queue.
+  /// @param Idx Position offset in pending queue (if in it).
+  void releaseNode(SUnit *SU, unsigned ReadyCycle, bool InPQueue,
+                   unsigned Idx = 0);
 
   void bumpCycle(unsigned NextCycle);
 
   void incExecutedResources(unsigned PIdx, unsigned Count);
 
   unsigned countResource(unsigned PIdx, unsigned Cycles, unsigned ReadyCycle);
 
   void bumpNode(SUnit *SU);
public:
   SUnit *pickNode(bool &IsTopNode) override;
 
   void schedNode(SUnit *SU, bool IsTopNode) override;
 
   void releaseTopNode(SUnit *SU) override {
     if (SU->isScheduled)
       return;
 
-    Top.releaseNode<false>(SU, SU->TopReadyCycle);
+    Top.releaseNode(SU, SU->TopReadyCycle, false);
     TopCand.SU = nullptr;
   }
 
   void releaseBottomNode(SUnit *SU) override {
     if (SU->isScheduled)
       return;
 
-    Bot.releaseNode<false>(SU, SU->BotReadyCycle);
+    Bot.releaseNode(SU, SU->BotReadyCycle, false);
     BotCand.SU = nullptr;
   }
 
   void registerRoots() override;
 
 protected:
   ScheduleDAGMILive *DAG = nullptr;
 
void scheduleTree(unsigned SubtreeID) override {
     llvm_unreachable("PostRA scheduler does not support subtree analysis.");
   }
 
   void schedNode(SUnit *SU, bool IsTopNode) override;
 
   void releaseTopNode(SUnit *SU) override {
     if (SU->isScheduled)
       return;
-    Top.releaseNode<false>(SU, SU->TopReadyCycle);
+    Top.releaseNode(SU, SU->TopReadyCycle, false);
   }
 
   // Only called for roots.
   void releaseBottomNode(SUnit *SU) override {
     BotRoots.push_back(SU);
   }
 
 protected:

llvm/lib/CodeGen/MachineScheduler.cpp

if (OtherCritIdx) {
     LLVM_DEBUG(
         dbgs() << "  " << Available.getName() << " + Remain CritRes: "
                << OtherCritCount / SchedModel->getResourceFactor(OtherCritIdx)
                << " " << SchedModel->getResourceName(OtherCritIdx) << "\n");
   }
   return OtherCritCount;
 }
 
-template void SchedBoundary::releaseNode<true>(SUnit *SU, unsigned ReadyCycle,
-                                               unsigned Idx);
-template void SchedBoundary::releaseNode<false>(SUnit *SU, unsigned ReadyCycle,
-                                                unsigned Idx);
-
-template <bool InPQueue>
-void SchedBoundary::releaseNode(SUnit *SU, unsigned ReadyCycle, unsigned Idx) {
+void SchedBoundary::releaseNode(SUnit *SU, unsigned ReadyCycle, bool InPQueue,
+                                unsigned Idx) {
   assert(SU->getInstr() && "Scheduled SUnit must have instr");
 
 #ifndef NDEBUG
   // ReadyCycle was been bumped up to the CurrCycle when this node was
   // scheduled, but CurrCycle may have been eagerly advanced immediately after
   // scheduling, so may now be greater than ReadyCycle.
   if (ReadyCycle > CurrCycle)
     MaxObservedStall = std::max(ReadyCycle - CurrCycle, MaxObservedStall);
for (unsigned I = 0, E = Pending.size(); I < E; ++I) {
     unsigned ReadyCycle = isTop() ? SU->TopReadyCycle : SU->BotReadyCycle;
 
     if (ReadyCycle < MinReadyCycle)
       MinReadyCycle = ReadyCycle;
 
     if (Available.size() >= ReadyListLimit)
       break;
 
-    releaseNode<true>(SU, ReadyCycle, I);
+    releaseNode(SU, ReadyCycle, true, I);
     if (E != Pending.size()) {
       --I;
       --E;
     }
   }
   CheckPending = false;
 }