mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-25 14:32:53 +00:00
4eed756153
The main advantages here are way better heuristics, taking into account not just loop depth but also __builtin_expect and other static heuristics and will eventually learn how to use profile info. Most of the work in this patch is pushing the MachineBlockFrequencyInfo analysis into the right places. This is good for a 5% speedup on zlib's deflate (x86_64), there were some very unfortunate spilling decisions in its hottest loop in longest_match(). Other benchmarks I tried were mostly neutral. This changes register allocation in subtle ways, update the tests for it. 2012-02-20-MachineCPBug.ll was deleted as it's very fragile and the instruction it looked for was gone already (but the FileCheck pattern picked up unrelated stuff). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@184105 91177308-0d34-0410-b5e6-96231b3b80d8
82 lines
2.7 KiB
C++
82 lines
2.7 KiB
C++
//===---------------- lib/CodeGen/CalcSpillWeights.h ------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#ifndef LLVM_CODEGEN_CALCSPILLWEIGHTS_H
|
|
#define LLVM_CODEGEN_CALCSPILLWEIGHTS_H
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/CodeGen/SlotIndexes.h"
|
|
|
|
namespace llvm {
|
|
|
|
class LiveInterval;
|
|
class LiveIntervals;
|
|
class MachineBlockFrequencyInfo;
|
|
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 constant 25 instructions 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 + 25*SlotIndex::InstrDist);
|
|
}
|
|
|
|
/// VirtRegAuxInfo - Calculate auxiliary information for a virtual
|
|
/// register such as its spill weight and allocation hint.
|
|
class VirtRegAuxInfo {
|
|
MachineFunction &MF;
|
|
LiveIntervals &LIS;
|
|
const MachineLoopInfo &Loops;
|
|
const MachineBlockFrequencyInfo &MBFI;
|
|
DenseMap<unsigned, float> Hint;
|
|
public:
|
|
VirtRegAuxInfo(MachineFunction &mf, LiveIntervals &lis,
|
|
const MachineLoopInfo &loops,
|
|
const MachineBlockFrequencyInfo &mbfi)
|
|
: MF(mf), LIS(lis), Loops(loops), MBFI(mbfi) {}
|
|
|
|
/// CalculateWeightAndHint - (re)compute li's spill weight and allocation
|
|
/// hint.
|
|
void CalculateWeightAndHint(LiveInterval &li);
|
|
};
|
|
|
|
/// CalculateSpillWeights - Compute spill weights for all virtual register
|
|
/// live intervals.
|
|
class CalculateSpillWeights : public MachineFunctionPass {
|
|
public:
|
|
static char ID;
|
|
|
|
CalculateSpillWeights() : MachineFunctionPass(ID) {
|
|
initializeCalculateSpillWeightsPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &au) const;
|
|
|
|
virtual bool runOnMachineFunction(MachineFunction &fn);
|
|
|
|
private:
|
|
/// Returns true if the given live interval is zero length.
|
|
bool isZeroLengthInterval(LiveInterval *li) const;
|
|
};
|
|
|
|
}
|
|
|
|
#endif // LLVM_CODEGEN_CALCSPILLWEIGHTS_H
|