6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-18 13:34:04 +00:00
Code Issues Projects Releases Wiki Activity

Move more fragments of spill weight calculation into CalcSpillWeights.h

Browse Source 
Simplify the spill weight calculation a bit by bypassing
getApproximateInstructionCount() and using LiveInterval::getSize() directly.
This changes the computed spill weights, but only by a constant factor in each
function. It should not affect how spill weights compare against each other, and
so it shouldn't affect code generation.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125530 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jakob Stoklund Olesen 2011-02-14 23:15:38 +00:00
parent 3fc178ffda
commit eb9f040f0d
4 changed files with 25 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/llvm/CodeGen/CalcSpillWeights.h
View File

@ -20,6 +20,26 @@ namespace llvm {
class LiveIntervals;
class MachineLoopInfo;
/// normalizeSpillWeight - The spill weight of a live interval is computed as:
///
/// (sum(use freq) + sum(def freq)) / (K + size)
///
/// @param UseDefFreq Expected number of executed use and def instructions
/// per function call. Derived from block frequencies.
/// @param Size Size of live interval as returnexd by getSize()
///
static inline float normalizeSpillWeight(float UseDefFreq, unsigned Size) {
// The magic constant 200 corresponds to approx. 25 instructions since
// SlotIndexes allocate 8 slots per instruction.
//
// The constant is added to avoid depending too much on accidental SlotIndex
// gaps for small intervals. The effect is that small intervals have a spill
// weight that is mostly proportional to the number of uses, while large
// intervals get a spill weight that is closer to a use density.
//
return UseDefFreq / (Size + 200);
}
/// VirtRegAuxInfo - Calculate auxiliary information for a virtual
/// register such as its spill weight and allocation hint.
class VirtRegAuxInfo {

11
include/llvm/CodeGen/LiveIntervalAnalysis.h
View File

@ -75,14 +75,6 @@ namespace llvm {
// Calculate the spill weight to assign to a single instruction.
static float getSpillWeight(bool isDef, bool isUse, unsigned loopDepth);
// After summing the spill weights of all defs and uses, the final weight
// should be normalized, dividing the weight of the interval by its size.
// This encourages spilling of intervals that are large and have few uses,
// and discourages spilling of small intervals with many uses.
void normalizeSpillWeight(LiveInterval &li) {
li.weight /= getApproximateInstructionCount(li) + 25;
}
typedef Reg2IntervalMap::iterator iterator;
typedef Reg2IntervalMap::const_iterator const_iterator;
const_iterator begin() const { return r2iMap_.begin(); }
@ -461,9 +453,6 @@ namespace llvm {
DenseMap<unsigned,unsigned> &MBBVRegsMap,
std::vector<LiveInterval*> &NewLIs);
// Normalize the spill weight of all the intervals in NewLIs.
void normalizeSpillWeights(std::vector<LiveInterval*> &NewLIs);
static LiveInterval* createInterval(unsigned Reg);
void printInstrs(raw_ostream &O) const;

3
lib/CodeGen/CalcSpillWeights.cpp
View File

@ -174,8 +174,7 @@ void VirtRegAuxInfo::CalculateWeightAndHint(LiveInterval &li) {
totalWeight *= 0.5F;
}
li.weight = totalWeight;
lis_.normalizeSpillWeight(li);
li.weight = normalizeSpillWeight(totalWeight, li.getSize());
}
void VirtRegAuxInfo::CalculateRegClass(unsigned reg) {

7
lib/CodeGen/LiveIntervalAnalysis.cpp
View File

@ -20,6 +20,7 @@
#include "VirtRegMap.h"
#include "llvm/Value.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/CodeGen/CalcSpillWeights.h"
#include "llvm/CodeGen/LiveVariables.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineInstr.h"
@ -1706,10 +1707,10 @@ LiveIntervals::getSpillWeight(bool isDef, bool isUse, unsigned loopDepth) {
return (isDef + isUse) * lc;
}
void
LiveIntervals::normalizeSpillWeights(std::vector<LiveInterval*> &NewLIs) {
static void normalizeSpillWeights(std::vector<LiveInterval*> &NewLIs) {
for (unsigned i = 0, e = NewLIs.size(); i != e; ++i)
normalizeSpillWeight(*NewLIs[i]);
NewLIs[i]->weight =
normalizeSpillWeight(NewLIs[i]->weight, NewLIs[i]->getSize());
}
std::vector<LiveInterval*> LiveIntervals::