From 32bdd4ea65f58e3227176b9a5a43013fb13f06a5 Mon Sep 17 00:00:00 2001 From: Alkis Evlogimenos Date: Sat, 31 Jan 2004 04:56:07 +0000 Subject: [PATCH] Several performance enhancements and cleanups from Chris. Simplification of LiveIntervals::Interval::overlaps() and addition of examples to overlaps() and liveAt() to make them clearer. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11028 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/LiveIntervalAnalysis.h | 20 +- include/llvm/CodeGen/LiveIntervals.h | 20 +- lib/CodeGen/LiveIntervalAnalysis.cpp | 210 ++++++++++---------- lib/CodeGen/LiveIntervalAnalysis.h | 20 +- 4 files changed, 135 insertions(+), 135 deletions(-) diff --git a/include/llvm/CodeGen/LiveIntervalAnalysis.h b/include/llvm/CodeGen/LiveIntervalAnalysis.h index 7cf627b3558..59441fb3bb8 100644 --- a/include/llvm/CodeGen/LiveIntervalAnalysis.h +++ b/include/llvm/CodeGen/LiveIntervalAnalysis.h @@ -13,8 +13,8 @@ // for register v if there is no instruction with number j' > j such // that v is live at j' abd there is no instruction with number i' < i // such that v is live at i'. In this implementation intervals can -// have holes, i.e. an interval might look like [1,20], [50,65], -// [1000,1001] +// have holes, i.e. an interval might look like [1,20), [50,65), +// [1000,1001) // //===----------------------------------------------------------------------===// @@ -22,11 +22,7 @@ #define LLVM_CODEGEN_LIVEINTERVALS_H #include "llvm/CodeGen/MachineFunctionPass.h" -#include "llvm/CodeGen/MachineBasicBlock.h" -#include #include -#include -#include namespace llvm { @@ -113,6 +109,10 @@ namespace llvm { public: virtual void getAnalysisUsage(AnalysisUsage &AU) const; + virtual void releaseMemory(); + + /// runOnMachineFunction - pass entry point + virtual bool runOnMachineFunction(MachineFunction&); Intervals& getIntervals() { return intervals_; } @@ -134,9 +134,6 @@ namespace llvm { unsigned rep(unsigned reg); private: - /// runOnMachineFunction - pass entry point - bool runOnMachineFunction(MachineFunction&); - /// computeIntervals - compute live intervals void computeIntervals(); @@ -164,7 +161,10 @@ namespace llvm { bool overlapsAliases(const Interval& lhs, const Interval& rhs) const; - unsigned getInstructionIndex(MachineInstr* instr) const; + unsigned getInstructionIndex(MachineInstr* instr) const { + assert(mi2iMap_.count(instr) && "instruction not assigned a number"); + return mi2iMap_.find(instr)->second; + } void printRegName(unsigned reg) const; }; diff --git a/include/llvm/CodeGen/LiveIntervals.h b/include/llvm/CodeGen/LiveIntervals.h index 7cf627b3558..59441fb3bb8 100644 --- a/include/llvm/CodeGen/LiveIntervals.h +++ b/include/llvm/CodeGen/LiveIntervals.h @@ -13,8 +13,8 @@ // for register v if there is no instruction with number j' > j such // that v is live at j' abd there is no instruction with number i' < i // such that v is live at i'. In this implementation intervals can -// have holes, i.e. an interval might look like [1,20], [50,65], -// [1000,1001] +// have holes, i.e. an interval might look like [1,20), [50,65), +// [1000,1001) // //===----------------------------------------------------------------------===// @@ -22,11 +22,7 @@ #define LLVM_CODEGEN_LIVEINTERVALS_H #include "llvm/CodeGen/MachineFunctionPass.h" -#include "llvm/CodeGen/MachineBasicBlock.h" -#include #include -#include -#include namespace llvm { @@ -113,6 +109,10 @@ namespace llvm { public: virtual void getAnalysisUsage(AnalysisUsage &AU) const; + virtual void releaseMemory(); + + /// runOnMachineFunction - pass entry point + virtual bool runOnMachineFunction(MachineFunction&); Intervals& getIntervals() { return intervals_; } @@ -134,9 +134,6 @@ namespace llvm { unsigned rep(unsigned reg); private: - /// runOnMachineFunction - pass entry point - bool runOnMachineFunction(MachineFunction&); - /// computeIntervals - compute live intervals void computeIntervals(); @@ -164,7 +161,10 @@ namespace llvm { bool overlapsAliases(const Interval& lhs, const Interval& rhs) const; - unsigned getInstructionIndex(MachineInstr* instr) const; + unsigned getInstructionIndex(MachineInstr* instr) const { + assert(mi2iMap_.count(instr) && "instruction not assigned a number"); + return mi2iMap_.find(instr)->second; + } void printRegName(unsigned reg) const; }; diff --git a/lib/CodeGen/LiveIntervalAnalysis.cpp b/lib/CodeGen/LiveIntervalAnalysis.cpp index 75fcfd09ea9..ef1858725c5 100644 --- a/lib/CodeGen/LiveIntervalAnalysis.cpp +++ b/lib/CodeGen/LiveIntervalAnalysis.cpp @@ -17,24 +17,19 @@ #define DEBUG_TYPE "liveintervals" #include "llvm/CodeGen/LiveIntervals.h" -#include "llvm/Function.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/CodeGen/LiveVariables.h" #include "llvm/CodeGen/MachineFrameInfo.h" -#include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/SSARegMap.h" #include "llvm/Target/MRegisterInfo.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetMachine.h" -#include "llvm/Target/TargetRegInfo.h" #include "llvm/Support/CFG.h" #include "Support/CommandLine.h" #include "Support/Debug.h" -#include "Support/DepthFirstIterator.h" #include "Support/Statistic.h" -#include #include #include @@ -45,6 +40,7 @@ namespace { "Live Interval Analysis"); Statistic<> numIntervals("liveintervals", "Number of intervals"); + Statistic<> numJoined ("liveintervals", "Number of intervals joined"); cl::opt join("join-liveintervals", @@ -63,6 +59,16 @@ void LiveIntervals::getAnalysisUsage(AnalysisUsage &AU) const MachineFunctionPass::getAnalysisUsage(AU); } +void LiveIntervals::releaseMemory() +{ + mbbi2mbbMap_.clear(); + mi2iMap_.clear(); + r2iMap_.clear(); + r2iMap_.clear(); + r2rMap_.clear(); + intervals_.clear(); +} + /// runOnMachineFunction - Register allocate the whole function /// bool LiveIntervals::runOnMachineFunction(MachineFunction &fn) { @@ -71,19 +77,13 @@ bool LiveIntervals::runOnMachineFunction(MachineFunction &fn) { tm_ = &fn.getTarget(); mri_ = tm_->getRegisterInfo(); lv_ = &getAnalysis(); - mbbi2mbbMap_.clear(); - mi2iMap_.clear(); - r2iMap_.clear(); - r2iMap_.clear(); - r2rMap_.clear(); - intervals_.clear(); // number MachineInstrs unsigned miIndex = 0; for (MachineFunction::iterator mbb = mf_->begin(), mbbEnd = mf_->end(); mbb != mbbEnd; ++mbb) { const std::pair& entry = - lv_->getMachineBasicBlockInfo(&*mbb); + lv_->getMachineBasicBlockInfo(mbb); bool inserted = mbbi2mbbMap_.insert(std::make_pair(entry.second, entry.first)).second; assert(inserted && "multiple index -> MachineBasicBlock"); @@ -107,20 +107,22 @@ bool LiveIntervals::runOnMachineFunction(MachineFunction &fn) { const MachineBasicBlock* mbb = mbbi; unsigned loopDepth = loopInfo.getLoopDepth(mbb->getBasicBlock()); - for (MachineBasicBlock::const_iterator mii = mbb->begin(), - mie = mbb->end(); mii != mie; ++mii) { - MachineInstr* mi = *mii; + if (loopDepth) { + for (MachineBasicBlock::const_iterator mii = mbb->begin(), + mie = mbb->end(); mii != mie; ++mii) { + MachineInstr* mi = *mii; - for (int i = mi->getNumOperands() - 1; i >= 0; --i) { - MachineOperand& mop = mi->getOperand(i); + for (int i = mi->getNumOperands() - 1; i >= 0; --i) { + MachineOperand& mop = mi->getOperand(i); - if (!mop.isVirtualRegister()) - continue; + if (!mop.isVirtualRegister()) + continue; - unsigned reg = mop.getAllocatedRegNum(); - Reg2IntervalMap::iterator r2iit = r2iMap_.find(reg); - assert(r2iit != r2iMap_.end()); - r2iit->second->weight += pow(10.0F, loopDepth); + unsigned reg = mop.getAllocatedRegNum(); + Reg2IntervalMap::iterator r2iit = r2iMap_.find(reg); + assert(r2iit != r2iMap_.end()); + r2iit->second->weight += pow(10.0F, loopDepth); + } } } } @@ -152,31 +154,27 @@ void LiveIntervals::handleVirtualRegisterDef(MachineBasicBlock* mbb, LiveVariables::VarInfo& vi = lv_->getVarInfo(reg); Interval* interval = 0; - Reg2IntervalMap::iterator r2iit = r2iMap_.find(reg); - if (r2iit == r2iMap_.end()) { + Reg2IntervalMap::iterator r2iit = r2iMap_.lower_bound(reg); + if (r2iit == r2iMap_.end() || r2iit->first != reg) { // add new interval intervals_.push_back(Interval(reg)); // update interval index for this register - bool inserted = - r2iMap_.insert(std::make_pair(reg, --intervals_.end())).second; - assert(inserted); + r2iMap_.insert(r2iit, std::make_pair(reg, --intervals_.end())); interval = &intervals_.back(); } else { interval = &*r2iit->second; } - for (MbbIndex2MbbMap::iterator - it = mbbi2mbbMap_.begin(), itEnd = mbbi2mbbMap_.end(); - it != itEnd; ++it) { - unsigned liveBlockIndex = it->first; - MachineBasicBlock* liveBlock = it->second; - if (liveBlockIndex < vi.AliveBlocks.size() && - vi.AliveBlocks[liveBlockIndex] && - !liveBlock->empty()) { - unsigned start = getInstructionIndex(liveBlock->front()); - unsigned end = getInstructionIndex(liveBlock->back()) + 1; - interval->addRange(start, end); + // iterate over all of the blocks that the variable is completely + // live in, adding them to the live interval + for (unsigned i = 0, e = vi.AliveBlocks.size(); i != e; ++i) { + if (vi.AliveBlocks[i]) { + MachineBasicBlock* mbb = lv_->getIndexMachineBasicBlock(i); + if (!mbb->empty()) { + interval->addRange(getInstructionIndex(mbb->front()), + getInstructionIndex(mbb->back())); + } } } @@ -207,62 +205,49 @@ void LiveIntervals::handlePhysicalRegisterDef(MachineBasicBlock* mbb, DEBUG(std::cerr << "\t\tregister: "; printRegName(reg)); unsigned start = getInstructionIndex(*mi); - unsigned end = start; + unsigned end = start + 1; // register can be dead by the instruction defining it but it can // only be killed by subsequent instructions - for (LiveVariables::killed_iterator ki = lv_->dead_begin(*mi), ke = lv_->dead_end(*mi); ki != ke; ++ki) { if (reg == ki->second) { - end = getInstructionIndex(ki->first) + 1; DEBUG(std::cerr << " dead\n"); goto exit; } } - ++mi; - for (MachineBasicBlock::iterator e = mbb->end(); mi != e; ++mi) { - for (LiveVariables::killed_iterator - ki = lv_->dead_begin(*mi), - ke = lv_->dead_end(*mi); - ki != ke; ++ki) { - if (reg == ki->second) { - end = getInstructionIndex(ki->first) + 1; - DEBUG(std::cerr << " dead\n"); - goto exit; + { + MachineBasicBlock::iterator e = mbb->end(); + do { + ++mi; + for (LiveVariables::killed_iterator + ki = lv_->killed_begin(*mi), + ke = lv_->killed_end(*mi); + ki != ke; ++ki) { + if (reg == ki->second) { + DEBUG(std::cerr << " killed\n"); + goto exit; + } } - } - - for (LiveVariables::killed_iterator - ki = lv_->killed_begin(*mi), - ke = lv_->killed_end(*mi); - ki != ke; ++ki) { - if (reg == ki->second) { - end = getInstructionIndex(ki->first) + 1; - DEBUG(std::cerr << " killed\n"); - goto exit; - } - } + ++end; + } while (mi != e); } + exit: assert(start < end && "did not find end of interval?"); - Reg2IntervalMap::iterator r2iit = r2iMap_.find(reg); - if (r2iit != r2iMap_.end()) { - Interval& interval = *r2iit->second; - interval.addRange(start, end); + Reg2IntervalMap::iterator r2iit = r2iMap_.lower_bound(reg); + if (r2iit != r2iMap_.end() && r2iit->first == reg) { + r2iit->second->addRange(start, end); } else { intervals_.push_back(Interval(reg)); - Interval& interval = intervals_.back(); // update interval index for this register - bool inserted = - r2iMap_.insert(std::make_pair(reg, --intervals_.end())).second; - assert(inserted); - interval.addRange(start, end); + r2iMap_.insert(r2iit, std::make_pair(reg, --intervals_.end())); + intervals_.back().addRange(start, end); } } @@ -282,16 +267,9 @@ void LiveIntervals::handleRegisterDef(MachineBasicBlock* mbb, } } -unsigned LiveIntervals::getInstructionIndex(MachineInstr* instr) const -{ - assert(mi2iMap_.find(instr) != mi2iMap_.end() && - "instruction not assigned a number"); - return mi2iMap_.find(instr)->second; -} - /// computeIntervals - computes the live intervals for virtual -/// registers. for some ordering of the machine instructions [1,N] a -/// live interval is an interval [i, j] where 1 <= i <= j <= N for +/// registers. for some ordering of the machine instructions [1,N) a +/// live interval is an interval [i, j) where 1 <= i <= j < N for /// which a variable is live void LiveIntervals::computeIntervals() { @@ -318,13 +296,9 @@ void LiveIntervals::computeIntervals() // handle explicit defs for (int i = instr->getNumOperands() - 1; i >= 0; --i) { + // handle register defs - build intervals MachineOperand& mop = instr->getOperand(i); - - if (!mop.isRegister()) - continue; - - // handle defs - build intervals - if (mop.isDef()) + if (mop.isRegister() && mop.isDef()) handleRegisterDef(mbb, mi, mop.getAllocatedRegNum()); } } @@ -424,6 +398,7 @@ void LiveIntervals::joinIntervals() intervals_.erase(dstInt); } } + ++numJoined; } } } @@ -434,7 +409,7 @@ void LiveIntervals::joinIntervals() DEBUG(for (Reg2RegMap::const_iterator i = r2rMap_.begin(), e = r2rMap_.end(); i != e; ++i) std::cerr << i->first << " -> " << i->second << '\n';); - + } bool LiveIntervals::overlapsAliases(const Interval& lhs, @@ -461,6 +436,15 @@ LiveIntervals::Interval::Interval(unsigned r) } +// This example is provided becaues liveAt() is non-obvious: +// +// this = [1,2), liveAt(1) will return false. The idea is that the +// variable is defined in 1 and not live after definition. So it was +// dead to begin with (defined but never used). +// +// this = [1,3), liveAt(2) will return false. The variable is used at +// 2 but 2 is the last use so the variable's allocated register is +// available for reuse. bool LiveIntervals::Interval::liveAt(unsigned index) const { Ranges::const_iterator r = ranges.begin(); @@ -472,13 +456,38 @@ bool LiveIntervals::Interval::liveAt(unsigned index) const return false; } +// This example is provided because overlaps() is non-obvious: +// +// 0: A = ... +// 1: B = ... +// 2: C = A + B ;; last use of A +// +// The live intervals should look like: +// +// A = [0, 3) +// B = [1, x) +// C = [2, y) +// +// A->overlaps(C) should return false since we want to be able to join +// A and C. bool LiveIntervals::Interval::overlaps(const Interval& other) const { Ranges::const_iterator i = ranges.begin(); + Ranges::const_iterator ie = ranges.end(); Ranges::const_iterator j = other.ranges.begin(); + Ranges::const_iterator je = other.ranges.end(); + + while (i != ie && j != je) { + if (i->first == j->first) { + return true; + } + else { + if (i->first > j->first) { + swap(i, j); + swap(ie, je); + } + assert(i->first < j->first); - while (i != ranges.end() && j != other.ranges.end()) { - if (i->first < j->first) { if ((i->second - 1) > j->first) { return true; } @@ -486,17 +495,6 @@ bool LiveIntervals::Interval::overlaps(const Interval& other) const ++i; } } - else if (j->first < i->first) { - if ((j->second - 1) > i->first) { - return true; - } - else { - ++j; - } - } - else { - return true; - } } return false; @@ -504,6 +502,7 @@ bool LiveIntervals::Interval::overlaps(const Interval& other) const void LiveIntervals::Interval::addRange(unsigned start, unsigned end) { + assert(start < end && "Invalid range to add!"); DEBUG(std::cerr << "\t\t\tadding range: [" << start <<','<< end << ") -> "); //assert(start < end && "invalid range?"); Range range = std::make_pair(start, end); @@ -548,12 +547,13 @@ LiveIntervals::Interval::mergeRangesForward(Ranges::iterator it) LiveIntervals::Interval::Ranges::iterator LiveIntervals::Interval::mergeRangesBackward(Ranges::iterator it) { - for (Ranges::iterator prev = it - 1; - it != ranges.begin() && it->first <= prev->second; ) { + while (it != ranges.begin()) { + Ranges::iterator prev = it - 1; + if (it->first > prev->second) break; + it->first = std::min(it->first, prev->first); it->second = std::max(it->second, prev->second); it = ranges.erase(prev); - prev = it - 1; } return it; diff --git a/lib/CodeGen/LiveIntervalAnalysis.h b/lib/CodeGen/LiveIntervalAnalysis.h index 7cf627b3558..59441fb3bb8 100644 --- a/lib/CodeGen/LiveIntervalAnalysis.h +++ b/lib/CodeGen/LiveIntervalAnalysis.h @@ -13,8 +13,8 @@ // for register v if there is no instruction with number j' > j such // that v is live at j' abd there is no instruction with number i' < i // such that v is live at i'. In this implementation intervals can -// have holes, i.e. an interval might look like [1,20], [50,65], -// [1000,1001] +// have holes, i.e. an interval might look like [1,20), [50,65), +// [1000,1001) // //===----------------------------------------------------------------------===// @@ -22,11 +22,7 @@ #define LLVM_CODEGEN_LIVEINTERVALS_H #include "llvm/CodeGen/MachineFunctionPass.h" -#include "llvm/CodeGen/MachineBasicBlock.h" -#include #include -#include -#include namespace llvm { @@ -113,6 +109,10 @@ namespace llvm { public: virtual void getAnalysisUsage(AnalysisUsage &AU) const; + virtual void releaseMemory(); + + /// runOnMachineFunction - pass entry point + virtual bool runOnMachineFunction(MachineFunction&); Intervals& getIntervals() { return intervals_; } @@ -134,9 +134,6 @@ namespace llvm { unsigned rep(unsigned reg); private: - /// runOnMachineFunction - pass entry point - bool runOnMachineFunction(MachineFunction&); - /// computeIntervals - compute live intervals void computeIntervals(); @@ -164,7 +161,10 @@ namespace llvm { bool overlapsAliases(const Interval& lhs, const Interval& rhs) const; - unsigned getInstructionIndex(MachineInstr* instr) const; + unsigned getInstructionIndex(MachineInstr* instr) const { + assert(mi2iMap_.count(instr) && "instruction not assigned a number"); + return mi2iMap_.find(instr)->second; + } void printRegName(unsigned reg) const; };