RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 19:12:56 +02:00
Code Issues Projects Releases Wiki Activity

Part one of switching to using a more sane heuristic for determining if-conversion profitability.

Browse Source 
Rather than having arbitrary cutoffs, actually try to cost model the conversion.

For now, the constants are tuned to more or less match our existing behavior, but these will be
changed to reflect realistic values as this work proceeds.

llvm-svn: 114973
This commit is contained in:
Owen Anderson 2010-09-28 18:32:13 +00:00
parent 69d1069a4b
commit c0e1200323
7 changed files with 46 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/llvm/Target/TargetInstrInfo.h
View File

@ -304,27 +304,33 @@ public:
}
/// isProfitableToIfCvt - Return true if it's profitable to first "NumInstrs"
/// of the specified basic block.
/// of the specified basic block, where the probability of the instructions
/// being executed is given by Probability.
virtual
bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumInstrs) const {
bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumInstrs,
float Probability) const {
return false;
}
/// isProfitableToIfCvt - Second variant of isProfitableToIfCvt, this one
/// checks for the case where two basic blocks from true and false path
/// of a if-then-else (diamond) are predicated on mutally exclusive
/// predicates.
/// predicates, where the probability of the true path being taken is given
/// by Probability.
virtual bool
isProfitableToIfCvt(MachineBasicBlock &TMBB, unsigned NumTInstrs,
MachineBasicBlock &FMBB, unsigned NumFInstrs) const {
MachineBasicBlock &FMBB, unsigned NumFInstrs,
float Probability) const {
return false;
}
/// isProfitableToDupForIfCvt - Return true if it's profitable for
/// if-converter to duplicate a specific number of instructions in the
/// specified MBB to enable if-conversion.
/// specified MBB to enable if-conversion, where the probability of the
/// instructions being executed is given by Probability.
virtual bool
isProfitableToDupForIfCvt(MachineBasicBlock &MBB,unsigned NumInstrs) const {
isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumInstrs,
float Probability) const {
return false;
}

8
lib/CodeGen/IfConversion.cpp
View File

@ -191,13 +191,13 @@ namespace {
void MergeBlocks(BBInfo &ToBBI, BBInfo &FromBBI, bool AddEdges = true);
bool MeetIfcvtSizeLimit(MachineBasicBlock &BB, unsigned Size) const {
return Size > 0 && TII->isProfitableToIfCvt(BB, Size);
return Size > 0 && TII->isProfitableToIfCvt(BB, Size, 0.5);
}
bool MeetIfcvtSizeLimit(MachineBasicBlock &TBB, unsigned TSize,
MachineBasicBlock &FBB, unsigned FSize) const {
return TSize > 0 && FSize > 0 &&
TII->isProfitableToIfCvt(TBB, TSize, FBB, FSize);
TII->isProfitableToIfCvt(TBB, TSize, FBB, FSize, 0.5);
}
// blockAlwaysFallThrough - Block ends without a terminator.
@ -444,7 +444,7 @@ bool IfConverter::ValidSimple(BBInfo &TrueBBI, unsigned &Dups) const {
if (TrueBBI.BB->pred_size() > 1) {
if (TrueBBI.CannotBeCopied ||
!TII->isProfitableToDupForIfCvt(*TrueBBI.BB, TrueBBI.NonPredSize))
!TII->isProfitableToDupForIfCvt(*TrueBBI.BB, TrueBBI.NonPredSize, 0.5))
return false;
Dups = TrueBBI.NonPredSize;
}
@ -481,7 +481,7 @@ bool IfConverter::ValidTriangle(BBInfo &TrueBBI, BBInfo &FalseBBI,
++Size;
}
}
if (!TII->isProfitableToDupForIfCvt(*TrueBBI.BB, Size))
if (!TII->isProfitableToDupForIfCvt(*TrueBBI.BB, Size, 0.5))
return false;
Dups = Size;
}

34
lib/Target/ARM/ARMBaseInstrInfo.cpp
View File

