[llvm-commits] [llvm] r60817 - in /llvm/trunk: include/llvm/CodeGen/LatencyPriorityQueue.h lib/CodeGen/LatencyPriorityQueue.cpp

[Dan Gohman]

Author: djg
Date: Tue Dec  9 18:24:36 2008
New Revision: 60817

URL: http://llvm.org/viewvc/llvm-project?rev=60817&view=rev
Log:
Update CalcLatency to work in terms of edge latencies, rather than
node latencies. Use CalcLatency instead of manual code in
CalculatePriorities to keep it consistent. Previously it
computed slightly different results.

Modified:
    llvm/trunk/include/llvm/CodeGen/LatencyPriorityQueue.h
    llvm/trunk/lib/CodeGen/LatencyPriorityQueue.cpp

Modified: llvm/trunk/include/llvm/CodeGen/LatencyPriorityQueue.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/LatencyPriorityQueue.h?rev=60817&r1=60816&r2=60817&view=diff

==============================================================================
--- llvm/trunk/include/llvm/CodeGen/LatencyPriorityQueue.h (original)
+++ llvm/trunk/include/llvm/CodeGen/LatencyPriorityQueue.h Tue Dec  9 18:24:36 2008
@@ -115,7 +115,7 @@
 
 private:
     void CalculatePriorities();
-    int CalcLatency(const SUnit &SU);
+    void CalcLatency(const SUnit &SU);
     void AdjustPriorityOfUnscheduledPreds(SUnit *SU);
     SUnit *getSingleUnscheduledPred(SUnit *SU);
   };

Modified: llvm/trunk/lib/CodeGen/LatencyPriorityQueue.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/LatencyPriorityQueue.cpp?rev=60817&r1=60816&r2=60817&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/LatencyPriorityQueue.cpp (original)
+++ llvm/trunk/lib/CodeGen/LatencyPriorityQueue.cpp Tue Dec  9 18:24:36 2008
@@ -43,16 +43,15 @@
 
 /// CalcNodePriority - Calculate the maximal path from the node to the exit.
 ///
-int LatencyPriorityQueue::CalcLatency(const SUnit &SU) {
+void LatencyPriorityQueue::CalcLatency(const SUnit &SU) {
   int &Latency = Latencies[SU.NodeNum];
   if (Latency != -1)
-    return Latency;
+    return;
 
   std::vector<const SUnit*> WorkList;
   WorkList.push_back(&SU);
   while (!WorkList.empty()) {
     const SUnit *Cur = WorkList.back();
-    unsigned CurLatency = Cur->Latency;
     bool AllDone = true;
     unsigned MaxSuccLatency = 0;
     for (SUnit::const_succ_iterator I = Cur->Succs.begin(),E = Cur->Succs.end();
@@ -62,8 +61,7 @@
         AllDone = false;
         WorkList.push_back(I->getSUnit());
       } else {
-        // This assumes that there's no delay for reusing registers.
-        unsigned NewLatency = SuccLatency + CurLatency;
+        unsigned NewLatency = SuccLatency + I->getLatency();
         MaxSuccLatency = std::max(MaxSuccLatency, NewLatency);
       }
     }
@@ -72,8 +70,6 @@
       WorkList.pop_back();
     }
   }
-
-  return Latency;
 }
 
 /// CalculatePriorities - Calculate priorities of all scheduling units.
@@ -82,25 +78,8 @@
   NumNodesSolelyBlocking.assign(SUnits->size(), 0);
 
   // For each node, calculate the maximal path from the node to the exit.
-  std::vector<std::pair<const SUnit*, unsigned> > WorkList;
-  for (unsigned i = 0, e = SUnits->size(); i != e; ++i) {
-    const SUnit *SU = &(*SUnits)[i];
-    if (SU->Succs.empty())
-      WorkList.push_back(std::make_pair(SU, 0U));
-  }
-
-  while (!WorkList.empty()) {
-    const SUnit *SU = WorkList.back().first;
-    unsigned SuccLat = WorkList.back().second;
-    WorkList.pop_back();
-    int &Latency = Latencies[SU->NodeNum];
-    if (Latency == -1 || (SU->Latency + SuccLat) > (unsigned)Latency) {
-      Latency = SU->Latency + SuccLat;
-      for (SUnit::const_pred_iterator I = SU->Preds.begin(),E = SU->Preds.end();
-           I != E; ++I)
-        WorkList.push_back(std::make_pair(I->getSUnit(), Latency));
-    }
-  }
+  for (unsigned i = 0, e = SUnits->size(); i != e; ++i)
+    CalcLatency((*SUnits)[i]);
 }
 
 /// getSingleUnscheduledPred - If there is exactly one unscheduled predecessor