6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-14 11:32:34 +00:00
Code Issues Projects Releases Wiki Activity

BFI: Un-floatify more language

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@211561 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan P. N. Exon Smith 2014-06-24 00:26:13 +00:00
parent 529072a6da
commit 6ecab5a5b1
2 changed files with 33 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/llvm/Analysis/BlockFrequencyInfoImpl.h
View File

@ -584,11 +584,11 @@ public:
bool operator<(const BlockMass &X) const { return Mass < X.Mass; } bool operator<(const BlockMass &X) const { return Mass < X.Mass; }
bool operator>(const BlockMass &X) const { return Mass > X.Mass; } bool operator>(const BlockMass &X) const { return Mass > X.Mass; }
/// \brief Convert to floating point. /// \brief Convert to scaled number.
/// ///
/// Convert to a float. \a isFull() gives 1.0, while \a isEmpty() gives /// Convert to \a ScaledNumber. \a isFull() gives 1.0, while \a isEmpty()
/// slightly above 0.0. /// gives slightly above 0.0.
ScaledNumber<uint64_t> toFloat() const; ScaledNumber<uint64_t> toScaled() const;
void dump() const; void dump() const;
raw_ostream &print(raw_ostream &OS) const; raw_ostream &print(raw_ostream &OS) const;
@ -651,7 +651,7 @@ template <class BT> struct BlockEdgesAdder;
/// BlockFrequencyInfoImpl. See there for details. /// BlockFrequencyInfoImpl. See there for details.
class BlockFrequencyInfoImplBase { class BlockFrequencyInfoImplBase {
public: public:
typedef ScaledNumber<uint64_t> Float; typedef ScaledNumber<uint64_t> Scaled64;
/// \brief Representative of a block. /// \brief Representative of a block.
/// ///
@ -680,7 +680,7 @@ public:
/// \brief Stats about a block itself. /// \brief Stats about a block itself.
struct FrequencyData { struct FrequencyData {
Float Floating; Scaled64 Scaled;
uint64_t Integer; uint64_t Integer;
}; };
@ -698,7 +698,7 @@ public:
NodeList Nodes; ///< Header and the members of the loop. NodeList Nodes; ///< Header and the members of the loop.
BlockMass BackedgeMass; ///< Mass returned to loop header. BlockMass BackedgeMass; ///< Mass returned to loop header.
BlockMass Mass; BlockMass Mass;
Float Scale; Scaled64 Scale;
LoopData(LoopData *Parent, const BlockNode &Header) LoopData(LoopData *Parent, const BlockNode &Header)
: Parent(Parent), IsPackaged(false), NumHeaders(1), Nodes(1, Header) {} : Parent(Parent), IsPackaged(false), NumHeaders(1), Nodes(1, Header) {}
@ -945,7 +945,7 @@ public:
virtual raw_ostream &print(raw_ostream &OS) const { return OS; } virtual raw_ostream &print(raw_ostream &OS) const { return OS; }
void dump() const { print(dbgs()); } void dump() const { print(dbgs()); }
Float getFloatingBlockFreq(const BlockNode &Node) const; Scaled64 getFloatingBlockFreq(const BlockNode &Node) const;
BlockFrequency getBlockFreq(const BlockNode &Node) const; BlockFrequency getBlockFreq(const BlockNode &Node) const;
@ -1382,7 +1382,7 @@ public:
BlockFrequency getBlockFreq(const BlockT *BB) const { BlockFrequency getBlockFreq(const BlockT *BB) const {
return BlockFrequencyInfoImplBase::getBlockFreq(getNode(BB)); return BlockFrequencyInfoImplBase::getBlockFreq(getNode(BB));
} }
Float getFloatingBlockFreq(const BlockT *BB) const { Scaled64 getFloatingBlockFreq(const BlockT *BB) const {
return BlockFrequencyInfoImplBase::getFloatingBlockFreq(getNode(BB)); return BlockFrequencyInfoImplBase::getFloatingBlockFreq(getNode(BB));
} }

47
lib/Analysis/BlockFrequencyInfoImpl.cpp
View File

@ -216,7 +216,7 @@ void ScaledNumberBase::dump(uint64_t D, int16_t E, int Width) {
// BlockMass implementation. // BlockMass implementation.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
ScaledNumber<uint64_t> BlockMass::toFloat() const { ScaledNumber<uint64_t> BlockMass::toScaled() const {
if (isFull()) if (isFull())
return ScaledNumber<uint64_t>(1, 0); return ScaledNumber<uint64_t>(1, 0);
return ScaledNumber<uint64_t>(getMass() + 1, -64); return ScaledNumber<uint64_t>(getMass() + 1, -64);
@ -246,7 +246,7 @@ namespace {
typedef BlockFrequencyInfoImplBase::BlockNode BlockNode; typedef BlockFrequencyInfoImplBase::BlockNode BlockNode;
typedef BlockFrequencyInfoImplBase::Distribution Distribution; typedef BlockFrequencyInfoImplBase::Distribution Distribution;
typedef BlockFrequencyInfoImplBase::Distribution::WeightList WeightList; typedef BlockFrequencyInfoImplBase::Distribution::WeightList WeightList;
typedef BlockFrequencyInfoImplBase::Float Float; typedef BlockFrequencyInfoImplBase::Scaled64 Scaled64;
typedef BlockFrequencyInfoImplBase::LoopData LoopData; typedef BlockFrequencyInfoImplBase::LoopData LoopData;
typedef BlockFrequencyInfoImplBase::Weight Weight; typedef BlockFrequencyInfoImplBase::Weight Weight;
typedef BlockFrequencyInfoImplBase::FrequencyData FrequencyData; typedef BlockFrequencyInfoImplBase::FrequencyData FrequencyData;
@ -526,7 +526,7 @@ bool BlockFrequencyInfoImplBase::addLoopSuccessorsToDist(
/// ///
/// Gives the maximum number of estimated iterations allowed for a loop. Very /// Gives the maximum number of estimated iterations allowed for a loop. Very
/// large numbers cause problems downstream (even within 64-bits). /// large numbers cause problems downstream (even within 64-bits).
static Float getMaxLoopScale() { return Float(1, 12); } static Scaled64 getMaxLoopScale() { return Scaled64(1, 12); }
/// \brief Compute the loop scale for a loop. /// \brief Compute the loop scale for a loop.
void BlockFrequencyInfoImplBase::computeLoopScale(LoopData &Loop) { void BlockFrequencyInfoImplBase::computeLoopScale(LoopData &Loop) {
@ -538,7 +538,7 @@ void BlockFrequencyInfoImplBase::computeLoopScale(LoopData &Loop) {
BlockMass ExitMass = BlockMass::getFull() - Loop.BackedgeMass; BlockMass ExitMass = BlockMass::getFull() - Loop.BackedgeMass;
// Block scale stores the inverse of the scale. // Block scale stores the inverse of the scale.
Loop.Scale = ExitMass.toFloat().inverse(); Loop.Scale = ExitMass.toScaled().inverse();
DEBUG(dbgs() << " - exit-mass = " << ExitMass << " (" << BlockMass::getFull() DEBUG(dbgs() << " - exit-mass = " << ExitMass << " (" << BlockMass::getFull()
<< " - " << Loop.BackedgeMass << ")\n" << " - " << Loop.BackedgeMass << ")\n"
@ -612,15 +612,16 @@ void BlockFrequencyInfoImplBase::distributeMass(const BlockNode &Source,
} }
static void convertFloatingToInteger(BlockFrequencyInfoImplBase &BFI, static void convertFloatingToInteger(BlockFrequencyInfoImplBase &BFI,
const Float &Min, const Float &Max) { const Scaled64 &Min, const Scaled64 &Max) {
// Scale the Factor to a size that creates integers. Ideally, integers would // Scale the Factor to a size that creates integers. Ideally, integers would
// be scaled so that Max == UINT64_MAX so that they can be best // be scaled so that Max == UINT64_MAX so that they can be best
// differentiated. However, the register allocator currently deals poorly // differentiated. However, the register allocator currently deals poorly
// with large numbers. Instead, push Min up a little from 1 to give some // with large numbers. Instead, push Min up a little from 1 to give some
// room to differentiate small, unequal numbers. // room to differentiate small, unequal numbers.
// //
// TODO: fix issues downstream so that ScalingFactor can be Float(1,64)/Max. // TODO: fix issues downstream so that ScalingFactor can be
Float ScalingFactor = Min.inverse(); // Scaled64(1,64)/Max.
Scaled64 ScalingFactor = Min.inverse();
if ((Max / Min).lg() < 60) if ((Max / Min).lg() < 60)
ScalingFactor <<= 3; ScalingFactor <<= 3;
@ -628,10 +629,10 @@ static void convertFloatingToInteger(BlockFrequencyInfoImplBase &BFI,
DEBUG(dbgs() << "float-to-int: min = " << Min << ", max = " << Max DEBUG(dbgs() << "float-to-int: min = " << Min << ", max = " << Max
<< ", factor = " << ScalingFactor << "\n"); << ", factor = " << ScalingFactor << "\n");
for (size_t Index = 0; Index < BFI.Freqs.size(); ++Index) { for (size_t Index = 0; Index < BFI.Freqs.size(); ++Index) {
Float Scaled = BFI.Freqs[Index].Floating * ScalingFactor; Scaled64 Scaled = BFI.Freqs[Index].Scaled * ScalingFactor;
BFI.Freqs[Index].Integer = std::max(UINT64_C(1), Scaled.toInt<uint64_t>()); BFI.Freqs[Index].Integer = std::max(UINT64_C(1), Scaled.toInt<uint64_t>());
DEBUG(dbgs() << " - " << BFI.getBlockName(Index) << ": float = " DEBUG(dbgs() << " - " << BFI.getBlockName(Index) << ": float = "
<< BFI.Freqs[Index].Floating << ", scaled = " << Scaled << BFI.Freqs[Index].Scaled << ", scaled = " << Scaled
<< ", int = " << BFI.Freqs[Index].Integer << "\n"); << ", int = " << BFI.Freqs[Index].Integer << "\n");
} }
} }
@ -644,7 +645,7 @@ static void unwrapLoop(BlockFrequencyInfoImplBase &BFI, LoopData &Loop) {
DEBUG(dbgs() << "unwrap-loop-package: " << BFI.getLoopName(Loop) DEBUG(dbgs() << "unwrap-loop-package: " << BFI.getLoopName(Loop)
<< ": mass = " << Loop.Mass << ", scale = " << Loop.Scale << ": mass = " << Loop.Mass << ", scale = " << Loop.Scale
<< "\n"); << "\n");
Loop.Scale *= Loop.Mass.toFloat(); Loop.Scale *= Loop.Mass.toScaled();
Loop.IsPackaged = false; Loop.IsPackaged = false;
DEBUG(dbgs() << " => combined-scale = " << Loop.Scale << "\n"); DEBUG(dbgs() << " => combined-scale = " << Loop.Scale << "\n");
@ -653,9 +654,9 @@ static void unwrapLoop(BlockFrequencyInfoImplBase &BFI, LoopData &Loop) {
// final head scale will be used for updated the rest of the members. // final head scale will be used for updated the rest of the members.
for (const BlockNode &N : Loop.Nodes) { for (const BlockNode &N : Loop.Nodes) {
const auto &Working = BFI.Working[N.Index]; const auto &Working = BFI.Working[N.Index];
Float &F = Working.isAPackage() ? Working.getPackagedLoop()->Scale Scaled64 &F = Working.isAPackage() ? Working.getPackagedLoop()->Scale
: BFI.Freqs[N.Index].Floating; : BFI.Freqs[N.Index].Scaled;
Float New = Loop.Scale * F; Scaled64 New = Loop.Scale * F;
DEBUG(dbgs() << " - " << BFI.getBlockName(N) << ": " << F << " => " << New DEBUG(dbgs() << " - " << BFI.getBlockName(N) << ": " << F << " => " << New
<< "\n"); << "\n");
F = New; F = New;
@ -665,7 +666,7 @@ static void unwrapLoop(BlockFrequencyInfoImplBase &BFI, LoopData &Loop) {
void BlockFrequencyInfoImplBase::unwrapLoops() { void BlockFrequencyInfoImplBase::unwrapLoops() {
// Set initial frequencies from loop-local masses. // Set initial frequencies from loop-local masses.
for (size_t Index = 0; Index < Working.size(); ++Index) for (size_t Index = 0; Index < Working.size(); ++Index)
Freqs[Index].Floating = Working[Index].Mass.toFloat(); Freqs[Index].Scaled = Working[Index].Mass.toScaled();
for (LoopData &Loop : Loops) for (LoopData &Loop : Loops)
unwrapLoop(*this, Loop); unwrapLoop(*this, Loop);
@ -674,12 +675,12 @@ void BlockFrequencyInfoImplBase::unwrapLoops() {
void BlockFrequencyInfoImplBase::finalizeMetrics() { void BlockFrequencyInfoImplBase::finalizeMetrics() {
// Unwrap loop packages in reverse post-order, tracking min and max // Unwrap loop packages in reverse post-order, tracking min and max
// frequencies. // frequencies.
auto Min = Float::getLargest(); auto Min = Scaled64::getLargest();
auto Max = Float::getZero(); auto Max = Scaled64::getZero();
for (size_t Index = 0; Index < Working.size(); ++Index) { for (size_t Index = 0; Index < Working.size(); ++Index) {
// Update min/max scale. // Update min/max scale.
Min = std::min(Min, Freqs[Index].Floating); Min = std::min(Min, Freqs[Index].Scaled);
Max = std::max(Max, Freqs[Index].Floating); Max = std::max(Max, Freqs[Index].Scaled);
} }
// Convert to integers. // Convert to integers.
@ -698,11 +699,11 @@ BlockFrequencyInfoImplBase::getBlockFreq(const BlockNode &Node) const {
return 0; return 0;
return Freqs[Node.Index].Integer; return Freqs[Node.Index].Integer;
} }
Float Scaled64
BlockFrequencyInfoImplBase::getFloatingBlockFreq(const BlockNode &Node) const { BlockFrequencyInfoImplBase::getFloatingBlockFreq(const BlockNode &Node) const {
if (!Node.isValid()) if (!Node.isValid())
return Float::getZero(); return Scaled64::getZero();
return Freqs[Node.Index].Floating; return Freqs[Node.Index].Scaled;
} }
std::string std::string
@ -723,8 +724,8 @@ BlockFrequencyInfoImplBase::printBlockFreq(raw_ostream &OS,
raw_ostream & raw_ostream &
BlockFrequencyInfoImplBase::printBlockFreq(raw_ostream &OS, BlockFrequencyInfoImplBase::printBlockFreq(raw_ostream &OS,
const BlockFrequency &Freq) const { const BlockFrequency &Freq) const {
Float Block(Freq.getFrequency(), 0); Scaled64 Block(Freq.getFrequency(), 0);
Float Entry(getEntryFreq(), 0); Scaled64 Entry(getEntryFreq(), 0);
return OS << Block / Entry; return OS << Block / Entry;
} }