@ -1195,22 +1195,36 @@ bool ARMBaseInstrInfo::isSchedulingBoundary(const MachineInstr *MI,
return false;
}
bool ARMBaseInstrInfo::
isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumInstrs) const {
bool ARMBaseInstrInfo::isProfitableToIfCvt(MachineBasicBlock &MBB,
unsigned NumInstrs,
float Probability) const {
if (!NumInstrs)
return false;
if (Subtarget.getCPUString() == "generic")
// Generic (and overly aggressive) if-conversion limits for testing.
return NumInstrs <= 10;
else if (Subtarget.hasV7Ops())
return NumInstrs <= 3;
return NumInstrs <= 2;
// Attempt to estimate the relative costs of predication versus branching.
float UnpredCost = Probability * NumInstrs;
UnpredCost += 2.0; // FIXME: Should model a misprediction cost.
float PredCost = NumInstrs;
return PredCost < UnpredCost;
}
bool ARMBaseInstrInfo::
isProfitableToIfCvt(MachineBasicBlock &TMBB, unsigned NumT,
MachineBasicBlock &FMBB, unsigned NumF) const {
return NumT && NumF && NumT <= 2 && NumF <= 2;
MachineBasicBlock &FMBB, unsigned NumF,
float Probability) const {
if (!NumT || !NumF)
return false;
// Attempt to estimate the relative costs of predication versus branching.
float UnpredCost = Probability * NumT + (1.0 - Probability) * NumF;
UnpredCost += 2.0; // FIXME: Should model a misprediction cost.
float PredCost = NumT + NumF;
return PredCost < UnpredCost;
}
/// getInstrPredicate - If instruction is predicated, returns its predicate

8
lib/Target/ARM/ARMBaseInstrInfo.h
View File

@ -312,13 +312,15 @@ public:
const MachineFunction &MF) const;
virtual bool isProfitableToIfCvt(MachineBasicBlock &MBB,
unsigned NumInstrs) const;
unsigned NumInstrs, float Prob) const;
virtual bool isProfitableToIfCvt(MachineBasicBlock &TMBB,unsigned NumT,
MachineBasicBlock &FMBB,unsigned NumF) const;
MachineBasicBlock &FMBB,unsigned NumF,
float Probability) const;
virtual bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB,
unsigned NumInstrs) const {
unsigned NumInstrs,
float Probability) const {
return NumInstrs && NumInstrs == 1;
}

25
lib/Target/ARM/Thumb2InstrInfo.cpp
View File

@ -28,16 +28,6 @@
using namespace llvm;
static cl::opt<unsigned>
IfCvtLimit("thumb2-ifcvt-limit", cl::Hidden,
cl::desc("Thumb2 if-conversion limit (default 3)"),
cl::init(3));
static cl::opt<unsigned>
IfCvtDiamondLimit("thumb2-ifcvt-diamond-limit", cl::Hidden,
cl::desc("Thumb2 diamond if-conversion limit (default 3)"),
cl::init(3));
Thumb2InstrInfo::Thumb2InstrInfo(const ARMSubtarget &STI)
: ARMBaseInstrInfo(STI), RI(*this, STI) {
}
@ -105,21 +95,6 @@ Thumb2InstrInfo::isLegalToSplitMBBAt(MachineBasicBlock &MBB,
return llvm::getITInstrPredicate(MBBI, PredReg) == ARMCC::AL;
}
bool Thumb2InstrInfo::isProfitableToIfCvt(MachineBasicBlock &MBB,
unsigned NumInstrs) const {
return NumInstrs && NumInstrs <= IfCvtLimit;
}
bool Thumb2InstrInfo::
isProfitableToIfCvt(MachineBasicBlock &TMBB, unsigned NumT,
MachineBasicBlock &FMBB, unsigned NumF) const {
// FIXME: Catch optimization such as:
// r0 = movne
// r0 = moveq
return NumT && NumF &&
NumT <= (IfCvtDiamondLimit) && NumF <= (IfCvtDiamondLimit);
}
void Thumb2InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
MachineBasicBlock::iterator I, DebugLoc DL,
unsigned DestReg, unsigned SrcReg,

5
lib/Target/ARM/Thumb2InstrInfo.h
View File

@ -38,11 +38,6 @@ public:
bool isLegalToSplitMBBAt(MachineBasicBlock &MBB,
MachineBasicBlock::iterator MBBI) const;
bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumInstrs) const;
bool isProfitableToIfCvt(MachineBasicBlock &TMBB, unsigned NumTInstrs,
MachineBasicBlock &FMBB, unsigned NumFInstrs) const;
void copyPhysReg(MachineBasicBlock &MBB,
MachineBasicBlock::iterator I, DebugLoc DL,
unsigned DestReg, unsigned SrcReg,

3
test/CodeGen/ARM/lsr-on-unrolled-loops.ll
View File

@ -627,8 +627,7 @@ bb24: ; preds = %bb23
; in a register, and it shouldn't require any reloads here.
; CHECK: @ %bb24
; CHECK-NEXT: @ in Loop: Header=BB1_1 Depth=1
; CHECK-NEXT: sub{{.*}} [[REGISTER:(r[0-9]+)|(lr)]], #1
; CHECK: subs{{.*}} [[REGISTER:(r[0-9]+)|(lr)]], #1
; CHECK-NEXT: bne.w
%92 = icmp eq i32 %tmp81, %indvar78 ; <i1> [#uses=1]