Use priority queue for latency scheduling in preRA.

The change is to improve the compile time in preRA.

Author: petechou

visa/LocalScheduler/G4_Sched.cpp

@@ -12,6 +12,7 @@ SPDX-License-Identifier: MIT
 #include <functional>
 #include <fstream>
 #include <iostream>
+#include <queue>
 
 using namespace vISA;
 
@@ -882,7 +883,7 @@ class QueueBase {
     // The data-dependency graph.
     preDDD& ddd;
 
-    // Registre pressure related data.
+    // Register pressure related data.
     RegisterPressure& rp;
 
     // Options to customize scheduler.
@@ -920,6 +921,8 @@ class QueueBase {
         if (TheCurrTupleParts == 0)
             TheCurrTupleLead = nullptr;
     }
+    virtual void push(preNode* N)  = 0;
+    virtual preNode* pop() = 0;
 
 protected:
     // The current (send) tuple lead.
@@ -947,7 +950,7 @@ class SethiUllmanQueue : public QueueBase {
     }
 
     // Add a new ready node.
-    void push(preNode* N)
+    void push(preNode* N) override
     {
         // Clustering nodes have been added.
         if (N->isClustered && !N->isClusterLead)
@@ -962,7 +965,7 @@ class SethiUllmanQueue : public QueueBase {
     }
 
     // Schedule the top node.
-    preNode* pop()
+    preNode* pop() override
     {
         return select();
     }
@@ -1323,37 +1326,44 @@ class LatencyQueue : public QueueBase {
     // group will be scheduled for latency.
     std::map<G4_INST *, unsigned> GroupInfo;
 
-    // Instrction latency information.
+    // Instruction latency information.
     const LatencyTable &LT;
 
+    // TODO: Try to apply priority queue to SethiUllmanQueue as well.
+    std::priority_queue<preNode*, std::vector<preNode*>, std::function<bool(preNode*, preNode*)>> ReadyList;
+
 public:
     LatencyQueue(preDDD& ddd, RegisterPressure& rp, SchedConfig config,
         const LatencyTable& LT)
         : QueueBase(ddd, rp, config)
         , LT(LT)
+        , ReadyList([this](preNode* a, preNode* b){ return compare(a, b);})
     {
         init();
     }
 
     // Add a new ready node.
-    void push(preNode* N)
+    void push(preNode* N) override
     {
         if (N->getInst() && N->getInst()->isPseudoKill())
             pseudoKills.push_back(N);
         else
-            Q.push_back(N);
+            ReadyList.push(N);
     }
 
     // Schedule the top node.
-    preNode* pop()
+    preNode* pop() override
     {
         // Pop all pseudo-kills if any.
         if (!pseudoKills.empty()) {
             preNode* N = pseudoKills.back();
             pseudoKills.pop_back();
             return N;
         }
-        return select();
+        assert(!ReadyList.empty());
+        preNode* N = ReadyList.top();
+        ReadyList.pop();
+        return N;
     }
 
     bool empty() const
@@ -1365,8 +1375,6 @@ class LatencyQueue : public QueueBase {
     void init();
     unsigned calculatePriority(preNode *N);
 
-    preNode* select();
-
     // Compare two ready nodes and decide which one should be scheduled first.
     // Return true if N2 has a higher priority than N1, false otherwise.
     bool compare(preNode* N1, preNode* N2);
@@ -1636,22 +1644,6 @@ unsigned LatencyQueue::calculatePriority(preNode* N)
     return std::max(1U, Priority);
 }
 
-preNode* LatencyQueue::select()
-{
-    assert(!Q.empty());
-    auto TopIter = Q.end();
-    for (auto I = Q.begin(), E = Q.end(); I != E; ++I) {
-        preNode* N = *I;
-        if (TopIter == Q.end() || compare(*TopIter, N))
-            TopIter = I;
-    }
-    assert(TopIter != Q.end());
-    preNode* Top = *TopIter;
-    std::swap(*TopIter, Q.back());
-    Q.pop_back();
-    return Top;
-}
-
 // Compare two ready nodes and decide which one should be scheduled first.
 // Return true if N2 has a higher priority than N1, false otherwise.
 bool LatencyQueue::compare(preNode* N1, preNode* N2)