RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-01-26 22:45:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Estimate a cost using the possible number of scratch registers required and use

Browse Source 
it as a late BURR scheduling tie-breaker.
Intuitively, it's good to push down instructions whose results are liveout so
their long live ranges won't conflict with other values which are needed inside
the BB. Further prioritize liveout instructions by the number of operands which
are calculated within the BB.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35109 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng 2007-03-14 22:43:40 +00:00
parent ba693005e9
commit c6deb3d447
1 changed files with 47 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp
View File

@ -576,15 +576,43 @@ namespace {
};
}
/// closestSucc - Returns the scheduled cycle of the successor which is
/// closet to the current cycle.
static unsigned closestSucc(const SUnit *SU) {
unsigned MaxCycle = 0;
for (SUnit::const_succ_iterator I = SU->Succs.begin(), E = SU->Succs.end();
I != E; ++I)
if (I->first->Cycle > MaxCycle)
MaxCycle = I->first->Cycle;
I != E; ++I) {
unsigned Cycle = I->first->Cycle;
// If there are bunch of CopyToRegs stacked up, they should be considered
// to be at the same position.
if (I->first->Node->getOpcode() == ISD::CopyToReg)
Cycle = closestSucc(I->first)+1;
if (Cycle > MaxCycle)
MaxCycle = Cycle;
}
return MaxCycle;
}
/// calcMaxScratches - Returns an cost estimate of the worse case requirement
/// for scratch registers. Live-in operands and live-out results don't count
/// since they are "fixed".
static unsigned calcMaxScratches(const SUnit *SU) {
unsigned Scratches = 0;
for (SUnit::const_pred_iterator I = SU->Preds.begin(), E = SU->Preds.end();
I != E; ++I) {
if (I->second) continue; // ignore chain preds
if (I->first->Node->getOpcode() != ISD::CopyFromReg)
Scratches++;
}
for (SUnit::const_succ_iterator I = SU->Succs.begin(), E = SU->Succs.end();
I != E; ++I) {
if (I->second) continue; // ignore chain succs
if (I->first->Node->getOpcode() != ISD::CopyToReg)
Scratches += 10;
}
return Scratches;
}
// Bottom up
bool bu_ls_rr_sort::operator()(const SUnit *left, const SUnit *right) const {
bool LIsTarget = left->Node->isTargetOpcode();
@ -627,15 +655,25 @@ bool bu_ls_rr_sort::operator()(const SUnit *left, const SUnit *right) const {
unsigned RDist = closestSucc(right);
if (LDist < RDist)
return true;
else if (LDist == RDist)
if (left->Height > right->Height)
else if (LDist == RDist) {
// Intuitively, it's good to push down instructions whose results are
// liveout so their long live ranges won't conflict with other values
// which are needed inside the BB. Further prioritize liveout instructions
// by the number of operands which are calculated within the BB.
unsigned LScratch = calcMaxScratches(left);
unsigned RScratch = calcMaxScratches(right);
if (LScratch > RScratch)
return true;
else if (left->Height == right->Height)
if (left->Depth < right->Depth)
else if (LScratch == RScratch)
if (left->Height > right->Height)
return true;
else if (left->Depth == right->Depth)
if (left->CycleBound > right->CycleBound)
else if (left->Height == right->Height)
if (left->Depth < right->Depth)
return true;
else if (left->Depth == right->Depth)
if (left->CycleBound > right->CycleBound)
return true;
}
}
return false;
}